Merge lp:~widelands-dev/widelands/fh1-multitexture into lp:widelands

[GunChleoc]

The new font renderer now creates a set of textures that will be blitted separately by the new class RenderedText. This avoids issues with texture sizes exceeding the maximum size supported by graphics drivers when MultilineTextareas get arbitrarily long.

- Fixed positioning and scaling for census & statistics.
- Removed size restriction from FullscreenMenuLoadGame::filename_list_string().
- Got rid of BiDi spaghetti code in Table and Listselect
- As a side effect, this fixes the lag in Multilineeditbox with large texts and reduces the amount of needed cache memory.

Also, refactored the following classes and functions:
- text_height()
- Tooltips
- Game tips
- TabPanel

Notes:

1. There are 2 NOCOMs in this branch for testing purposes - need to be removed before merging.

2. Code review: Please pay special attention to memory management.

3. Testers: Pay attention to scrolling and alignment issues and possible wonky background colors. The messages sent by buildings have a row of dead trees in the background - this is for testing background images and will be removed before the merge.

Known issue: A line of text can start with a blank space. This issue is already in trunk and unrelated to this branch.

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 2172. State: passed. Details: https://travis-ci.org/widelands/widelands/builds/231241186.
Appveyor build 2007. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_fh1_multitexture-2007.

[kaputtnik (franku)]

Got a compiler warning:

/home/kaputtnik/Quellcode/widelands-repo/fh1-multitexture/src/graphic/text/rendered_text.cc:129:14: Warnung: unused variable »maximum_size« [-Wunused-variable]
    const int maximum_size = kMinimumSizeForTextures;
              ^~~~~~~~~~~~

And some crashes, but i am not sure if they are related to this branch, because trunk crashes also sometimes without a reason. One crash in this branch shows in console:

SaveHandler::save_game() took 659ms
Autosave: save took 660 ms
pure virtual method called
terminate called without an active exception
Abgebrochen (Speicherabzug geschrieben

Will try to get a backtrace...

[kaputtnik (franku)]

In the message box strings in the title column are not cut if they exceed the column width. Played the Warfare tutorial and the message 'Enemy defeated' is only cut at the image from the Type-column, not where the Title-column ends.

No crash so far... every time running with gdb i get no crash :-D

[GunChleoc (gunchleoc)]

Fixed the cropping, so this is now ready for review again.

review: Needs Resubmitting

[kaputtnik (franku)]

Got a crash:

Thread 1 "widelands" received signal SIGSEGV, Segmentation fault.
0x0000000000cfe5fd in RenderTarget::blit (this=0x1c03930, dst=..., image=0x803d538, blend_mode=BlendMode::UseAlpha,
    align=UI::Align::kLeft) at /home/kaputtnik/Quellcode/widelands-repo/fh1-multitexture/src/graphic/rendertarget.cc:151
151 UI::correct_for_align(align, image->width(), &destination_point);
(gdb) bt
#0 0x0000000000cfe5fd in RenderTarget::blit (this=0x1c03930, dst=..., image=0x803d538, blend_mode=BlendMode::UseAlpha,
    align=UI::Align::kLeft) at /home/kaputtnik/Quellcode/widelands-repo/fh1-multitexture/src/graphic/rendertarget.cc:151
#1 0x0000000000d4a5b1 in UI::RenderedText::draw (this=0x88adfb0, dst=..., position=..., region=..., align=UI::Align::kRight,
    cropmode=UI::RenderedText::CropMode::kRenderTarget)
    at /home/kaputtnik/Quellcode/widelands-repo/fh1-multitexture/src/graphic/text/rendered_text.cc:174
#2 0x0000000000d4a75e in UI::RenderedText::draw (this=0x88adfb0, dst=..., position=..., align=UI::Align::kRight)
    at /home/kaputtnik/Quellcode/widelands-repo/fh1-multitexture/src/graphic/text/rendered_text.cc:191
#3 0x0000000000fac3b9 in InteractiveGameBase::draw_overlay (this=0x9c77ce0, dst=...)
    at /home/kaputtnik/Quellcode/widelands-repo/fh1-multitexture/src/wui/interactive_gamebase.cc:130
#4 0x0000000000effd10 in UI::Panel::do_draw_inner (this=0x9c77ce0, dst=...)
    at /home/kaputtnik/Quellcode/widelands-repo/fh1-multitexture/src/ui_basic/panel.cc:733
#5 0x0000000000effe7d in UI::Panel::do_draw (this=0x9c77ce0, dst=...)
    at /home/kaputtnik/Quellcode/widelands-repo/fh1-multitexture/src/ui_basic/panel.cc:760
#6 0x0000000000efeafe in UI::Panel::do_run (this=0x9c77ce0)
    at /home/kaputtnik/Quellcode/widelands-repo/fh1-multitexture/src/ui_basic/panel.cc:192
#7 0x0000000000c578a0 in UI::Panel::run<UI::Panel::Returncodes> (this=0x9c77ce0)
    at /home/kaputtnik/Quellcode/widelands-repo/fh1-multitexture/src/ui_basic/panel.h:99
#8 0x0000000000d6b046 in Widelands::Game::run (this=0x7fffffffbe90, loader_ui=0x7fffffffa280, start_game_type=Widelands::Game::Loaded,
    script_to_run="", replay=false, prefix_for_replays="single_player")
    at /home/kaputtnik/Quellcode/widelands-repo/fh1-multitexture/src/logic/game.cc:524
#9 0x0000000000d6a4a0 in Widelands::Game::run_load_game (this=0x7fffffffbe90, filename="save/test.wgf", script_to_run="")
    at /home/kaputtnik/Quellcode/widelands-repo/fh1-multitexture/src/logic/game.cc:381
#10 0x0000000000c52396 in WLApplication::load_game (this=0x1991790)
    at /home/kaputtnik/Quellcode/widelands-repo/fh1-multitexture/src/wlapplication.cc:1278
#11 0x0000000000c513ee in WLApplication::mainmenu_singleplayer (this=0x1991790)
    at /home/kaputtnik/Quellcode/widelands-repo/fh1-multitexture/src/wlapplication.cc:1107
#12 0x0000000000c50dd8...

[kaputtnik (franku)]

Got another crash in RenderTarget::blit() related to kCensus and kStatistics similar to https://bugs.launchpad.net/widelands/+bug/1690519/comments/6

Those bugs appear after playing a while. Could not say if i played an hour or longer using mostly 3x speed or 5x speed in fullscreen mode (initial resolution 1440x900).

[Klaus Halfmann (klaus-halfmann)]

I think that render_cache_ need a bit more attention:
 * explian what this actually maps
 * what is the cachek poliy (e.g. when will object be removed?)
 * why do you use an (additional) std::unique_ptr if the make already makes this unique?
 * if its not small it deserverves some presizing.

Some comments inline, but I need more time to read this ....

[GunChleoc (gunchleoc)]

Thanks for taking on this review :)

 * explian what this actually maps

It keeps rendered text so that we won't have to render it again - rendering is expensive, especially for complex stuff like the help windows. And some text images are reused a lot, e.g. the census and statistics strings.

 * what is the cachek poliy (e.g. when will object be removed?)

Just like with the main image cache and the animation cache, objects are never removed. I guess we could have a flush function if the memory consumption should get too big and that could be called at strategic points, e.g. when switching between fullscreen menu and game.

 * why do you use an (additional) std::unique_ptr if the make already makes this unique?

I don't know what you mean. Are you misreading make_pair as make_unique here?

 * if its not small it deserverves some presizing.

You mean as is already done in texture_cache_(new TextureCache(kTextureCacheSize))?

I have also added comments to your in-line comments.

[GunChleoc (gunchleoc)]

@kaputtnik: Yes, that looks like the same crash.

[GunChleoc (gunchleoc)]

I have now looked at the code for the TextureCache (which I didn't write) and it does indeed automatically drop the oldest entries to ensure that its size is not exceeded.

I have also added some asserts (to help track down the crash), and made the nullptr comparisons explicit (maybe this will make it go away).

[Klaus Halfmann (klaus-halfmann)]

Gun: please add the comments in the code,
the next reader will not find it here :-)

What I did not get about the cache is:
For every Text (and width) it stores the Image to render it.

So If I open all dialogs in every language one after the other,
the cache will contain all the Images? Will this include
user generated strings as well? Such szenarios could make
the cache explode.

In general such cahes should me somewhat elastic:
* user LRU to drop old, rarely used entries
* reduze size when memory is getting low
  (e.g. malloc starts to retun null)

Do you have some debugoutput about the size consumptions?
Is there some tescase that switches through all lanaguages
and open all dialogs?

P.S. I now got a newer, faster mac, but I needed today to migrate everything ...

[Klaus Halfmann (klaus-halfmann)]

On tip about int <-> flot conversion:
As of modern processsors this is quiten expensive,
as this involves the otherwise decupled int and float computing unita.

e.g. Rectf(0.0f, 0.0f, width, height) would be better.

In this particular case the compiler should optimize this away of cause.

lets go on reading the code.

[Klaus Halfmann (klaus-halfmann)]

Checked the lower 50% of the chnages now, still not complete.

The code reads much better (some exceptions inline).

please comment what happens with scaling and in the chat window.

will try to play now with different scalings and check lots of dialogs
(english and german only).

Will the font cache be active inside a Gmae only of for the liftime of
the Programm?

[kaputtnik (franku)]

Crashed again (r8200) after playing a while. Just followed an expedition ship exploring the world. Opened windows: Stock and Expedition. Unfortunately no asserts:

Autosave: save took 1591 ms
TrainingSite::drop_stalled_soldiers: Kicking somebody out.
TrainingSite::drop_stalled_soldiers: Kicking somebody out.
TrainingSite::drop_stalled_soldiers: Kicking somebody out.
TrainingSite::drop_stalled_soldiers: Kicking somebody out.

Thread 1 "widelands" received signal SIGSEGV, Segmentation fault.
0x0000000007abea00 in ?? ()
(gdb) bt
#0 0x0000000007abea00 in ?? ()
#1 0x0000000000cff86f in RenderTarget::blit (this=0x78078b0, dst=..., image=0x7abea18, blend_mode=BlendMode::UseAlpha,
    align=UI::Align::kLeft) at /home/kaputtnik/Quellcode/widelands-repo/fh1-multitexture/src/graphic/rendertarget.cc:152
#2 0x0000000000d4b86f in UI::RenderedText::draw (this=0x7a3e950, dst=..., position=..., region=..., align=UI::Align::kCenter,
    cropmode=UI::RenderedText::CropMode::kRenderTarget)
    at /home/kaputtnik/Quellcode/widelands-repo/fh1-multitexture/src/graphic/text/rendered_text.cc:174
#3 0x0000000000d4ba1c in UI::RenderedText::draw (this=0x7a3e950, dst=..., position=..., align=UI::Align::kCenter)
    at /home/kaputtnik/Quellcode/widelands-repo/fh1-multitexture/src/graphic/text/rendered_text.cc:191
#4 0x0000000000f1f907 in UI::Window::draw_border (this=0x7d0b9e0, dst=...)
    at /home/kaputtnik/Quellcode/widelands-repo/fh1-multitexture/src/ui_basic/window.cc:281
#5 0x0000000000f010f9 in UI::Panel::do_draw (this=0x7d0b9e0, dst=...)
    at /home/kaputtnik/Quellcode/widelands-repo/fh1-multitexture/src/ui_basic/panel.cc:754
#6 0x0000000000f01004 in UI::Panel::do_draw_inner (this=0x2331ee0, dst=...)
    at /home/kaputtnik/Quellcode/widelands-repo/fh1-multitexture/src/ui_basic/panel.cc:731
#7 0x0000000000f0119d in UI::Panel::do_draw (this=0x2331ee0, dst=...)
    at /home/kaputtnik/Quellcode/widelands-repo/fh1-multitexture/src/ui_basic/panel.cc:760
#8 0x0000000000effe1e in UI::Panel::do_run (this=0x2331ee0)
    at /home/kaputtnik/Quellcode/widelands-repo/fh1-multitexture/src/ui_basic/panel.cc:192
#9 0x0000000000c58af0 in UI::Panel::run<UI::Panel::Returnc...

[GunChleoc (gunchleoc)]

If you click on "Show diff comments" for a post, the diff will switch to the appropriate revision so you can see them.

Answers to your comments inline - I added all important comments to the code as well. I will also replace the 0's with 0.f for the Rectf calls.

I think the caching model is generally broken and also the cause of the cache. The textures are kept in a cache that can overflow, so the RenderedText has references to objects that have been destroyed by the TextureCache. I think that I need to do the following 2 things:

- Turn the TextureCache into a templated object por mimic the code, so we will have an upper size limit for both the small textures within a text and the while RenderedText, and maximum reuse of computed textures at the same time,

- Replace unique_ptr with shared_ptr. This way, when an texture is removed from the cache, it won't be destroyed if a RenderedText is still using it. Furthermore, some UI elements prerender their texts and keep them for their lifetime, so those objects need to share ownership as well. I think the only reason that this particular problem hasn't blown up in our faces yet is that the texture cache never overflows in Build 19.

[GunChleoc (gunchleoc)]

OK, this went faster than expected. We now have a templated class TransientCache that hands out shared_ptrs to everyone. It's a bit heavy in the header, but there was no obvious split into header/cc file because of the templating.

I have also added some log output when the cache overflows. I haven't seen a log message yet, but that might change once we move more stuff to the new renderer. The cache size can be tweaked then.

[GunChleoc (gunchleoc)]

Added some more small tweaks, and this is hopefully done now. Let's get a new diff.

review: Needs Resubmitting

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 2237. State: passed. Details: https://travis-ci.org/widelands/widelands/builds/234607244.
Appveyor build 2072. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_fh1_multitexture-2072.

[Klaus Halfmann (klaus-halfmann)]

OK, compile your code but will now go down to kTextureCacheSize = 5 << 20
or even further untill I find some logs and/or the cache flutters.

Now lets start reading again ...

[Klaus Halfmann (klaus-halfmann)]

Checked the code from the top to about 50%, some comments inline.
Did not find the logging, yet.

wil now play a bit with the reduced cache size.

[Klaus Halfmann (klaus-halfmann)]

Ahh, now I see what the cache ist used for:

TransientCache: Dropping 2 bytes, new size 4094. Hash: 0<rt><p align=left><font face=condensed size=14 bold=1 shadow=1 color=ffff00>05:08</font></p></rt>
TransientCache: Dropping 2 bytes, new size 4092. Hash: 0<rt><p align=left><font face=condensed size=14 bold=1 shadow=1 color=ffff00>05:09</font></p></rt>
TransientCache: Dropping 2 bytes, new size 4090. Hash: 0<rt><p align=left><font face=condensed size=14 bold=1 shadow=1 color=ffff00>05:10</font></p></rt>
TransientCache: Dropping 2 bytes, new size 4088. Hash: 0<rt><p align=left><font face=condensed size=14 bold=1 shadow=1 color=ffff00>05:11</font></p></rt>
TransientCache: Dropping 2 bytes, new size 4086. Hash: 0<rt><p align=left><font face=condensed size=14 bold=1 shadow=1 color=ffff00>05:12</font></p></rt>
TransientCache: Dropping 1 bytes, new size 4085. Hash: 317<rt><p align=left><font face=sans size=14 bold=1 shadow=1 color=ffff00></font></p></rt>
TransientCache: Dropping 2 bytes, new size 4083. Hash: 0<rt><p align=left><font face=condensed size=14 bold=1 shadow=1 color=ffff00>05:13</font></p></rt>
TransientCache: Dropping 2 bytes, new size 4081. Hash: 0<rt><p align=left><font face=condensed size=14 bold=1 shadow=1 color=ffff00>05:14</font></p></rt>
TransientCache: Dropping 2 bytes, new size 4079. Hash: 0<rt><p align=left><font face=condensed size=14 bold=1 shadow=1 color=ffff00>05:15</font></p></rt>
TransientCache: Dropping 4176 bytes, new size 5230440. Hash: ttf:DejaVu/DejaVuSans-Bold.ttf:14:Teams::ffff00:8
TransientCache: Dropping 4 bytes, new size 4091. Hash: 0<rt><p align=left><font face=sans size=13 bold=1 shadow=1 color=ffff00>Nachrichten: Posteingang</font></p></rt>
TransientCache: Dropping 3744 bytes, new size 5236416. Hash: ttf:DejaVu/DejaVuSans-Bold.ttf:14:Autor::ffff00:8

So this is the gametime, the fps display and such.

Is this wise?
Do you have a chache hit ratio computed somewhere?

Me will ponder this the next days :-)

[kaputtnik (franku)]

This looks really good now :-)

Played an hour or so but no crash anymore. The output of 'new size' is a bit annoying, i guess it switches between Kilobytes and Bytes (?):

TransientCache: Dropping 11 bytes, new size 4082. [...]
TransientCache: Dropping 4032 bytes, new size 31452972. [...]
[...]
TransientCache: Dropping 4 bytes, new size 4092.

But it never exceeds the size of 4093 (as far as i can see).

There are a lot of such outputs if you just move the mouse around, also moving the mouse on black areas. Don't know if this much processor time consuming. Maybe here is a chance of optimization?

review: Approve (testing)

[kaputtnik (franku)]

Ah, forgotton:

There is still the compiler warning about the unused variable 'maximum_size' as decribed in my first post here.

[GunChleoc (gunchleoc)]

I have now removed all the temporary testing stuff, so the compiler warning and the "TransientCache: Dropping" output should be gone now.

I have only commented out the log output in "graphic/text/transient_cache.h", so it can easily be activated again for further tweaking of the cache size.

From my testing, the current cache sizes allow for loading 22 maps in the map selection screen before they start dropping entries. In-game dropping of textures only started after quite a lot of text was generated by mousing over things. Typing 500+ characters in a Multilineeditbox did not trigger texture dropping.

[Klaus Halfmann (klaus-halfmann)]

I got some compile warning we should not neglect:

fh1-multitexture/src/graphic/text/transient_cache.h:48:2: warning: 'TransientCache<Image>' has virtual functions but non-virtual
      destructor [-Wnon-virtual-dtor]
        ~TransientCache();

in general when subclassing and using a parent pointer the correct Destructor will not be called.

fh1-multitexture/src/logic/editor_game_base.h:39:1: warning: struct 'FullscreenMenuLaunchGame' was previously declared as a class
      [-Wmismatched-tags]
struct FullscreenMenuLaunchGame;
^
fh1-multitexture/src/ui_fsmenu/launch_game.h:44:7: note: previous use is here
class FullscreenMenuLaunchGame : public FullscreenMenuBase {

fh1-multitexture/src/network/network.h:122:9: warning: struct 'Deserializer' was previously declared as a class [-Wmismatched-tags]
        friend struct Deserializer;
               ^
fh1-multitexture/src/network/network.h:36:7: note: previous use is here
class Deserializer;

Are there functions limited to float only?

fh1-multitexture/src/logic/map_objects/map_object.cc:468:40: warning: implicit conversion increases floating-point precision: 'float' to 'double' [-Wdouble-promotion]
        scale = std::round(2 * (scale > 1.f ? std::sqrt(scale) : std::pow(scale, 2))) / 2;

No idea about these, SirVer may tell us?

fh1-multitexture/src/graphic/font_handler1.cc:90:48: warning: moving a temporary object prevents copy elision [-Wpessimizing-move]
                        rendered_text = render_cache_->insert(hash, std::move(rt_renderer_->render(text, w)));
                                                                    ^
fh1-multitexture/src/graphic/font_handler1.cc:90:48: note: remove std::move call here
                        rendered_text = render_cache_->insert(hash, std::move(rt_renderer_->render(text, w)));

Sorry no time to check more code tonight, will just play that branch a bit ....

[GunChleoc (gunchleoc)]

Thanks for the review! I have hopefully fixed the compiler warnings now - we'll just have to wait what clang says.

I also addressed your points from a few posts up and added some more documentation to the RendererText header file - I hope it will make the code a bit more clear. Yes, it's a bit complicated due to the cropping involved.

2 notes:

1. CropMode::kVertical doesn't exist because CropMode::kHorizontal was a stupid name. I went with kSelf now. Btter ideas are welcome :)

2. Re. better replace true / false by kBackGroundColorSet and !kBackGroundColorSet or such: While I generally prefer enum classes over bools myself, I think it would actually make the code harder to read in this instance, because there is no "else" branch when it is checked. This bool is only ever assigned in the private constructors, so it shouldn't cause any interface readability issues.

[GunChleoc (gunchleoc)]

> Do you have a chache hit ratio computed somewhere?

No, I just used the log output to experiment a bit to find an acceptable value. Since we have 2 caches now, I made one really big while testing the other and vice versa.

BTW the gametime being kicked out is perfectly OK, since it counts up, so the old gametime texture definitely isn't needed any more. The cache also bumps entries when they are accessed, so those textures that have gone the longest without being used are the first to be removed when it overflows.

[Klaus Halfmann (klaus-halfmann)]

Thx, the warning are gone, we still have some, but I will addres them in the next branch,
so we get get this in.

Will it be possible to exclude some Texts/Textures from Caching?
e.g. the current game time or any other text we know will change the next time we draw it.

will not have time for more code rewiew till perhpas the weekend.

[Klaus Halfmann (klaus-halfmann)]

Now I got a crash after playing for perhaps 10 Minutes?

Thread 0 Crashed:: Dispatch queue: com.apple.main-thread
0 widelands 0x00000001042abba5 Widelands::Request::transfer_finish(Widelands::Game&, Widelands::Transfer&) + 69 (request.cc:418)
1 widelands 0x00000001042bc8c2 Widelands::Transfer::has_finished() + 50 (transfer.cc:222)
2 widelands 0x00000001042becad Widelands::WareInstance::enter_building(Widelands::Game&, Widelands::Building&) + 157 (ware_instance.cc:376)
3 widelands 0x0000000103bb77d9 Widelands::Carrier::deliver_to_building(Widelands::Game&, Widelands::Bob::State&) + 409 (carrier.cc:213)
4 widelands 0x0000000103bb72cb Widelands::Carrier::transport_update(Widelands::Game&, Widelands::Bob::State&) + 971 (carrier.cc:160)
5 widelands 0x0000000103b5cb51 Widelands::Bob::do_act(Widelands::Game&) + 337 (bob.cc:196)

Uhm.. perhpas I can reproduce that one?

[Klaus Halfmann (klaus-halfmann)]

playes another on > 1h, no Problems. so far for determistic machines.

[GunChleoc (gunchleoc)]

The newest crash looks like it's coming from WareInstance::cleanup - there's a naked delete statement in there. Doesn't seem related to the font renderer.

[GunChleoc (gunchleoc)]

> Will it be possible to exclude some Texts/Textures from Caching?

I think that would be overkill. This would mean carrying a parameter through quite a lot of functions until it reaches the point where it's checked for, for very little gain.

Let's say our cache looks like this:

A - B - C - D

Then we need B again, this will make the cache like like this:

A - C - D - B

Then let's say it's full and we add something new, the cache will now look like this:

C - D - B - E
D - B - E - F

So, the frequently-used B has not been dropped yet, although C was originally generated after B was generated.

I think this is efficient enough for reuse.

[Klaus Halfmann (klaus-halfmann)]

Will we need a resubmit fro travis to kick in?
Looks I now have time to do a full review and some Debugging.

[Klaus Halfmann (klaus-halfmann)]

OK for me now, we should get this in and try to find those nasty crashes in trunk.
I still do not get the whole story, though. Would like to see bunnybot again.

Will continue with that net-boost-asio next.

review: Approve (code review, compile, test)

[GunChleoc (gunchleoc)]

As long as both Travis and Appveyor continue to be green, bunnybot will not post here again. SirVer stopped that, because it was too spammy.

Bunnybot will refuse to merge though if Travis and Appyeyor aren't both green.

Thanks for the testing and review! I know this was a complicated one.

@bunnybot merge

=== modified file 'src/editor/ui_menus/main_menu_map_options.cc'
--- src/editor/ui_menus/main_menu_map_options.cc	2017-05-13 11:25:24 +0000
+++ src/editor/ui_menus/main_menu_map_options.cc	2017-05-23 21:33:09 +0000
@@ -46,9 +46,7 @@
    : UI::Window(&parent, "map_options", 0, 0, 350, parent.get_inner_h() - 80, _("Map Options")),
      padding_(4),
      indent_(10),
-     labelh_(
-        UI::g_fh1->render(as_uifont(UI::g_fh1->fontset()->representative_character()))->height() +
-        4),
+     labelh_(text_height() + 4),
      checkbox_space_(25),
      butw_((get_inner_w() - 3 * padding_) / 2),
      max_w_(get_inner_w() - 2 * padding_),

=== modified file 'src/editor/ui_menus/main_menu_random_map.cc'
--- src/editor/ui_menus/main_menu_random_map.cc	2017-05-13 11:25:24 +0000
+++ src/editor/ui_menus/main_menu_random_map.cc	2017-05-23 21:33:09 +0000
@@ -52,9 +52,7 @@
      // UI elements
      margin_(4),
      box_width_(get_inner_w() - 2 * margin_),
-     label_height_(
-        UI::g_fh1->render(as_uifont(UI::g_fh1->fontset()->representative_character()))->height() +
-        2),
+     label_height_(text_height() + 2),
      box_(this, margin_, margin_, UI::Box::Vertical, 0, 0, margin_),
      // Size
      width_(&box_,

=== modified file 'src/editor/ui_menus/tool_set_terrain_options_menu.cc'
--- src/editor/ui_menus/tool_set_terrain_options_menu.cc	2017-05-13 11:25:24 +0000
+++ src/editor/ui_menus/tool_set_terrain_options_menu.cc	2017-05-23 21:33:09 +0000
@@ -53,8 +53,8 @@
 	// Blit the main terrain image
 	const Image& terrain_texture = terrain_descr.get_texture(0);
 	Texture* texture = new Texture(terrain_texture.width(), terrain_texture.height());
-	texture->blit(Rectf(0, 0, terrain_texture.width(), terrain_texture.height()), terrain_texture,
-	              Rectf(0, 0, terrain_texture.width(), terrain_texture.height()), 1.,
+	texture->blit(Rectf(0.f, 0.f, terrain_texture.width(), terrain_texture.height()), terrain_texture,
+	              Rectf(0.f, 0.f, terrain_texture.width(), terrain_texture.height()), 1.,
 	              BlendMode::UseAlpha);
 	Vector2i pt(1, terrain_texture.height() - kSmallPicSize - 1);
 
@@ -66,7 +66,7 @@
 
 		texture->blit(Rectf(pt.x, pt.y, terrain_type.icon->width(), terrain_type.icon->height()),
 		              *terrain_type.icon,
-		              Rectf(0, 0, terrain_type.icon->width(), terrain_type.icon->height()), 1.,
+		              Rectf(0.f, 0.f, terrain_type.icon->width(), terrain_type.icon->height()), 1.,
 		              BlendMode::UseAlpha);
 		pt.x += kSmallPicSize + 1;
 	}

=== modified file 'src/graphic/CMakeLists.txt'
--- src/graphic/CMakeLists.txt	2017-04-26 17:11:43 +0000
+++ src/graphic/CMakeLists.txt	2017-05-23 21:33:09 +0000
@@ -109,8 +109,6 @@
     surface.h
     texture.cc
     texture.h
-    texture_cache.cc
-    texture_cache.h
   USES_SDL2
   DEPENDS
     base_exceptions
@@ -268,16 +266,9 @@
     font_handler1.cc
     font_handler1.h
   DEPENDS
-    base_exceptions
-    base_geometry
-    base_log
     base_macros
-    graphic
-    graphic_align
     graphic_image_cache
-    graphic_surface
     graphic_text
-    io_filesystem
 )
 
 wl_library(graphic_text_constants

=== modified file 'src/graphic/animation.cc'
--- src/graphic/animation.cc	2017-05-19 06:05:40 +0000
+++ src/graphic/animation.cc	2017-05-23 21:33:09 +0000
@@ -227,7 +227,8 @@
 	const int w = image->width();
 	const int h = image->height();
 	Texture* rv = new Texture(w / scale_, h / scale_);
-	rv->blit(Rectf(0, 0, w / scale_, h / scale_), *image, Rectf(0, 0, w, h), 1., BlendMode::Copy);
+	rv->blit(
+	   Rectf(0.f, 0.f, w / scale_, h / scale_), *image, Rectf(0.f, 0.f, w, h), 1., BlendMode::Copy);
 	return rv;
 }
 

=== modified file 'src/graphic/build_texture_atlas.cc'
--- src/graphic/build_texture_atlas.cc	2017-01-25 18:55:59 +0000
+++ src/graphic/build_texture_atlas.cc	2017-05-23 21:33:09 +0000
@@ -39,10 +39,6 @@
 // threshold, but not background pictures.
 constexpr int kMaxAreaForTextureAtlas = 240 * 240;
 
-// A graphics card must at least support this size for texture for Widelands to
-// run.
-constexpr int kMinimumSizeForTextures = 2048;
-
 // Returns true if 'filename' ends with an image extension.
 bool is_image(const std::string& filename) {
 	return boost::ends_with(filename, ".png") || boost::ends_with(filename, ".jpg");

=== modified file 'src/graphic/font_handler1.cc'
--- src/graphic/font_handler1.cc	2017-03-25 15:32:49 +0000
+++ src/graphic/font_handler1.cc	2017-05-23 21:33:09 +0000
@@ -19,88 +19,34 @@
 
 #include "graphic/font_handler1.h"
 
-#include <functional>
 #include <memory>
 
 #include <boost/lexical_cast.hpp>
-#include <boost/utility.hpp>
 
-#include "base/log.h"
-#include "base/wexception.h"
-#include "graphic/graphic.h"
-#include "graphic/image.h"
-#include "graphic/image_cache.h"
-#include "graphic/rendertarget.h"
-#include "graphic/text/rt_errors.h"
 #include "graphic/text/rt_render.h"
-#include "graphic/text/sdl_ttf_font.h"
-#include "graphic/texture.h"
-#include "graphic/texture_cache.h"
-#include "io/filesystem/filesystem.h"
-
-using namespace std;
-using namespace boost;
+#include "graphic/text/texture_cache.h"
 
 namespace {
 
-// The size of the richtext surface cache in bytes. All work that the richtext
-// renderer does is / cached in this cache until it overflows. The idea is that
-// this is big enough to cache the text that is used on a typical screen - so
-// that we do not need to lay out text every frame. Last benchmarked at r7712,
-// 30 MB was enough to cache texts for many frames (> 1000), while it is
-// quickly overflowing in the map selection menu.
-// This might need reevaluation is the new font handler is used for more stuff.
-const uint32_t RICHTEXT_TEXTURE_CACHE = 30 << 20;  // shifting converts to MB
-
-// An Image implementation that recreates a rich text texture when needed on
-// the fly. It is meant to be saved into the ImageCache.
-class RTImage : public Image {
-public:
-	RTImage(const string& ghash,
-	        TextureCache* texture_cache,
-	        std::function<RT::Renderer*()> get_renderer,
-	        const string& text,
-	        int gwidth)
-	   : hash_(ghash),
-	     text_(text),
-	     width_(gwidth),
-	     get_renderer_(get_renderer),
-	     texture_cache_(texture_cache) {
-	}
-	virtual ~RTImage() {
-	}
-
-	// Implements Image.
-	int width() const override {
-		return texture()->width();
-	}
-	int height() const override {
-		return texture()->height();
-	}
-
-	const BlitData& blit_data() const override {
-		return texture()->blit_data();
-	}
-
-private:
-	Texture* texture() const {
-		Texture* surf = texture_cache_->get(hash_);
-		if (surf != nullptr) {
-			return surf;
-		}
-		return texture_cache_->insert(
-		   hash_, std::unique_ptr<Texture>(get_renderer_()->render(text_, width_)));
-	}
-
-	const string hash_;
-	const string text_;
-	int width_;
-	std::function<RT::Renderer*()> get_renderer_;
-
-	// Nothing owned.
-	TextureCache* const texture_cache_;
-};
-}
+// The CacheSize constexpr values control the cache sizes for our transient caches.
+// The idea is that they are big enough to cache the text that is used on a typical screen - so
+// that we do not need to lay out text every frame.
+
+// TODO(GunChleoc): Re-evaulate the cache sizes once the in-game help and the campaigns have been
+// converted to this font renderer.
+// The current cache sizes allow for loading 22 maps in the map selection screen before they start
+// dropping entries. In-game dropping of textures only started after quite a lot of text was
+// generated by mousing over things. Typing 500+ characters in a Multilineeditbox did not trigger
+// texture dropping.
+
+// The size of the richtext surface cache in bytes.
+constexpr uint32_t kTextureCacheSize = 3 << 20;  // shifting by 20 converts to MB
+
+// The maximum number of RenderedRects. It's all pointers or combinations of basic data types, so
+// the size requirement is pretty constant. Therefore, simply counting them is sufficient.
+// We estimate that the member variables of each RenderedRect take up ca. 13 * 32 bytes.
+constexpr uint32_t kRenderCacheSize = 8 * 1024;
+}  // namespace
 
 namespace UI {
 
@@ -108,9 +54,24 @@
 // the ImageCache, so repeated calls to render with the same arguments should not
 // be a problem.
 class FontHandler1 : public IFontHandler1 {
+private:
+	// A transient cache for the generated rendered texts
+	class RenderCache : public TransientCache<RenderedText> {
+	public:
+		RenderCache(uint32_t max_number_of_rects)
+		   : TransientCache<RenderedText>(max_number_of_rects) {
+		}
+
+		std::shared_ptr<const RenderedText> insert(const std::string& hash,
+		                                           std::shared_ptr<const RenderedText> entry) override {
+			return TransientCache<RenderedText>::insert(hash, entry, entry->rects.size());
+		}
+	};
+
 public:
 	FontHandler1(ImageCache* image_cache, const std::string& locale)
-	   : texture_cache_(new TextureCache(RICHTEXT_TEXTURE_CACHE)),
+	   : texture_cache_(new TextureCache(kTextureCacheSize)),
+	     render_cache_(new RenderCache(kRenderCacheSize)),
 	     fontsets_(),
 	     fontset_(fontsets_.get_fontset(locale)),
 	     rt_renderer_(new RT::Renderer(image_cache, texture_cache_.get(), fontsets_)),
@@ -119,17 +80,16 @@
 	virtual ~FontHandler1() {
 	}
 
-	const Image* render(const string& text, uint16_t w = 0) override {
-		const string hash = boost::lexical_cast<string>(w) + text;
-
-		if (image_cache_->has(hash))
-			return image_cache_->get(hash);
-
-		std::unique_ptr<RTImage> image(
-		   new RTImage(hash, texture_cache_.get(), [this] { return rt_renderer_.get(); }, text, w));
-		image->width();  // force the rich text to get rendered in case there is an exception thrown.
-
-		return image_cache_->insert(hash, std::move(image));
+	// This will render the 'text' with a width restriction of 'w'. If 'w' == 0, no restriction is
+	// applied.
+	std::shared_ptr<const UI::RenderedText> render(const std::string& text,
+	                                               uint16_t w = 0) override {
+		const std::string hash = boost::lexical_cast<std::string>(w) + text;
+		std::shared_ptr<const RenderedText> rendered_text = render_cache_->get(hash);
+		if (rendered_text.get() == nullptr) {
+			rendered_text = render_cache_->insert(hash, rt_renderer_->render(text, w));
+		}
+		return rendered_text;
 	}
 
 	UI::FontSet const* fontset() const override {
@@ -138,12 +98,14 @@
 
 	void reinitialize_fontset(const std::string& locale) override {
 		fontset_ = fontsets_.get_fontset(locale);
-		texture_cache_.get()->flush();
+		texture_cache_->flush();
+		render_cache_->flush();
 		rt_renderer_.reset(new RT::Renderer(image_cache_, texture_cache_.get(), fontsets_));
 	}
 
 private:
 	std::unique_ptr<TextureCache> texture_cache_;
+	std::unique_ptr<RenderCache> render_cache_;
 	UI::FontSets fontsets_;       // All fontsets
 	UI::FontSet const* fontset_;  // The currently active FontSet
 	std::unique_ptr<RT::Renderer> rt_renderer_;

=== modified file 'src/graphic/font_handler1.h'
--- src/graphic/font_handler1.h	2017-02-28 20:07:07 +0000
+++ src/graphic/font_handler1.h	2017-05-23 21:33:09 +0000
@@ -22,16 +22,11 @@
 #define WL_GRAPHIC_FONT_HANDLER1_H
 
 #include <memory>
-#include <string>
 
 #include "base/macros.h"
-#include "base/vector.h"
-#include "graphic/align.h"
+#include "graphic/image_cache.h"
 #include "graphic/text/font_set.h"
-
-class FileSystem;
-class Image;
-class ImageCache;
+#include "graphic/text/rendered_text.h"
 
 namespace UI {
 
@@ -44,11 +39,10 @@
 	virtual ~IFontHandler1() {
 	}
 
-	/*
-	 * Renders the given text into an image. The image is cached and therefore
-	 * ownership remains with this class. Will throw on error.
-	 */
-	virtual const Image* render(const std::string& text, uint16_t w = 0) = 0;
+	/// Renders the given text into a set of images. The images are cached in a transient cache,
+	/// so we share the ownership. Will throw on error.
+	virtual std::shared_ptr<const UI::RenderedText> render(const std::string& text,
+	                                                       uint16_t w = 0) = 0;
 
 	/// Returns the font handler's current FontSet
 	virtual UI::FontSet const* fontset() const = 0;
@@ -61,7 +55,7 @@
 	DISALLOW_COPY_AND_ASSIGN(IFontHandler1);
 };
 
-// Create a new FontHandler1.
+/// Create a new FontHandler1.
 IFontHandler1* create_fonthandler(ImageCache* image_cache, const std::string& locale);
 
 extern IFontHandler1* g_fh1;

=== modified file 'src/graphic/graphic.h'
--- src/graphic/graphic.h	2017-01-25 18:55:59 +0000
+++ src/graphic/graphic.h	2017-05-23 21:33:09 +0000
@@ -33,6 +33,10 @@
 class Screen;
 class StreamWrite;
 
+// A graphics card must at least support this size for texture for Widelands to
+// run.
+constexpr int kMinimumSizeForTextures = 2048;
+
 // Will be send whenever the resolution changes.
 struct GraphicResolutionChanged {
 	CAN_BE_SENT_AS_NOTE(NoteId::GraphicResolutionChanged)

=== modified file 'src/graphic/minimap_renderer.cc'
--- src/graphic/minimap_renderer.cc	2017-05-13 11:25:24 +0000
+++ src/graphic/minimap_renderer.cc	2017-05-23 21:33:09 +0000
@@ -237,7 +237,8 @@
 
 	std::unique_ptr<Texture> texture(new Texture(map_w, map_h));
 
-	texture->fill_rect(Rectf(0, 0, texture->width(), texture->height()), RGBAColor(0, 0, 0, 255));
+	texture->fill_rect(
+	   Rectf(0.f, 0.f, texture->width(), texture->height()), RGBAColor(0, 0, 0, 255));
 
 	// Center the view on the middle of the 'view_area'.
 	const bool zoom = layers & MiniMapLayer::Zoom2;

=== modified file 'src/graphic/playercolor.cc'
--- src/graphic/playercolor.cc	2017-05-15 11:36:22 +0000
+++ src/graphic/playercolor.cc	2017-05-23 21:33:09 +0000
@@ -49,8 +49,8 @@
 	const int w = image->width();
 	const int h = image->height();
 	Texture* pc_image = new Texture(w, h);
-	pc_image->fill_rect(Rectf(0, 0, w, h), RGBAColor(0, 0, 0, 0));
-	pc_image->blit_blended(Rectf(0, 0, w, h), *image, *color_mask, Rectf(0, 0, w, h), clr);
+	pc_image->fill_rect(Rectf(0.f, 0.f, w, h), RGBAColor(0, 0, 0, 0));
+	pc_image->blit_blended(Rectf(0.f, 0.f, w, h), *image, *color_mask, Rectf(0.f, 0.f, w, h), clr);
 	g_gr->images().insert(hash, std::unique_ptr<const Texture>(std::move(pc_image)));
 	assert(g_gr->images().has(hash));
 	return g_gr->images().get(hash);

=== modified file 'src/graphic/rendertarget.cc'
--- src/graphic/rendertarget.cc	2017-05-13 18:48:26 +0000
+++ src/graphic/rendertarget.cc	2017-05-23 21:33:09 +0000
@@ -23,6 +23,7 @@
 #include "graphic/animation.h"
 #include "graphic/graphic.h"
 #include "graphic/surface.h"
+#include "graphic/text_layout.h"
 
 /**
  * Build a render target for the given surface.
@@ -142,9 +143,16 @@
  *
  * This blit function copies the pixels to the destination surface.
  */
-void RenderTarget::blit(const Vector2i& dst, const Image* image, BlendMode blend_mode) {
-	Rectf source_rect(Vector2i::zero(), image->width(), image->height());
-	Rectf destination_rect(dst.x, dst.y, source_rect.w, source_rect.h);
+void RenderTarget::blit(const Vector2i& dst,
+                        const Image* image,
+                        BlendMode blend_mode,
+                        UI::Align align) {
+	assert(image != nullptr);
+	Vector2i destination_point(dst);
+	UI::correct_for_align(align, image->width(), &destination_point);
+
+	Rectf source_rect(0.f, 0.f, image->width(), image->height());
+	Rectf destination_rect(destination_point.x, destination_point.y, source_rect.w, source_rect.h);
 
 	if (to_surface_geometry(&destination_rect, &source_rect)) {
 		// I seem to remember seeing 1. a lot in blitting calls.
@@ -155,9 +163,13 @@
 
 void RenderTarget::blit_monochrome(const Vector2i& dst,
                                    const Image* image,
-                                   const RGBAColor& blend_mode) {
-	Rectf source_rect(Vector2i::zero(), image->width(), image->height());
-	Rectf destination_rect(dst.x, dst.y, source_rect.w, source_rect.h);
+                                   const RGBAColor& blend_mode,
+                                   UI::Align align) {
+	Vector2i destination_point(dst);
+	UI::correct_for_align(align, image->width(), &destination_point);
+
+	Rectf source_rect(0.f, 0.f, image->width(), image->height());
+	Rectf destination_rect(destination_point.x, destination_point.y, source_rect.w, source_rect.h);
 
 	if (to_surface_geometry(&destination_rect, &source_rect)) {
 		surface_->blit_monochrome(destination_rect, *image, source_rect, blend_mode);

=== modified file 'src/graphic/rendertarget.h'
--- src/graphic/rendertarget.h	2017-05-13 18:48:26 +0000
+++ src/graphic/rendertarget.h	2017-05-23 21:33:09 +0000
@@ -62,10 +62,16 @@
 	void fill_rect(const Recti&, const RGBAColor&, BlendMode blend_mode = BlendMode::Copy);
 	void brighten_rect(const Recti&, int32_t factor);
 
-	void blit(const Vector2i& dst, const Image* image, BlendMode blend_mode = BlendMode::UseAlpha);
+	void blit(const Vector2i& dst,
+	          const Image* image,
+	          BlendMode blend_mode = BlendMode::UseAlpha,
+	          UI::Align = UI::Align::kLeft);
 
 	// Like blit. See MonochromeBlitProgram for details.
-	void blit_monochrome(const Vector2i& dst, const Image* image, const RGBAColor& blend_mode);
+	void blit_monochrome(const Vector2i& dst,
+	                     const Image* image,
+	                     const RGBAColor& blend_mode,
+	                     UI::Align = UI::Align::kLeft);
 
 	void blitrect(const Vector2i& dst,
 	              const Image* image,

=== modified file 'src/graphic/text/CMakeLists.txt'
--- src/graphic/text/CMakeLists.txt	2017-03-29 12:36:20 +0000
+++ src/graphic/text/CMakeLists.txt	2017-05-23 21:33:09 +0000
@@ -14,10 +14,14 @@
     rt_parse.h
     rt_render.cc
     rt_render.h
+    rendered_text.cc
+    rendered_text.h
     sdl_ttf_font.cc
     sdl_ttf_font.h
     textstream.cc
     textstream.h
+    texture_cache.h
+    transient_cache.h
   USES_SDL2
   USES_SDL2_TTF
   USES_ICU

=== added file 'src/graphic/text/rendered_text.cc'
--- src/graphic/text/rendered_text.cc	1970-01-01 00:00:00 +0000
+++ src/graphic/text/rendered_text.cc	2017-05-23 21:33:09 +0000
@@ -0,0 +1,266 @@
+/*
+ * Copyright (C) 2017 by the Widelands Development Team
+ *
+ * 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.
+ *
+ */
+
+#include "graphic/text/rendered_text.h"
+
+#include <memory>
+
+#include "graphic/graphic.h"
+#include "graphic/text_layout.h"
+
+namespace UI {
+// RenderedRect
+RenderedRect::RenderedRect(const Recti& init_rect,
+                           std::shared_ptr<const Image> init_image,
+                           bool visited,
+                           const RGBColor& color,
+                           bool is_background_color_set,
+                           DrawMode init_mode)
+   : rect_(init_rect),
+     transient_image_(init_image),
+     permanent_image_(nullptr),
+     visited_(visited),
+     background_color_(color),
+     is_background_color_set_(is_background_color_set),
+     mode_(init_mode) {
+}
+RenderedRect::RenderedRect(const Recti& init_rect,
+                           const Image* init_image,
+                           bool visited,
+                           const RGBColor& color,
+                           bool is_background_color_set,
+                           DrawMode init_mode)
+   : rect_(init_rect),
+     transient_image_(nullptr),
+     permanent_image_(init_image),
+     visited_(visited),
+     background_color_(color),
+     is_background_color_set_(is_background_color_set),
+     mode_(init_mode) {
+}
+
+RenderedRect::RenderedRect(const Recti& init_rect, const Image* init_image)
+   : RenderedRect(init_rect, init_image, false, RGBColor(0, 0, 0), false, DrawMode::kTile) {
+}
+RenderedRect::RenderedRect(const Recti& init_rect, const RGBColor& color)
+   : RenderedRect(init_rect, nullptr, false, color, true, DrawMode::kTile) {
+}
+RenderedRect::RenderedRect(std::shared_ptr<const Image> init_image)
+   : RenderedRect(Recti(0, 0, init_image->width(), init_image->height()),
+                  init_image,
+                  false,
+                  RGBColor(0, 0, 0),
+                  false,
+                  DrawMode::kBlit) {
+}
+RenderedRect::RenderedRect(const Image* init_image)
+   : RenderedRect(Recti(0, 0, init_image->width(), init_image->height()),
+                  init_image,
+                  false,
+                  RGBColor(0, 0, 0),
+                  false,
+                  DrawMode::kBlit) {
+}
+
+const Image* RenderedRect::image() const {
+	assert(permanent_image_ == nullptr || transient_image_.get() == nullptr);
+	return permanent_image_ == nullptr ? transient_image_.get() : permanent_image_;
+}
+
+int RenderedRect::x() const {
+	return rect_.x;
+}
+
+int RenderedRect::y() const {
+	return rect_.y;
+}
+
+int RenderedRect::width() const {
+	return rect_.w;
+}
+int RenderedRect::height() const {
+	return rect_.h;
+}
+
+void RenderedRect::set_origin(const Vector2i& new_origin) {
+	rect_.x = new_origin.x;
+	rect_.y = new_origin.y;
+}
+void RenderedRect::set_visited() {
+	visited_ = true;
+}
+bool RenderedRect::was_visited() const {
+	return visited_;
+}
+
+bool RenderedRect::has_background_color() const {
+	return is_background_color_set_;
+}
+const RGBColor& RenderedRect::background_color() const {
+	return background_color_;
+}
+
+RenderedRect::DrawMode RenderedRect::mode() const {
+	return mode_;
+}
+
+// RenderedText
+int RenderedText::width() const {
+	int result = 0;
+	for (const auto& rect : rects) {
+		result = std::max(result, rect->x() + rect->width());
+	}
+	return result;
+}
+int RenderedText::height() const {
+	int result = 0;
+	for (const auto& rect : rects) {
+		result = std::max(result, rect->y() + rect->height());
+	}
+	return result;
+}
+
+void RenderedText::draw(RenderTarget& dst,
+                        const Vector2i& position,
+                        const Recti& region,
+                        Align align,
+                        CropMode cropmode) const {
+
+	// Un-const the position and adjust for alignment according to region width
+	Vector2i aligned_pos(position.x, position.y);
+
+	// For cropping images that don't fit
+	int offset_x = 0;
+	if (cropmode == CropMode::kSelf) {
+		UI::correct_for_align(align, width(), &aligned_pos);
+		if (align != UI::Align::kLeft) {
+			for (const auto& rect : rects) {
+				offset_x = std::min(region.w - rect->width(), offset_x);
+			}
+			if (align == UI::Align::kCenter) {
+				offset_x /= 2;
+			}
+		}
+	} else {
+		aligned_pos.x -= region.x;
+		aligned_pos.y -= region.y;
+		UI::correct_for_align(align, region.w, &aligned_pos);
+	}
+
+	// Blit the rects
+	for (const auto& rect : rects) {
+		blit_rect(dst, offset_x, aligned_pos, *rect.get(), region, align, cropmode);
+	}
+}
+
+void RenderedText::blit_rect(RenderTarget& dst,
+                             int offset_x,
+                             const Vector2i& aligned_position,
+                             const RenderedRect& rect,
+                             const Recti& region,
+                             Align align,
+                             CropMode cropmode) const {
+	const Vector2i blit_point(aligned_position.x + rect.x(), aligned_position.y + rect.y());
+
+	// Draw Solid background Color
+	if (rect.has_background_color()) {
+#ifndef NDEBUG
+		const int maximum_size = kMinimumSizeForTextures;
+#else
+		const int maximum_size = g_gr->max_texture_size();
+#endif
+		const int tile_width = std::min(maximum_size, rect.width());
+		const int tile_height = std::min(maximum_size, rect.height());
+		for (int tile_x = blit_point.x; tile_x + tile_width <= blit_point.x + rect.width();
+		     tile_x += tile_width) {
+			for (int tile_y = blit_point.y; tile_y + tile_height <= blit_point.y + rect.height();
+			     tile_y += tile_height) {
+				dst.fill_rect(Recti(tile_x, tile_y, tile_width, tile_height), rect.background_color());
+			}
+		}
+	}
+
+	if (rect.image() != nullptr) {
+		switch (rect.mode()) {
+		// Draw a foreground texture
+		case RenderedRect::DrawMode::kBlit: {
+			switch (cropmode) {
+			case CropMode::kRenderTarget:
+				// dst will handle any cropping
+				dst.blit(blit_point, rect.image());
+				break;
+			case CropMode::kSelf:
+				blit_cropped(dst, offset_x, aligned_position, blit_point, rect, region, align);
+			}
+		} break;
+		// Draw a background image (tiling)
+		case RenderedRect::DrawMode::kTile:
+			dst.tile(Recti(blit_point, rect.width(), rect.height()), rect.image(), Vector2i::zero());
+			break;
+		}
+	}
+}
+
+void RenderedText::draw(RenderTarget& dst, const Vector2i& position, UI::Align align) const {
+	draw(dst, position, Recti(0, 0, width(), height()), align);
+}
+
+// Crop horizontally if it doesn't fit
+void RenderedText::blit_cropped(RenderTarget& dst,
+                                int offset_x,
+                                const Vector2i& position,
+                                const Vector2i& blit_point,
+                                const RenderedRect& rect,
+                                const Recti& region,
+                                Align align) const {
+
+	int blit_width = rect.width();
+	int cropped_left = 0;
+	if (align != UI::Align::kLeft) {
+		if (rect.x() + rect.width() + offset_x <= region.x) {
+			// Falls off the left-hand side
+			return;
+		}
+		if (rect.x() + offset_x < 0) {
+			// Needs cropping
+			blit_width = rect.width() + offset_x + rect.x() - region.x;
+			cropped_left = rect.width() - blit_width;
+		}
+	}
+
+	if (align != UI::Align::kRight) {
+		if (rect.x() + rect.width() - offset_x > region.w - region.x) {
+			blit_width = region.w - rect.x() - offset_x;
+		}
+	}
+
+	// Don't blit tiny or negative width
+	if (blit_width < 3) {
+		return;
+	}
+
+	dst.blitrect(
+	   Vector2i(cropped_left > 0 ?
+	               position.x + region.x - (align == UI::Align::kRight ? region.w : region.w / 2) :
+	               blit_point.x,
+	            blit_point.y),
+	   rect.image(), Recti(cropped_left > 0 ? cropped_left : 0, region.y, blit_width, region.h));
+}
+
+}  // namespace UI

=== added file 'src/graphic/text/rendered_text.h'
--- src/graphic/text/rendered_text.h	1970-01-01 00:00:00 +0000
+++ src/graphic/text/rendered_text.h	2017-05-23 21:33:09 +0000
@@ -0,0 +1,174 @@
+/*
+ * Copyright (C) 2017 by the Widelands Development Team
+ *
+ * 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 WL_GRAPHIC_TEXT_RENDERED_TEXT_H
+#define WL_GRAPHIC_TEXT_RENDERED_TEXT_H
+
+#include <memory>
+#include <vector>
+
+#include "base/rect.h"
+#include "base/vector.h"
+#include "graphic/image.h"
+#include "graphic/rendertarget.h"
+#include "graphic/texture.h"
+
+namespace UI {
+
+/// A rectangle that contains blitting information for rendered text.
+class RenderedRect {
+public:
+	/// Whether the RenderedRect's image should be blitted once or tiled
+	enum class DrawMode {
+		kBlit,  // The image texture is considered a foreground image and blitted as is
+		kTile   // The image texture is considered a background image and is tiled to fill the rect
+	};
+
+private:
+	// The image is managed by a transient cache
+	RenderedRect(const Recti& init_rect,
+	             std::shared_ptr<const Image> init_image,
+	             bool visited,
+	             const RGBColor& color,
+	             bool is_background_color_set,
+	             DrawMode init_mode);
+	// The image is managed by a pernament cache
+	RenderedRect(const Recti& init_rect,
+	             const Image* init_image,
+	             bool visited,
+	             const RGBColor& color,
+	             bool is_background_color_set,
+	             DrawMode init_mode);
+
+public:
+	/// RenderedRect will contain a background image that should be tiled
+	RenderedRect(const Recti& init_rect, const Image* init_image);
+
+	/// RenderedRect will contain a background color that should be tiled
+	RenderedRect(const Recti& init_rect, const RGBColor& color);
+
+	/// RenderedRect will contain a normal image that is managed by a transient cache.
+	/// Use this if the image is managed by an instance of TextureCache.
+	RenderedRect(std::shared_ptr<const Image> init_image);
+
+	/// RenderedRect will contain a normal image that is managed by a permanent cache.
+	/// Use this if the image is managed by g_gr->images().
+	RenderedRect(const Image* init_image);
+	~RenderedRect() {
+	}
+
+	/// An image to be blitted. Can be nullptr.
+	const Image* image() const;
+
+	/// The x position of the rectangle
+	int x() const;
+	/// The y position of the rectangle
+	int y() const;
+	/// The width of the rectangle
+	int width() const;
+	/// The height of the rectangle
+	int height() const;
+
+	/// Change x and y position of the rectangle.
+	void set_origin(const Vector2i& new_origin);
+
+	/// Set that this rectangle was already visited by the font renderer. Needed by the font renderer
+	/// for correct positioning.
+	void set_visited();
+	/// Whether this rectangle was already visited by the font renderer
+	bool was_visited() const;
+
+	/// Whether this rectangle contains a background color
+	bool has_background_color() const;
+	/// This rectangle's background color
+	const RGBColor& background_color() const;
+
+	/// Whether the RenderedRect's image should be blitted once or tiled
+	DrawMode mode() const;
+
+private:
+	Recti rect_;
+	// We have 2 image objects depending on the caching situation - only use one of them at the same
+	// time.
+	std::shared_ptr<const Image> transient_image_;  // Shared ownership, managed by a transient cache
+	const Image* permanent_image_;                  // Not owned, managed by a permanent cache
+	bool visited_;
+	const RGBColor background_color_;
+	const bool is_background_color_set_;
+	const DrawMode mode_;
+};
+
+struct RenderedText {
+	/// RenderedRects that can be drawn on screen
+	std::vector<std::unique_ptr<RenderedRect>> rects;
+
+	/// The width occupied  by all rects in pixels.
+	int width() const;
+	/// The height occupied  by all rects in pixels.
+	int height() const;
+
+	enum class CropMode {
+		// The RenderTarget will handle all cropping. Use this for scrollable elements or when you
+		// don't expect any cropping.
+		kRenderTarget,
+		// The draw() method will handle horizontal cropping. Use this for table entries.
+		kSelf
+	};
+
+	/// Draw the rects. 'position', 'region' and 'align' are used to control the overall drawing
+	/// position and cropping.
+	/// For 'cropmode', use kRenderTarget if you wish the text to fill the whole RenderTarget, e.g.
+	/// for scrolling panels. Use kHorizontal for horizontal cropping in smaller elements, e.g. table
+	/// cells.
+	void draw(RenderTarget& dst,
+	          const Vector2i& position,
+	          const Recti& region,
+	          UI::Align align = UI::Align::kLeft,
+	          CropMode cropmode = CropMode::kRenderTarget) const;
+
+	/// Draw the rects without cropping. 'position' and 'align' are used to control the overall
+	/// drawing position
+	void draw(RenderTarget& dst, const Vector2i& position, UI::Align align = UI::Align::kLeft) const;
+
+private:
+	/// Helper function for draw(). Blits the rect's background color and images. The rect will be
+	/// positioned according to 'aligned_position' and cropped according to 'region'. 'offxet_x' and
+	/// 'align' are used by the cropping algorithm when we use CropMode::kSelf mode.
+	void blit_rect(RenderTarget& dst,
+	               int offset_x,
+	               const Vector2i& aligned_position,
+	               const RenderedRect& rect,
+	               const Recti& region,
+	               Align align,
+	               CropMode cropmode) const;
+
+	/// Helper function for CropMode::kSelf. It only does horizontal cropping since the RenderTarget
+	/// itself still seems to take care of vertical stuff for us in tables.
+	void blit_cropped(RenderTarget& dst,
+	                  int offset_x,
+	                  const Vector2i& position,
+	                  const Vector2i& blit_point,
+	                  const RenderedRect& rect,
+	                  const Recti& region,
+	                  Align align) const;
+};
+
+}  // namespace UI
+
+#endif  // end of include guard: WL_GRAPHIC_TEXT_RENDERED_TEXT_H

=== modified file 'src/graphic/text/rt_render.cc'
--- src/graphic/text/rt_render.cc	2017-05-03 07:24:06 +0000
+++ src/graphic/text/rt_render.cc	2017-05-23 21:33:09 +0000
@@ -43,6 +43,7 @@
 #include "graphic/text/bidi.h"
 #include "graphic/text/font_io.h"
 #include "graphic/text/font_set.h"
+#include "graphic/text/rendered_text.h"
 #include "graphic/text/rt_parse.h"
 #include "graphic/text/sdl_ttf_font.h"
 #include "graphic/text/textstream.h"
@@ -52,7 +53,7 @@
 #include "io/filesystem/layered_filesystem.h"
 
 using namespace std;
-
+// TODO(GunChleoc): text line can start with space text node when it's within a div.
 namespace RT {
 
 static const uint16_t INFINITE_WIDTH = 65535;  // 2^16-1
@@ -227,15 +228,20 @@
 	virtual ~RenderNode() {
 	}
 
-	virtual uint16_t width() = 0;
-	virtual uint16_t height() = 0;
-	virtual uint16_t hotspot_y() = 0;
-	virtual Texture* render(TextureCache* texture_cache) = 0;
-
-	virtual bool is_non_mandatory_space() {
+	virtual uint16_t width() const = 0;
+	virtual uint16_t height() const = 0;
+	virtual uint16_t hotspot_y() const = 0;
+	virtual UI::RenderedText* render(TextureCache* texture_cache) = 0;
+
+	// TODO(GunChleoc): Remove this function once conversion is finished and well tested.
+	virtual std::string debug_info() const = 0;
+
+	// If a node is a non-mandatory space, it can be removed as a leading/trailing space
+	// by the positioning algorithm.
+	virtual bool is_non_mandatory_space() const {
 		return false;
 	}
-	virtual bool is_expanding() {
+	virtual bool is_expanding() const {
 		return false;
 	}
 	virtual void set_w(uint16_t) {
@@ -245,19 +251,19 @@
 		return vector<Reference>();
 	}
 
-	Floating get_floating() {
+	Floating get_floating() const {
 		return floating_;
 	}
 	void set_floating(Floating f) {
 		floating_ = f;
 	}
-	UI::Align halign() {
+	UI::Align halign() const {
 		return halign_;
 	}
 	void set_halign(UI::Align ghalign) {
 		halign_ = ghalign;
 	}
-	UI::Align valign() {
+	UI::Align valign() const {
 		return valign_;
 	}
 	void set_valign(UI::Align gvalign) {
@@ -269,13 +275,38 @@
 	void set_y(int32_t ny) {
 		y_ = ny;
 	}
-	int32_t x() {
+	int32_t x() const {
 		return x_;
 	}
-	int32_t y() {
+	int32_t y() const {
 		return y_;
 	}
 
+protected:
+	/// Throws a TextureTooBig exception if the given dimensions would be bigger than the graphics
+	/// can handle
+	void check_size(int check_w, int check_h) {
+// Test for minimum supported size in debug builds.
+#ifndef NDEBUG
+		const int maximum_size = kMinimumSizeForTextures;
+#else
+		const int maximum_size = g_gr->max_texture_size();
+#endif
+		if (check_w > maximum_size || check_h > maximum_size) {
+			const std::string error_message =
+			   (boost::format("Texture (%d, %d) too big! Maximum size is %d.") % check_w % check_h %
+			    maximum_size)
+			      .str();
+			log("%s\n", error_message.c_str());
+			throw TextureTooBig(error_message);
+		}
+	}
+
+	/// Check the size for the node's own dimensions
+	void check_size() {
+		check_size(width(), height());
+	}
+
 private:
 	Floating floating_;
 	UI::Align halign_;
@@ -479,13 +510,17 @@
 	virtual ~TextNode() {
 	}
 
-	uint16_t width() override {
+	std::string debug_info() const override {
+		return "'" + txt_ + "'";
+	}
+
+	uint16_t width() const override {
 		return w_;
 	}
-	uint16_t height() override {
+	uint16_t height() const override {
 		return h_ + nodestyle_.spacing;
 	}
-	uint16_t hotspot_y() override;
+	uint16_t hotspot_y() const override;
 	const vector<Reference> get_references() override {
 		vector<Reference> rv;
 		if (!nodestyle_.reference.empty()) {
@@ -495,7 +530,7 @@
 		return rv;
 	}
 
-	Texture* render(TextureCache* texture_cache) override;
+	UI::RenderedText* render(TextureCache* texture_cache) override;
 
 protected:
 	uint16_t w_, h_;
@@ -512,18 +547,20 @@
      fontcache_(font),
      font_(dynamic_cast<SdlTtfFont&>(fontcache_.get_font(&nodestyle_))) {
 	font_.dimensions(txt_, ns.font_style, &w_, &h_);
+	check_size();
 }
-uint16_t TextNode::hotspot_y() {
+uint16_t TextNode::hotspot_y() const {
 	return font_.ascent(nodestyle_.font_style);
 }
 
-Texture* TextNode::render(TextureCache* texture_cache) {
-	const Texture& img =
+UI::RenderedText* TextNode::render(TextureCache* texture_cache) {
+	auto rendered_image =
 	   font_.render(txt_, nodestyle_.font_color, nodestyle_.font_style, texture_cache);
-	Texture* rv = new Texture(img.width(), img.height());
-	rv->blit(Rectf(0, 0, img.width(), img.height()), img, Rectf(0, 0, img.width(), img.height()), 1.,
-	         BlendMode::Copy);
-	return rv;
+	assert(rendered_image.get() != nullptr);
+	UI::RenderedText* rendered_text = new UI::RenderedText();
+	rendered_text->rects.push_back(
+	   std::unique_ptr<UI::RenderedRect>(new UI::RenderedRect(rendered_image)));
+	return rendered_text;
 }
 
 /*
@@ -536,12 +573,18 @@
 	   FontCache& font, NodeStyle& ns, uint16_t w, const string& txt, bool expanding = false)
 	   : TextNode(font, ns, txt), is_expanding_(expanding) {
 		w_ = w;
+		check_size();
 	}
 	virtual ~FillingTextNode() {
 	}
-	Texture* render(TextureCache*) override;
-
-	bool is_expanding() override {
+
+	std::string debug_info() const override {
+		return "ft";
+	}
+
+	UI::RenderedText* render(TextureCache*) override;
+
+	bool is_expanding() const override {
 		return is_expanding_;
 	}
 	void set_w(uint16_t w) override {
@@ -551,15 +594,29 @@
 private:
 	bool is_expanding_;
 };
-Texture* FillingTextNode::render(TextureCache* texture_cache) {
-	const Texture& t =
-	   font_.render(txt_, nodestyle_.font_color, nodestyle_.font_style, texture_cache);
-	Texture* rv = new Texture(w_, h_);
-	for (uint16_t curx = 0; curx < w_; curx += t.width()) {
-		Rectf srcrect(0.f, 0.f, min<int>(t.width(), w_ - curx), h_);
-		rv->blit(Rectf(curx, 0, srcrect.w, srcrect.h), t, srcrect, 1., BlendMode::Copy);
+UI::RenderedText* FillingTextNode::render(TextureCache* texture_cache) {
+	UI::RenderedText* rendered_text = new UI::RenderedText();
+	const std::string hash =
+	   (boost::format("rt:fill:%s:%s:%i:%i:%i:%s") % txt_ % nodestyle_.font_color.hex_value() %
+	    nodestyle_.font_style % width() % height() % (is_expanding_ ? "e" : "f"))
+	      .str();
+
+	std::shared_ptr<const Image> rendered_image = texture_cache->get(hash);
+	if (rendered_image.get() == nullptr) {
+		std::shared_ptr<const Image> ttf =
+		   font_.render(txt_, nodestyle_.font_color, nodestyle_.font_style, texture_cache);
+		auto texture = std::make_shared<Texture>(width(), height());
+		for (uint16_t curx = 0; curx < w_; curx += ttf->width()) {
+			Rectf srcrect(0.f, 0.f, min<int>(ttf->width(), w_ - curx), h_);
+			texture->blit(
+			   Rectf(curx, 0, srcrect.w, srcrect.h), *ttf.get(), srcrect, 1., BlendMode::Copy);
+		}
+		rendered_image = texture_cache->insert(hash, std::move(texture));
 	}
-	return rv;
+	assert(rendered_image.get() != nullptr);
+	rendered_text->rects.push_back(
+	   std::unique_ptr<UI::RenderedRect>(new UI::RenderedRect(rendered_image)));
+	return rendered_text;
 }
 
 /*
@@ -569,20 +626,34 @@
 class WordSpacerNode : public TextNode {
 public:
 	WordSpacerNode(FontCache& font, NodeStyle& ns) : TextNode(font, ns, " ") {
+		check_size();
 	}
 	static void show_spaces(bool t) {
 		show_spaces_ = t;
 	}
 
-	Texture* render(TextureCache* texture_cache) override {
+	std::string debug_info() const override {
+		return "wsp";
+	}
+
+	UI::RenderedText* render(TextureCache* texture_cache) override {
 		if (show_spaces_) {
-			Texture* rv = new Texture(w_, h_);
-			rv->fill_rect(Rectf(0, 0, w_, h_), RGBAColor(0xcc, 0, 0, 0xcc));
-			return rv;
+			UI::RenderedText* rendered_text = new UI::RenderedText();
+			const std::string hash = (boost::format("rt:wsp:%i:%i") % width() % height()).str();
+			std::shared_ptr<const Image> rendered_image = texture_cache->get(hash);
+			if (rendered_image.get() == nullptr) {
+				auto texture = std::make_shared<Texture>(width(), height());
+				texture->fill_rect(Rectf(0.f, 0.f, w_, h_), RGBAColor(0xcc, 0, 0, 0xcc));
+				rendered_image = texture_cache->insert(hash, std::move(texture));
+			}
+			assert(rendered_image.get() != nullptr);
+			rendered_text->rects.push_back(
+			   std::unique_ptr<UI::RenderedRect>(new UI::RenderedRect(rendered_image)));
+			return rendered_text;
 		}
 		return TextNode::render(texture_cache);
 	}
-	bool is_non_mandatory_space() override {
+	bool is_non_mandatory_space() const override {
 		return true;
 	}
 
@@ -599,19 +670,24 @@
 public:
 	NewlineNode(NodeStyle& ns) : RenderNode(ns) {
 	}
-	uint16_t height() override {
+
+	std::string debug_info() const override {
+		return "nl";
+	}
+
+	uint16_t height() const override {
 		return 0;
 	}
-	uint16_t width() override {
+	uint16_t width() const override {
 		return INFINITE_WIDTH;
 	}
-	uint16_t hotspot_y() override {
+	uint16_t hotspot_y() const override {
 		return 0;
 	}
-	Texture* render(TextureCache* /* texture_cache */) override {
+	UI::RenderedText* render(TextureCache* /* texture_cache */) override {
 		NEVER_HERE();
 	}
-	bool is_non_mandatory_space() override {
+	bool is_non_mandatory_space() const override {
 		return true;
 	}
 };
@@ -622,52 +698,76 @@
 class SpaceNode : public RenderNode {
 public:
 	SpaceNode(NodeStyle& ns, uint16_t w, uint16_t h = 0, bool expanding = false)
-	   : RenderNode(ns), w_(w), h_(h), background_image_(nullptr), is_expanding_(expanding) {
-	}
-
-	uint16_t height() override {
+	   : RenderNode(ns),
+	     w_(w),
+	     h_(h),
+	     background_image_(nullptr),
+	     filename_(""),
+	     is_expanding_(expanding) {
+		check_size();
+	}
+
+	std::string debug_info() const override {
+		return "sp";
+	}
+
+	uint16_t height() const override {
 		return h_;
 	}
-	uint16_t width() override {
+	uint16_t width() const override {
 		return w_;
 	}
-	uint16_t hotspot_y() override {
+	uint16_t hotspot_y() const override {
 		return h_;
 	}
-	Texture* render(TextureCache* /* texture_cache */) override {
-		Texture* rv = new Texture(w_, h_);
+	UI::RenderedText* render(TextureCache* texture_cache) override {
+		UI::RenderedText* rendered_text = new UI::RenderedText();
+		const std::string hash = (boost::format("rt:sp:%s:%i:%i:%s") % filename_ % width() %
+		                          height() % (is_expanding_ ? "e" : "f"))
+		                            .str();
 
-		// Draw background image (tiling)
-		if (background_image_) {
-			Rectf dst;
-			Rectf srcrect(0, 0, 1, 1);
-			for (uint16_t curx = 0; curx < w_; curx += background_image_->width()) {
-				dst.x = curx;
-				dst.y = 0;
-				srcrect.w = dst.w = min<int>(background_image_->width(), w_ - curx);
-				srcrect.h = dst.h = h_;
-				rv->blit(dst, *background_image_, srcrect, 1., BlendMode::Copy);
+		std::shared_ptr<const Image> rendered_image = texture_cache->get(hash);
+		if (rendered_image.get() == nullptr) {
+			// Draw background image (tiling)
+			auto texture = std::make_shared<Texture>(width(), height());
+			if (background_image_ != nullptr) {
+				Rectf dst;
+				Rectf srcrect(0, 0, 1, 1);
+				for (uint16_t curx = 0; curx < w_; curx += background_image_->width()) {
+					dst.x = curx;
+					dst.y = 0;
+					srcrect.w = dst.w = min<int>(background_image_->width(), w_ - curx);
+					srcrect.h = dst.h = h_;
+					texture->blit(dst, *background_image_, srcrect, 1., BlendMode::Copy);
+				}
+			} else {
+				texture->fill_rect(Rectf(0.f, 0.f, w_, h_), RGBAColor(255, 255, 255, 0));
 			}
-		} else {
-			rv->fill_rect(Rectf(0, 0, w_, h_), RGBAColor(255, 255, 255, 0));
+			rendered_image = texture_cache->insert(hash, std::move(texture));
 		}
-		return rv;
+		assert(rendered_image.get() != nullptr);
+		rendered_text->rects.push_back(
+		   std::unique_ptr<UI::RenderedRect>(new UI::RenderedRect(rendered_image)));
+		return rendered_text;
 	}
-	bool is_expanding() override {
+
+	bool is_expanding() const override {
 		return is_expanding_;
 	}
 	void set_w(uint16_t w) override {
 		w_ = w;
 	}
 
-	void set_background(const Image* s) {
+	void set_background(const Image* s, const std::string& filename) {
 		background_image_ = s;
+		filename_ = filename;
 		h_ = s->height();
 	}
 
 private:
 	uint16_t w_, h_;
 	const Image* background_image_;  // not owned
+	std::string filename_;
 	bool is_expanding_;
 };
 
@@ -690,13 +790,17 @@
 		nodes_to_render_.clear();
 	}
 
-	uint16_t width() override {
+	std::string debug_info() const override {
+		return "div";
+	}
+
+	uint16_t width() const override {
 		return w_ + margin_.left + margin_.right;
 	}
-	uint16_t height() override {
+	uint16_t height() const override {
 		return h_ + margin_.top + margin_.bottom;
 	}
-	uint16_t hotspot_y() override {
+	uint16_t hotspot_y() const override {
 		return height();
 	}
 
@@ -704,60 +808,48 @@
 		return desired_width_;
 	}
 
-	Texture* render(TextureCache* texture_cache) override {
-		if (width() > g_gr->max_texture_size() || height() > g_gr->max_texture_size()) {
-			const std::string error_message =
-			   (boost::format("Texture (%d, %d) too big! Maximum size is %d.") % width() % height() %
-			    g_gr->max_texture_size())
-			      .str();
-			log("%s\n", error_message.c_str());
-			throw TextureTooBig(error_message);
-		}
-		Texture* rv = new Texture(width(), height());
-		rv->fill_rect(Rectf(0, 0, rv->width(), rv->height()), RGBAColor(255, 255, 255, 0));
+	UI::RenderedText* render(TextureCache* texture_cache) override {
+		UI::RenderedText* rendered_text = new UI::RenderedText();
+		// Preserve padding
+		rendered_text->rects.push_back(std::unique_ptr<UI::RenderedRect>(
+		   new UI::RenderedRect(Recti(0, 0, width(), height()), nullptr)));
 
 		// Draw Solid background Color
-		bool set_alpha = true;
 		if (is_background_color_set_) {
-			rv->fill_rect(Rectf(margin_.left, margin_.top, w_, h_), background_color_);
-			set_alpha = false;
+			UI::RenderedRect* bg_rect =
+			   new UI::RenderedRect(Recti(margin_.left, margin_.top, w_, h_), background_color_);
+			// Size is automatically adjusted in RenderedText while blitting, so no need to call
+			// check_size() here.
+			rendered_text->rects.push_back(std::unique_ptr<UI::RenderedRect>(std::move(bg_rect)));
 		}
 
 		// Draw background image (tiling)
-		if (background_image_) {
-			Rectf dst;
-			Rectf src(0, 0, 0, 0);
-
-			for (uint16_t cury = margin_.top; cury < h_ + margin_.top;
-			     cury += background_image_->height()) {
-				for (uint16_t curx = margin_.left; curx < w_ + margin_.left;
-				     curx += background_image_->width()) {
-					dst.x = curx;
-					dst.y = cury;
-					src.w = dst.w = min<int>(background_image_->width(), w_ + margin_.left - curx);
-					src.h = dst.h = min<int>(background_image_->height(), h_ + margin_.top - cury);
-					rv->blit(dst, *background_image_, src, 1., BlendMode::Copy);
+		if (background_image_ != nullptr) {
+			UI::RenderedRect* bg_rect =
+			   new UI::RenderedRect(Recti(margin_.left, margin_.top, w_, h_), background_image_);
+			check_size(bg_rect->width(), bg_rect->height());
+			rendered_text->rects.push_back(std::unique_ptr<UI::RenderedRect>(std::move(bg_rect)));
+		}
+
+		for (RenderNode* n : nodes_to_render_) {
+			const auto& renderme = n->render(texture_cache);
+			for (auto& rendered_rect : renderme->rects) {
+				if (rendered_rect->was_visited()) {
+					rendered_rect->set_origin(
+					   Vector2i(x() + rendered_rect->x(), y() + rendered_rect->y() + margin_.top));
+
+				} else {
+					rendered_rect->set_origin(
+					   Vector2i(x() + n->x() + margin_.left, y() + n->y() + margin_.top));
+					rendered_rect->set_visited();
 				}
-			}
-			set_alpha = false;
-		}
-
-		for (RenderNode* n : nodes_to_render_) {
-			Texture* node_texture = n->render(texture_cache);
-			if (node_texture) {
-				Rectf dst(n->x() + margin_.left, n->y() + margin_.top, node_texture->width(),
-				          node_texture->height());
-				Rectf src(0, 0, node_texture->width(), node_texture->height());
-				rv->blit(
-				   dst, *node_texture, src, 1., set_alpha ? BlendMode::Copy : BlendMode::UseAlpha);
-				delete node_texture;
+				rendered_text->rects.push_back(std::move(rendered_rect));
 			}
 			delete n;
 		}
-
 		nodes_to_render_.clear();
 
-		return rv;
+		return rendered_text;
 	}
 	const vector<Reference> get_references() override {
 		return refs_;
@@ -806,30 +898,62 @@
 	   : RenderNode(ns),
 	     image_(use_playercolor ? playercolor_image(color, image_filename) :
 	                              g_gr->images().get(image_filename)),
-	     scale_(scale) {
-	}
-
-	uint16_t width() override {
+	     filename_(image_filename),
+	     scale_(scale),
+	     color_(color),
+	     use_playercolor_(use_playercolor) {
+		check_size();
+	}
+
+	std::string debug_info() const override {
+		return "img";
+	}
+
+	uint16_t width() const override {
 		return scale_ * image_->width();
 	}
-	uint16_t height() override {
-		return scale_ * image_->height();
-	}
-	uint16_t hotspot_y() override {
-		return scale_ * image_->height();
-	}
-	Texture* render(TextureCache* texture_cache) override;
+	uint16_t height() const override {
+		return scale_ * image_->height();
+	}
+	uint16_t hotspot_y() const override {
+		return scale_ * image_->height();
+	}
+	UI::RenderedText* render(TextureCache* texture_cache) override;
 
 private:
 	const Image* image_;
+	const std::string filename_;
 	const double scale_;
+	const RGBColor& color_;
+	bool use_playercolor_;
 };
 
-Texture* ImgRenderNode::render(TextureCache* /* texture_cache */) {
-	Texture* rv = new Texture(width(), height());
-	rv->blit(Rectf(0, 0, width(), height()), *image_, Rectf(0, 0, image_->width(), image_->height()),
-	         1., BlendMode::Copy);
-	return rv;
+UI::RenderedText* ImgRenderNode::render(TextureCache* texture_cache) {
+	UI::RenderedText* rendered_text = new UI::RenderedText();
+
+	if (scale_ == 1.0) {
+		// Image can be used as is, and has already been cached in g_gr->images()
+		assert(image_ != nullptr);
+		rendered_text->rects.push_back(
+		   std::unique_ptr<UI::RenderedRect>(new UI::RenderedRect(image_)));
+	} else {
+		const std::string hash = (boost::format("rt:img:%s:%s:%i:%i") % filename_ %
+		                          (use_playercolor_ ? color_.hex_value() : "") % width() % height())
+		                            .str();
+		std::shared_ptr<const Image> rendered_image = texture_cache->get(hash);
+		if (rendered_image.get() == nullptr) {
+			auto texture = std::make_shared<Texture>(width(), height());
+			texture->blit(Rectf(0.f, 0.f, width(), height()), *image_,
+			              Rectf(0.f, 0.f, image_->width(), image_->height()), 1., BlendMode::Copy);
+			rendered_image = texture_cache->insert(hash, std::move(texture));
+		}
+
+		assert(rendered_image.get() != nullptr);
+		rendered_text->rects.push_back(
+		   std::unique_ptr<UI::RenderedRect>(new UI::RenderedRect(rendered_image)));
+	}
+
+	return rendered_text;
 }
 // End: Helper Stuff
 
@@ -1136,6 +1260,7 @@
 	                 const UI::FontSets& fontsets)
 	   : TagHandler(tag, fc, ns, image_cache, init_renderer_style, fontsets),
 	     background_image_(nullptr),
+	     image_filename_(""),
 	     space_(0) {
 	}
 
@@ -1151,6 +1276,7 @@
 			fill_text_ = a["fill"].get_string();
 			try {
 				background_image_ = image_cache_->get(fill_text_);
+				image_filename_ = fill_text_;
 				fill_text_ = "";
 			} catch (ImageNotFound&) {
 			}
@@ -1172,7 +1298,7 @@
 				sn = new SpaceNode(nodestyle_, 0, 0, true);
 
 			if (background_image_)
-				sn->set_background(background_image_);
+				sn->set_background(background_image_, image_filename_);
 			rn = sn;
 		}
 		nodes.push_back(rn);
@@ -1181,6 +1307,7 @@
 private:
 	string fill_text_;
 	const Image* background_image_;
+	std::string image_filename_;
 	uint16_t space_;
 };
 
@@ -1481,10 +1608,11 @@
 	return nodes[0];
 }
 
-Texture* Renderer::render(const string& text, uint16_t width, const TagSet& allowed_tags) {
+std::shared_ptr<const UI::RenderedText>
+Renderer::render(const string& text, uint16_t width, const TagSet& allowed_tags) {
 	std::unique_ptr<RenderNode> node(layout_(text, width, allowed_tags));
 
-	return node->render(texture_cache_);
+	return std::shared_ptr<const UI::RenderedText>(std::move(node->render(texture_cache_)));
 }
 
 IRefMap*

=== modified file 'src/graphic/text/rt_render.h'
--- src/graphic/text/rt_render.h	2017-01-25 18:55:59 +0000
+++ src/graphic/text/rt_render.h	2017-05-23 21:33:09 +0000
@@ -28,11 +28,10 @@
 
 #include "graphic/color.h"
 #include "graphic/image.h"
+#include "graphic/image_cache.h"
 #include "graphic/text/font_set.h"
-
-class Texture;
-class ImageCache;
-class TextureCache;
+#include "graphic/text/rendered_text.h"
+#include "graphic/text/texture_cache.h"
 
 namespace RT {
 
@@ -80,9 +79,9 @@
 	~Renderer();
 
 	// Render the given string in the given width. Restricts the allowed tags to
-	// the ones in TagSet. The renderer does not do caching in the TextureCache
-	// for its individual nodes, but the font render does.
-	Texture* render(const std::string&, uint16_t width, const TagSet& tagset = TagSet());
+	// the ones in TagSet.
+	std::shared_ptr<const UI::RenderedText>
+	render(const std::string&, uint16_t width, const TagSet& tagset = TagSet());
 
 	// Returns a reference map of the clickable hyperlinks in the image. This
 	// will do no caching and needs to do all layouting, so do not call this too

=== modified file 'src/graphic/text/sdl_ttf_font.cc'
--- src/graphic/text/sdl_ttf_font.cc	2017-01-25 18:55:59 +0000
+++ src/graphic/text/sdl_ttf_font.cc	2017-05-23 21:33:09 +0000
@@ -63,17 +63,18 @@
 	*gh = h;
 }
 
-const Texture& SdlTtfFont::render(const std::string& txt,
-                                  const RGBColor& clr,
-                                  int style,
-                                  TextureCache* texture_cache) {
+std::shared_ptr<const Image> SdlTtfFont::render(const std::string& txt,
+                                                const RGBColor& clr,
+                                                int style,
+                                                TextureCache* texture_cache) {
 	const std::string hash =
-	   (boost::format("%s:%s:%i:%02x%02x%02x:%i") % font_name_ % ptsize_ % txt %
+	   (boost::format("ttf:%s:%s:%i:%02x%02x%02x:%i") % font_name_ % ptsize_ % txt %
 	    static_cast<int>(clr.r) % static_cast<int>(clr.g) % static_cast<int>(clr.b) % style)
 	      .str();
-	const Texture* rv = texture_cache->get(hash);
-	if (rv)
-		return *rv;
+	std::shared_ptr<const Image> rv = texture_cache->get(hash);
+	if (rv.get() != nullptr) {
+		return rv;
+	}
 
 	set_style(style);
 
@@ -128,7 +129,7 @@
 		throw RenderError(
 		   (boost::format("Rendering '%s' gave the error: %s") % txt % TTF_GetError()).str());
 
-	return *texture_cache->insert(hash, std::unique_ptr<Texture>(new Texture(text_surface)));
+	return texture_cache->insert(hash, std::make_shared<Texture>(text_surface));
 }
 
 uint16_t SdlTtfFont::ascent(int style) const {

=== modified file 'src/graphic/text/sdl_ttf_font.h'
--- src/graphic/text/sdl_ttf_font.h	2017-02-28 20:07:07 +0000
+++ src/graphic/text/sdl_ttf_font.h	2017-05-23 21:33:09 +0000
@@ -25,8 +25,8 @@
 
 #include <SDL_ttf.h>
 
+#include "graphic/text/texture_cache.h"
 #include "graphic/texture.h"
-#include "graphic/texture_cache.h"
 
 namespace RT {
 
@@ -51,7 +51,8 @@
 	}
 
 	virtual void dimensions(const std::string&, int, uint16_t*, uint16_t*) = 0;
-	virtual const Texture& render(const std::string&, const RGBColor& clr, int, TextureCache*) = 0;
+	virtual std::shared_ptr<const Image>
+	render(const std::string&, const RGBColor& clr, int, TextureCache*) = 0;
 
 	virtual uint16_t ascent(int) const = 0;
 	virtual TTF_Font* get_ttf_font() const = 0;
@@ -64,7 +65,8 @@
 	virtual ~SdlTtfFont();
 
 	void dimensions(const std::string&, int, uint16_t* w, uint16_t* h) override;
-	const Texture& render(const std::string&, const RGBColor& clr, int, TextureCache*) override;
+	std::shared_ptr<const Image>
+	render(const std::string&, const RGBColor& clr, int, TextureCache*) override;
 	uint16_t ascent(int) const override;
 	TTF_Font* get_ttf_font() const override {
 		return font_;

=== modified file 'src/graphic/text/test/CMakeLists.txt'
--- src/graphic/text/test/CMakeLists.txt	2015-10-15 10:46:37 +0000
+++ src/graphic/text/test/CMakeLists.txt	2017-05-23 21:33:09 +0000
@@ -23,7 +23,6 @@
   DEPENDS
     base_i18n
     graphic_image_cache
-    graphic_surface
     graphic_text
     io_filesystem
 )

=== modified file 'src/graphic/text/test/render.cc'
--- src/graphic/text/test/render.cc	2017-01-25 18:55:59 +0000
+++ src/graphic/text/test/render.cc	2017-05-23 21:33:09 +0000
@@ -28,7 +28,7 @@
 #include "graphic/image_cache.h"
 #include "graphic/text/rt_render.h"
 #include "graphic/text/test/paths.h"
-#include "graphic/texture_cache.h"
+#include "graphic/text/texture_cache.h"
 #include "io/filesystem/layered_filesystem.h"
 
 StandaloneRenderer::StandaloneRenderer() {

=== modified file 'src/graphic/text/test/render_richtext.cc'
--- src/graphic/text/test/render_richtext.cc	2017-01-25 18:55:59 +0000
+++ src/graphic/text/test/render_richtext.cc	2017-05-23 21:33:09 +0000
@@ -33,6 +33,7 @@
 #include "config.h"
 #include "graphic/graphic.h"
 #include "graphic/image_io.h"
+#include "graphic/rendertarget.h"
 #include "graphic/text/rt_errors.h"
 #include "graphic/text/test/render.h"
 #include "graphic/texture.h"
@@ -138,11 +139,15 @@
 	StandaloneRenderer standalone_renderer;
 
 	try {
-		std::unique_ptr<Texture> texture(
-		   standalone_renderer.renderer()->render(txt, w, allowed_tags));
+		std::shared_ptr<const UI::RenderedText> rendered_text =
+		   standalone_renderer.renderer()->render(txt, w, allowed_tags);
+		std::unique_ptr<Texture> texture(new Texture(rendered_text->width(), rendered_text->height()));
+		std::unique_ptr<RenderTarget> dst(new RenderTarget(texture.get()));
+		rendered_text->draw(*dst.get(), Vector2i::zero());
 
 		std::unique_ptr<FileSystem> fs(&FileSystem::create("."));
 		std::unique_ptr<StreamWrite> sw(fs->open_stream_write(outname));
+
 		if (!save_to_png(texture.get(), sw.get(), ColorType::RGBA)) {
 			std::cout << "Could not encode PNG." << std::endl;
 		}

=== added file 'src/graphic/text/texture_cache.h'
--- src/graphic/text/texture_cache.h	1970-01-01 00:00:00 +0000
+++ src/graphic/text/texture_cache.h	2017-05-23 21:33:09 +0000
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2017 by the Widelands Development Team
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#ifndef WL_GRAPHIC_TEXT_TEXTURE_CACHE_H
+#define WL_GRAPHIC_TEXT_TEXTURE_CACHE_H
+
+#include <memory>
+
+#include "graphic/image.h"
+#include "graphic/text/transient_cache.h"
+
+class TextureCache : public TransientCache<Image> {
+public:
+	TextureCache(uint32_t max_size_in_bytes) : TransientCache<Image>(max_size_in_bytes) {
+	}
+
+	std::shared_ptr<const Image> insert(const std::string& hash,
+	                                    std::shared_ptr<const Image> entry) override {
+		return TransientCache<Image>::insert(hash, entry, entry->width() * entry->height() * 4);
+	}
+};
+
+#endif  // end of include guard: WL_GRAPHIC_TEXT_TEXTURE_CACHE_H

=== renamed file 'src/graphic/texture_cache.h' => 'src/graphic/text/transient_cache.h'
--- src/graphic/texture_cache.h	2017-01-25 18:55:59 +0000
+++ src/graphic/text/transient_cache.h	2017-05-23 21:33:09 +0000
@@ -17,8 +17,8 @@
  *
  */
 
-#ifndef WL_GRAPHIC_TEXTURE_CACHE_H
-#define WL_GRAPHIC_TEXTURE_CACHE_H
+#ifndef WL_GRAPHIC_TEXT_TRANSIENT_CACHE_H
+#define WL_GRAPHIC_TEXT_TRANSIENT_CACHE_H
 
 #include <cassert>
 #include <list>
@@ -26,55 +26,132 @@
 #include <memory>
 #include <string>
 
+#include <SDL.h>
 #include <boost/utility.hpp>
 
 #include "base/macros.h"
 
-class Texture;
+// The implementation took inspiration from
+// https://timday.bitbucket.io/lru.html, but our use case here is a little
+// different.
 
-// Caches transient Surfaces, i.e. those that are always free to be deleted
-// because they can be regenerated - somebody else must then recreate them when
-// they are needed again.
-//
-// Nothing in Widelands should hold onto a Surface they get from this class,
-// instead, they should use it only temporarily and rerequest it whenever they
-// need it.
-class TextureCache {
+/// Caches transient rendered text. The entries will be kept until the memory limit is reached,
+/// then the stalest entries will be deleted to make room for new entries.
+///
+/// We use shared_ptr so that other objects can hold on to the textures if they need them more
+/// permanently.
+template <typename T> class TransientCache {
 public:
-	// Create a new Cache whichs combined pixels data in all transient surfaces
-	// are always below the 'max_size_in_bytes'.
-	TextureCache(uint32_t max_size_in_bytes);
-	~TextureCache();
+	/// Create a new cache in which the combined data size for all transient entries is always below
+	/// the 'max_size_in_arbitrary_unit'.
+	TransientCache(uint32_t max_size_in_arbitrary_unit);
+	virtual ~TransientCache();
 
-	/// Deletes all surfaces in the cache leaving it as if it were just created.
+	/// Deletes all entries in the cache, leaving it as if it were just created.
 	void flush();
 
 	/// Returns an entry if it is cached, nullptr otherwise.
-	Texture* get(const std::string& hash);
-
-	// Inserts this entry into the TextureCache. asserts() that there is no
-	// entry with this hash already cached. Returns the given Surface for
-	// convenience. If 'transient' is false, this surface will not be deleted
-	// automatically - use this if surfaces are around for a long time and
-	// recreation is expensive (i.e. images loaded from disk).
-	Texture* insert(const std::string& hash, std::unique_ptr<Texture> texture);
+	std::shared_ptr<const T> get(const std::string& hash);
+
+
+	/// Inserts this entry of type T into the cache. Returns the given T for convenience.
+	/// When overriding this function, calculate the size of 'entry' and then call
+	/// insert(hash, entry, entry_size_in_size_unit).
+	virtual std::shared_ptr<const T> insert(const std::string& hash,
+	                                std::shared_ptr<const T> entry) = 0;
+
+protected:
+	/// Inserts this entry of type T into the cache. asserts() that there is no entry with this hash
+	/// already cached. Returns the given T for convenience.
+	std::shared_ptr<const T> insert(const std::string& hash,
+	                                std::shared_ptr<const T> entry,
+	                                uint32_t entry_size_in_size_unit);
 
 private:
+	/// Drop the oldest entry
 	void drop();
 
 	using AccessHistory = std::list<std::string>;
 	struct Entry {
-		std::unique_ptr<Texture> texture;
+		std::shared_ptr<const T> entry;
+		uint32_t size;
 		uint32_t last_access;  // Mainly for debugging and analysis.
 		const AccessHistory::iterator list_iterator;
 	};
 
-	uint32_t max_size_in_bytes_;
-	uint32_t size_in_bytes_;
+	uint32_t max_size_in_size_unit_;
+	uint32_t size_in_size_unit_;
 	std::map<std::string, Entry> entries_;
 	AccessHistory access_history_;
 
-	DISALLOW_COPY_AND_ASSIGN(TextureCache);
+	DISALLOW_COPY_AND_ASSIGN(TransientCache);
 };
 
-#endif  // end of include guard: WL_GRAPHIC_TEXTURE_CACHE_H
+// Implementation
+
+template <typename T>
+TransientCache<T>::TransientCache(uint32_t max_size_in_arbitrary_unit)
+   : max_size_in_size_unit_(max_size_in_arbitrary_unit), size_in_size_unit_(0) {
+}
+template <typename T> TransientCache<T>::~TransientCache() {
+	flush();
+}
+
+template <typename T> void TransientCache<T>::flush() {
+	access_history_.clear();
+	size_in_size_unit_ = 0;
+	entries_.clear();
+}
+
+/// Returns an entry if it is cached, nullptr otherwise.
+template <typename T> std::shared_ptr<const T> TransientCache<T>::get(const std::string& hash) {
+	const auto it = entries_.find(hash);
+	if (it == entries_.end()) {
+		return std::shared_ptr<const T>(nullptr);
+	}
+
+	// Move this to the back of the access list to signal that we have used this
+	// recently and update last access time.
+	access_history_.splice(access_history_.end(), access_history_, it->second.list_iterator);
+	it->second.last_access = SDL_GetTicks();
+	return it->second.entry;
+}
+
+template <typename T>
+std::shared_ptr<const T> TransientCache<T>::insert(const std::string& hash,
+                                                   std::shared_ptr<const T> entry,
+                                                   uint32_t entry_size_in_size_unit) {
+	assert(entries_.find(hash) == entries_.end());
+
+	while (!entries_.empty() &&
+	       size_in_size_unit_ + entry_size_in_size_unit > max_size_in_size_unit_) {
+		drop();
+	}
+
+	// Record hash as most-recently-used.
+	AccessHistory::iterator it = access_history_.insert(access_history_.end(), hash);
+	size_in_size_unit_ += entry_size_in_size_unit;
+	return entries_
+	   .insert(make_pair(hash, Entry{std::move(entry), entry_size_in_size_unit, SDL_GetTicks(), it}))
+	   .first->second.entry;
+}
+
+template <typename T> void TransientCache<T>::drop() {
+	assert(!access_history_.empty());
+
+	// Identify least recently used key
+	const auto it = entries_.find(access_history_.front());
+	assert(it != entries_.end());
+
+	size_in_size_unit_ -= it->second.size;
+	// TODO(GunChleoc): Remove the following line once everything is converted to the new font
+	// renderer and all testing has been done.
+	// log("TransientCache: Dropping %d bytes, new size %d. Hash: %s\n", it->second.size,
+	//    size_in_size_unit_, it->first.c_str());
+
+	// Erase both elements to completely purge record
+	entries_.erase(it);
+	access_history_.pop_front();
+}
+
+#endif  // end of include guard: WL_GRAPHIC_TEXT_TRANSIENT_CACHE_H

=== modified file 'src/graphic/text_layout.cc'
--- src/graphic/text_layout.cc	2017-05-13 13:14:29 +0000
+++ src/graphic/text_layout.cc	2017-05-23 21:33:09 +0000
@@ -48,14 +48,15 @@
 	boost::replace_all(*text, "&amp;", "&");  // Must be performed last
 }
 
-uint32_t text_width(const std::string& text, int ptsize) {
+int text_width(const std::string& text, int ptsize) {
 	return UI::g_fh1->render(as_editorfont(text, ptsize - UI::g_fh1->fontset()->size_offset()))
 	   ->width();
 }
 
-uint32_t text_height(const std::string& text, int ptsize) {
-	return UI::g_fh1->render(as_editorfont(text.empty() ? "." : text,
-	                                       ptsize - UI::g_fh1->fontset()->size_offset()))
+int text_height(int ptsize, UI::FontSet::Face face) {
+	return UI::g_fh1
+	   ->render(as_aligned(UI::g_fh1->fontset()->representative_character(), UI::Align::kLeft,
+	                       ptsize - UI::g_fh1->fontset()->size_offset(), RGBColor(0, 0, 0), face))
 	   ->height();
 }
 
@@ -162,8 +163,10 @@
 	           .str());
 }
 
-const Image* autofit_ui_text(const std::string& text, int width, RGBColor color, int fontsize) {
-	const Image* result = UI::g_fh1->render(as_uifont(richtext_escape(text), fontsize, color));
+std::shared_ptr<const UI::RenderedText>
+autofit_ui_text(const std::string& text, int width, RGBColor color, int fontsize) {
+	std::shared_ptr<const UI::RenderedText> result =
+	   UI::g_fh1->render(as_uifont(richtext_escape(text), fontsize, color));
 	if (width > 0) {  // Autofit
 		for (; result->width() > width && fontsize >= kMinimumFontSize; --fontsize) {
 			result = UI::g_fh1->render(
@@ -179,9 +182,14 @@
  * This mirrors the horizontal alignment for RTL languages.
  *
  * Do not store this value as it is based on the global font setting.
+ *
+ * If 'checkme' is not empty, mirror the alignment if the first 20 characters contain an RTL
+ * character. Otherwise, mirror if the current fontset is RTL.
  */
-Align mirror_alignment(Align alignment) {
-	if (UI::g_fh1->fontset()->is_rtl()) {
+Align mirror_alignment(Align alignment, const std::string& checkme) {
+	bool do_swap_alignment = checkme.empty() ? UI::g_fh1->fontset()->is_rtl() :
+	                                           i18n::has_rtl_character(checkme.c_str(), 20);
+	if (do_swap_alignment) {
 		switch (alignment) {
 		case Align::kLeft:
 			alignment = Align::kRight;

=== modified file 'src/graphic/text_layout.h'
--- src/graphic/text_layout.h	2017-05-13 13:14:29 +0000
+++ src/graphic/text_layout.h	2017-05-23 21:33:09 +0000
@@ -24,6 +24,7 @@
 
 #include "graphic/align.h"
 #include "graphic/color.h"
+#include "graphic/font_handler1.h"
 #include "graphic/image.h"
 #include "graphic/text/font_set.h"
 #include "graphic/text_constants.h"
@@ -38,14 +39,13 @@
   * Returns the exact width of the text rendered as editorfont for the given font size.
   * This function is inefficient; only call when we need the exact width.
   */
-
-uint32_t text_width(const std::string& text, int ptsize);
+int text_width(const std::string& text, int ptsize = UI_FONT_SIZE_SMALL);
 
 /**
-  * Returns the exact height of the text rendered as editorfont for the given font size.
+  * Returns the exact height of the text rendered for the given font size and face.
   * This function is inefficient; only call when we need the exact height.
   */
-uint32_t text_height(const std::string& text, int ptsize);
+int text_height(int ptsize = UI_FONT_SIZE_SMALL, UI::FontSet::Face face = UI::FontSet::Face::kSans);
 
 /**
  * Checks it the given string is RichText or not. Does not do validity checking.
@@ -95,14 +95,14 @@
   * smaller until it fits 'width'. The resulting font size will not go below
   * 'kMinimumFontSize'.
   */
-const Image* autofit_ui_text(const std::string& text,
-                             int width = 0,
-                             RGBColor color = UI_FONT_CLR_FG,
-                             int fontsize = UI_FONT_SIZE_SMALL);
+std::shared_ptr<const UI::RenderedText> autofit_ui_text(const std::string& text,
+                                                        int width = 0,
+                                                        RGBColor color = UI_FONT_CLR_FG,
+                                                        int fontsize = UI_FONT_SIZE_SMALL);
 
 namespace UI {
 
-Align mirror_alignment(Align alignment);
+Align mirror_alignment(Align alignment, const std::string& checkme = "");
 
 void center_vertically(uint32_t h, Vector2i* pt);
 void correct_for_align(Align, uint32_t w, Vector2i* pt);

=== modified file 'src/graphic/texture.cc'
--- src/graphic/texture.cc	2016-10-24 14:07:28 +0000
+++ src/graphic/texture.cc	2017-05-23 21:33:09 +0000
@@ -172,7 +172,7 @@
 void Texture::init(uint16_t w, uint16_t h) {
 	blit_data_ = {
 	   0,  // initialized below
-	   w, h, Rectf(0, 0, w, h),
+	   w, h, Rectf(0.f, 0.f, w, h),
 	};
 	if (w * h == 0) {
 		return;

=== modified file 'src/graphic/texture_atlas.cc'
--- src/graphic/texture_atlas.cc	2017-01-25 18:55:59 +0000
+++ src/graphic/texture_atlas.cc	2017-05-23 21:33:09 +0000
@@ -134,13 +134,13 @@
 	}
 
 	std::unique_ptr<Texture> texture_atlas(new Texture(root->r.w, root->r.h));
-	texture_atlas->fill_rect(Rectf(0, 0, root->r.w, root->r.h), RGBAColor(0, 0, 0, 0));
+	texture_atlas->fill_rect(Rectf(0.f, 0.f, root->r.w, root->r.h), RGBAColor(0, 0, 0, 0));
 
 	const auto packed_texture_id = texture_atlas->blit_data().texture_id;
 	for (Block& block : packed) {
 		texture_atlas->blit(
 		   Rectf(block.node->r.x, block.node->r.y, block.texture->width(), block.texture->height()),
-		   *block.texture, Rectf(0, 0, block.texture->width(), block.texture->height()), 1.,
+		   *block.texture, Rectf(0.f, 0.f, block.texture->width(), block.texture->height()), 1.,
 		   BlendMode::Copy);
 
 		pack_info->emplace_back(PackedTexture(

=== removed file 'src/graphic/texture_cache.cc'
--- src/graphic/texture_cache.cc	2017-01-25 18:55:59 +0000
+++ src/graphic/texture_cache.cc	1970-01-01 00:00:00 +0000
@@ -1,87 +0,0 @@
-/*
- * Copyright (C) 2006-2017 by the Widelands Development Team
- *
- * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-#include "graphic/texture_cache.h"
-
-#include <memory>
-
-#include <SDL.h>
-#include <stdint.h>
-
-#include "graphic/texture.h"
-
-// The implementation took inspiration from
-// http://timday.bitbucket.org/lru.html, but our use case here is a little
-// different.
-
-TextureCache::TextureCache(uint32_t max_size_in_bytes)
-   : max_size_in_bytes_(max_size_in_bytes), size_in_bytes_(0) {
-}
-
-TextureCache::~TextureCache() {
-	flush();
-}
-
-void TextureCache::flush() {
-	entries_.clear();
-	access_history_.clear();
-	size_in_bytes_ = 0;
-}
-
-Texture* TextureCache::get(const std::string& hash) {
-	const auto it = entries_.find(hash);
-	if (it == entries_.end())
-		return nullptr;
-
-	// Move this to the back of the access list to signal that we have used this
-	// recently and update last access time.
-	access_history_.splice(access_history_.end(), access_history_, it->second.list_iterator);
-	it->second.last_access = SDL_GetTicks();
-	return it->second.texture.get();
-}
-
-Texture* TextureCache::insert(const std::string& hash, std::unique_ptr<Texture> texture) {
-	assert(entries_.find(hash) == entries_.end());
-
-	const uint32_t texture_size = texture->width() * texture->height() * 4;
-	while (size_in_bytes_ + texture_size > max_size_in_bytes_) {
-		drop();
-	}
-
-	// Record hash as most-recently-used.
-	AccessHistory::iterator it = access_history_.insert(access_history_.end(), hash);
-	size_in_bytes_ += texture_size;
-	return entries_.insert(make_pair(hash, Entry{std::move(texture), SDL_GetTicks(), it}))
-	   .first->second.texture.get();
-}
-
-void TextureCache::drop() {
-	assert(!access_history_.empty());
-
-	// Identify least recently used key
-	const auto it = entries_.find(access_history_.front());
-	assert(it != entries_.end());
-
-	const uint32_t texture_size = it->second.texture->width() * it->second.texture->height() * 4;
-	size_in_bytes_ -= texture_size;
-
-	// Erase both elements to completely purge record
-	entries_.erase(it);
-	access_history_.pop_front();
-}

=== modified file 'src/graphic/wordwrap.cc'
--- src/graphic/wordwrap.cc	2017-05-13 13:14:29 +0000
+++ src/graphic/wordwrap.cc	2017-05-23 21:33:09 +0000
@@ -119,7 +119,7 @@
 	}
 
 	// Optimism: perhaps the entire line fits?
-	if (text_width(text.substr(line_start, orig_end - line_start), fontsize_) <=
+	if (uint32_t(text_width(text.substr(line_start, orig_end - line_start), fontsize_)) <=
 	    wrapwidth_ - safety_margin) {
 		line_end = orig_end;
 		next_line_start = orig_end + 1;
@@ -192,7 +192,8 @@
 	// Now make sure that it really fits.
 	std::string::size_type test_cutoff = line_start + end * 2 / 3;
 	while ((end > 0) && (static_cast<uint32_t>(line_start + end) > test_cutoff)) {
-		if (text_width(text.substr(line_start, end), fontsize_) > wrapwidth_ - safety_margin) {
+		if (uint32_t(text_width(text.substr(line_start, end), fontsize_)) >
+		    wrapwidth_ - safety_margin) {
 			--end;
 		} else {
 			break;
@@ -223,7 +224,7 @@
 	// calc_width_for_wrapping is fast, but it will underestimate the width.
 	// So, we test again with text_width to make sure that the line really fits.
 	return quick_width(i18n::make_ligatures(text.c_str())) <= wrapwidth_ - safety_margin &&
-	       text_width(text, fontsize_) <= wrapwidth_ - safety_margin;
+	       uint32_t(text_width(text, fontsize_)) <= wrapwidth_ - safety_margin;
 }
 
 /**
@@ -247,12 +248,7 @@
  * Compute the total height of the word-wrapped text.
  */
 uint32_t WordWrap::height() const {
-	uint16_t fontheight = 0;
-	if (!lines_.empty()) {
-		fontheight = text_height(lines_[0].text, fontsize_);
-	}
-
-	return fontheight * (lines_.size()) + 2 * kLineMargin;
+	return text_height(fontsize_) * (lines_.size()) + 2 * kLineMargin;
 }
 
 /**
@@ -305,9 +301,9 @@
 
 	Align alignment = mirror_alignment(align);
 
-	uint16_t fontheight = text_height(lines_[0].text, fontsize_);
+	const int fontheight = text_height(fontsize_);
 	for (uint32_t line = 0; line < lines_.size(); ++line, where.y += fontheight) {
-		if (where.y >= dst.height() || int32_t(where.y + fontheight) <= 0)
+		if (where.y >= dst.height() || (where.y + fontheight) <= 0)
 			continue;
 
 		Vector2i point(where.x, where.y);
@@ -316,10 +312,10 @@
 			point.x += wrapwidth_ - kLineMargin;
 		}
 
-		const Image* entry_text_im = UI::g_fh1->render(
+		std::shared_ptr<const UI::RenderedText> rendered_text = UI::g_fh1->render(
 		   as_editorfont(lines_[line].text, fontsize_ - UI::g_fh1->fontset()->size_offset(), color_));
-		UI::correct_for_align(alignment, entry_text_im->width(), &point);
-		dst.blit(point, entry_text_im);
+		UI::correct_for_align(alignment, rendered_text->width(), &point);
+		rendered_text->draw(dst, point);
 
 		if (draw_caret_ && line == caretline) {
 			std::string line_to_caret = lines_[line].text.substr(0, caretpos);

=== modified file 'src/graphic/wordwrap.h'
--- src/graphic/wordwrap.h	2017-04-29 14:57:30 +0000
+++ src/graphic/wordwrap.h	2017-05-23 21:33:09 +0000
@@ -27,8 +27,8 @@
 #include "base/vector.h"
 #include "graphic/align.h"
 #include "graphic/color.h"
+#include "graphic/text/sdl_ttf_font.h"
 #include "graphic/text_constants.h"
-#include "graphic/text/sdl_ttf_font.h"
 
 class RenderTarget;
 

=== modified file 'src/logic/editor_game_base.h'
--- src/logic/editor_game_base.h	2017-02-14 19:59:29 +0000
+++ src/logic/editor_game_base.h	2017-05-23 21:33:09 +0000
@@ -36,7 +36,7 @@
 namespace UI {
 struct ProgressWindow;
 }
-struct FullscreenMenuLaunchGame;
+class FullscreenMenuLaunchGame;
 class InteractiveBase;
 class InteractiveGameBase;  // TODO(GunChleoc): Get rid
 
@@ -78,7 +78,7 @@
 class EditorGameBase {
 public:
 	friend class InteractiveBase;
-	friend struct FullscreenMenuLaunchGame;
+	friend class FullscreenMenuLaunchGame;
 	friend struct GameClassPacket;
 
 	EditorGameBase(LuaInterface* lua);

=== modified file 'src/logic/map_objects/map_object.cc'
--- src/logic/map_objects/map_object.cc	2017-05-13 18:48:26 +0000
+++ src/logic/map_objects/map_object.cc	2017-05-23 21:33:09 +0000
@@ -20,6 +20,7 @@
 #include "logic/map_objects/map_object.h"
 
 #include <algorithm>
+#include <cmath>
 #include <cstdarg>
 #include <cstdio>
 #include <cstring>
@@ -463,30 +464,26 @@
 	}
 
 	// Rendering text is expensive, so let's just do it for only a few sizes.
-	scale = std::round(scale);
-	if (scale == 0.f) {
+	// The forumla is a bit fancy to avoid too much text overlap.
+	scale = std::round(2.f * (scale > 1.f ? std::sqrt(scale) : std::pow(scale, 2.f))) / 2.f;
+	if (scale < 1.f) {
 		return;
 	}
 	const int font_size = scale * UI_FONT_SIZE_SMALL;
 
 	// We always render this so we can have a stable position for the statistics string.
-	const Image* rendered_census_info =
-	   UI::g_fh1->render(as_condensed(census, UI::Align::kCenter, font_size), 120);
-
-	const Vector2i base_pos = field_on_dst.cast<int>() - Vector2i(0, 48) * scale;
-	Vector2i census_pos(base_pos);
-	UI::correct_for_align(UI::Align::kCenter, rendered_census_info->width(), &census_pos);
+	std::shared_ptr<const UI::RenderedText> rendered_census =
+	   UI::g_fh1->render(as_condensed(census, UI::Align::kCenter, font_size), 120 * scale);
+	Vector2i position = field_on_dst.cast<int>() - Vector2i(0, 48) * scale;
 	if (draw_text & TextToDraw::kCensus) {
-		dst->blit(census_pos, rendered_census_info, BlendMode::UseAlpha);
+		rendered_census->draw(*dst, position, UI::Align::kCenter);
 	}
 
 	if (draw_text & TextToDraw::kStatistics && !statictics.empty()) {
-		Vector2i statistics_pos =
-		   base_pos + Vector2i(0, rendered_census_info->height() / 2 + 10 * scale);
-		const Image* rendered_statictics =
+		std::shared_ptr<const UI::RenderedText> rendered_statistics =
 		   UI::g_fh1->render(as_condensed(statictics, UI::Align::kCenter, font_size));
-		UI::correct_for_align(UI::Align::kCenter, rendered_statictics->width(), &statistics_pos);
-		dst->blit(statistics_pos, rendered_statictics, BlendMode::UseAlpha);
+		position.y += rendered_census->height() + text_height(font_size) / 4;
+		rendered_statistics->draw(*dst, position, UI::Align::kCenter);
 	}
 }
 

=== modified file 'src/network/network.h'
--- src/network/network.h	2017-05-11 16:13:34 +0000
+++ src/network/network.h	2017-05-23 21:33:09 +0000
@@ -119,7 +119,7 @@
 	bool end_of_file() const override;
 
 private:
-	friend struct Deserializer;
+	friend class Deserializer;
 	std::vector<uint8_t> buffer;
 	size_t index_;
 };

=== modified file 'src/ui_basic/button.cc'
--- src/ui_basic/button.cc	2017-05-14 14:40:24 +0000
+++ src/ui_basic/button.cc	2017-05-23 21:33:09 +0000
@@ -58,9 +58,7 @@
      clr_down_(229, 161, 2) {
 	// Automatically resize for font height and give it a margin.
 	if (h < 1) {
-		int new_height =
-		   UI::g_fh1->render(as_uifont(UI::g_fh1->fontset()->representative_character()))->height() +
-		   4;
+		int new_height = text_height() + 4;
 		set_desired_size(w, new_height);
 		set_size(w, new_height);
 	}
@@ -207,13 +205,12 @@
 
 	} else if (title_.length()) {
 		//  Otherwise draw title string centered
-		const Image* entry_text_im =
+		std::shared_ptr<const UI::RenderedText> rendered_text =
 		   autofit_ui_text(title_, get_inner_w() - 2 * kButtonImageMargin,
 		                   is_monochrome ? UI_FONT_CLR_DISABLED : UI_FONT_CLR_FG);
 		// Blit on pixel boundary (not float), so that the text is blitted pixel perfect.
-		dst.blit(
-		   Vector2i((get_w() - entry_text_im->width()) / 2, (get_h() - entry_text_im->height()) / 2),
-		   entry_text_im);
+		rendered_text->draw(dst, Vector2i((get_w() - rendered_text->width()) / 2,
+		                                  (get_h() - rendered_text->height()) / 2));
 	}
 
 	//  draw border

=== modified file 'src/ui_basic/checkbox.cc'
--- src/ui_basic/checkbox.cc	2017-04-22 12:19:21 +0000
+++ src/ui_basic/checkbox.cc	2017-05-23 21:33:09 +0000
@@ -45,8 +45,8 @@
    : Panel(parent, p.x, p.y, kStateboxSize, kStateboxSize, tooltip_text),
      flags_(Is_Enabled),
      pic_graphics_(pic),
-     label_text_(""),
-     rendered_text_(nullptr) {
+     rendered_text_(nullptr),
+     label_text_("") {
 	uint16_t w = pic->width();
 	uint16_t h = pic->height();
 	set_desired_size(w, h);
@@ -63,8 +63,8 @@
    : Panel(parent, p.x, p.y, std::max(width, kStateboxSize), kStateboxSize, tooltip_text),
      flags_(Is_Enabled),
      pic_graphics_(g_gr->images().get("images/ui_basic/checkbox_light.png")),
-     label_text_(label_text),
-     rendered_text_(nullptr) {
+     rendered_text_(nullptr),
+     label_text_(label_text) {
 	set_flags(Has_Text, !label_text_.empty());
 	layout();
 }
@@ -83,7 +83,7 @@
 		rendered_text_ = label_text_.empty() ?
 		                    nullptr :
 		                    UI::g_fh1->render(as_uifont(label_text_), text_width(get_w(), pic_width));
-		if (rendered_text_) {
+		if (rendered_text_.get()) {
 			w = std::max(rendered_text_->width() + kPadding + pic_width, w);
 			h = std::max(rendered_text_->height(), h);
 		}
@@ -144,16 +144,16 @@
 	} else {
 		static_assert(0 <= kStateboxSize, "assert(0 <= STATEBOX_WIDTH) failed.");
 		static_assert(0 <= kStateboxSize, "assert(0 <= STATEBOX_HEIGHT) failed.");
-		Vector2i image_anchor(0, 0);
+		Vector2i image_anchor = Vector2i::zero();
 		Vector2i text_anchor(kStateboxSize + kPadding, 0);
 
-		if (rendered_text_) {
+		if (rendered_text_.get()) {
 			if (UI::g_fh1->fontset()->is_rtl()) {
 				text_anchor.x = 0;
 				image_anchor.x = rendered_text_->width() + kPadding;
 				image_anchor.y = (get_h() - kStateboxSize) / 2;
 			}
-			dst.blit(text_anchor, rendered_text_, BlendMode::UseAlpha);
+			rendered_text_->draw(dst, text_anchor);
 		}
 
 		dst.blitrect(

=== modified file 'src/ui_basic/checkbox.h'
--- src/ui_basic/checkbox.h	2017-02-12 09:10:57 +0000
+++ src/ui_basic/checkbox.h	2017-05-23 21:33:09 +0000
@@ -90,8 +90,8 @@
 			flags_ |= flags;
 	}
 	const Image* pic_graphics_;
+	std::shared_ptr<const UI::RenderedText> rendered_text_;
 	const std::string label_text_;
-	const Image* rendered_text_;
 };
 
 /**

=== modified file 'src/ui_basic/editbox.cc'
--- src/ui_basic/editbox.cc	2017-05-13 11:25:24 +0000
+++ src/ui_basic/editbox.cc	2017-05-23 21:33:09 +0000
@@ -80,15 +80,7 @@
                  int margin_y,
                  const Image* background,
                  int font_size)
-   : Panel(parent,
-           x,
-           y,
-           w,
-           h > 0 ? h :
-                   UI::g_fh1->render(as_editorfont(UI::g_fh1->fontset()->representative_character(),
-                                                   font_size))
-                         ->height() +
-                      2 * margin_y),
+   : Panel(parent, x, y, w, h > 0 ? h : text_height(font_size) + 2 * margin_y),
      m_(new EditBoxImpl),
      history_active_(false),
      history_position_(-1) {
@@ -380,15 +372,10 @@
 
 	const int max_width = get_w() - 2 * kMarginX;
 
-	const Image* entry_text_im = UI::g_fh1->render(as_editorfont(m_->text, m_->fontsize));
+	std::shared_ptr<const UI::RenderedText> rendered_text = UI::g_fh1->render(as_editorfont(m_->text, m_->fontsize));
 
-	const int linewidth = entry_text_im->width();
-	const int lineheight =
-	   m_->text.empty() ?
-	      UI::g_fh1->render(
-	                  as_editorfont(UI::g_fh1->fontset()->representative_character(), m_->fontsize))
-	         ->height() :
-	      entry_text_im->height();
+	const int linewidth = rendered_text->width();
+	const int lineheight = m_->text.empty() ? text_height(m_->fontsize) : rendered_text->height();
 
 	Vector2i point(kMarginX, get_h() / 2);
 	if (m_->align == UI::Align::kRight) {
@@ -405,18 +392,18 @@
 		// We want this always on, e.g. for mixed language savegame filenames
 		if (i18n::has_rtl_character(m_->text.c_str(), 100)) {  // Restrict check for efficiency
 			// TODO(GunChleoc): Arabic: Fix scrolloffset
-			dst.blitrect(point, entry_text_im, Recti(linewidth - max_width, 0, linewidth, lineheight));
+			rendered_text->draw(dst, point, Recti(linewidth - max_width, 0, linewidth, lineheight));
 		} else {
 			if (m_->align == UI::Align::kRight) {
 				// TODO(GunChleoc): Arabic: Fix scrolloffset
-				dst.blitrect(point, entry_text_im,
-				             Recti(point.x + m_->scrolloffset + kMarginX, 0, max_width, lineheight));
+				rendered_text->draw(
+				   dst, point, Recti(point.x + m_->scrolloffset + kMarginX, 0, max_width, lineheight));
 			} else {
-				dst.blitrect(point, entry_text_im, Recti(-m_->scrolloffset, 0, max_width, lineheight));
+				rendered_text->draw(dst, point, Recti(-m_->scrolloffset, 0, max_width, lineheight));
 			}
 		}
 	} else {
-		dst.blitrect(point, entry_text_im, Recti(0, 0, max_width, lineheight));
+		rendered_text->draw(dst, point, Recti(0, 0, max_width, lineheight));
 	}
 
 	if (has_focus()) {
@@ -425,7 +412,7 @@
 		// TODO(GunChleoc): Arabic: Fix cursor position for BIDI text.
 		int caret_x = text_width(line_to_caret, m_->fontsize);
 
-		const uint16_t fontheight = text_height(m_->text, m_->fontsize);
+		const uint16_t fontheight = text_height(m_->fontsize);
 
 		const Image* caret_image = g_gr->images().get("images/ui_basic/caret.png");
 		Vector2i caretpt = Vector2i::zero();

=== modified file 'src/ui_basic/listselect.cc'
--- src/ui_basic/listselect.cc	2017-05-14 14:40:24 +0000
+++ src/ui_basic/listselect.cc	2017-05-23 21:33:09 +0000
@@ -53,9 +53,7 @@
                                const Image* button_background,
                                const ListselectLayout selection_mode)
    : Panel(parent, x, y, w, h),
-     lineheight_(
-        UI::g_fh1->render(as_uifont(UI::g_fh1->fontset()->representative_character()))->height() +
-        kMargin),
+     lineheight_(text_height() + kMargin),
      scrollbar_(this, get_w() - Scrollbar::kSize, 0, Scrollbar::kSize, h, button_background),
      scrollpos_(0),
      selection_(no_selection_index()),
@@ -333,10 +331,10 @@
 	if (selection_mode_ == ListselectLayout::kDropdown) {
 		for (size_t i = 0; i < entry_records_.size(); ++i) {
 			const EntryRecord& er = *entry_records_[i];
-			const Image* entry_text_im = UI::g_fh1->render(as_uifont(
+			std::shared_ptr<const UI::RenderedText> rendered_text = UI::g_fh1->render(as_uifont(
 			   richtext_escape(er.name), UI_FONT_SIZE_SMALL, er.use_clr ? er.clr : UI_FONT_CLR_FG));
 			int picw = max_pic_width_ ? max_pic_width_ + 10 : 0;
-			int difference = entry_text_im->width() + picw + 8 - get_eff_w();
+			int difference = rendered_text->width() + picw + 8 - get_eff_w();
 			if (difference > 0) {
 				set_size(get_w() + difference, get_h());
 			}
@@ -378,10 +376,10 @@
 		assert(eff_h < std::numeric_limits<int32_t>::max());
 
 		const EntryRecord& er = *entry_records_[idx];
-		const Image* entry_text_im = UI::g_fh1->render(as_uifont(
+		std::shared_ptr<const UI::RenderedText> rendered_text = UI::g_fh1->render(as_uifont(
 		   richtext_escape(er.name), UI_FONT_SIZE_SMALL, er.use_clr ? er.clr : UI_FONT_CLR_FG));
 
-		int lineheight = std::max(get_lineheight(), entry_text_im->height());
+		int lineheight = std::max(get_lineheight(), rendered_text->height());
 
 		// Don't draw over the bottom edge
 		lineheight = std::min(eff_h - y, lineheight);
@@ -421,23 +419,22 @@
 			         er.pic);
 		}
 
+		// Position the text according to alignment
 		Align alignment = i18n::has_rtl_character(er.name.c_str(), 20) ? Align::kRight : Align::kLeft;
 		if (alignment == UI::Align::kRight) {
 			point.x += maxw - picw;
 		}
 
-		UI::correct_for_align(alignment, entry_text_im->width(), &point);
-
 		// Shift for image width
 		if (!UI::g_fh1->fontset()->is_rtl()) {
 			point.x += picw;
 		}
 
 		// Fix vertical position for mixed font heights
-		if (get_lineheight() > entry_text_im->height()) {
-			point.y += (lineheight_ - entry_text_im->height()) / 2;
+		if (get_lineheight() > rendered_text->height()) {
+			point.y += (lineheight_ - rendered_text->height()) / 2;
 		} else {
-			point.y -= (entry_text_im->height() - lineheight_) / 2;
+			point.y -= (rendered_text->height() - lineheight_) / 2;
 		}
 
 		// Don't draw over the bottom edge
@@ -445,21 +442,7 @@
 		if (lineheight < 0) {
 			break;
 		}
-
-		// Crop to column width while blitting
-		if ((alignment == UI::Align::kRight) &&
-		    (maxw + picw) < static_cast<uint32_t>(entry_text_im->width())) {
-			// Fix positioning for BiDi languages.
-			point.x = 0;
-
-			// We want this always on, e.g. for mixed language savegame filenames, or the languages
-			// list
-			dst.blitrect(point, entry_text_im, Recti(entry_text_im->width() - maxw + picw, 0, maxw,
-			                                         entry_text_im->height()));
-		} else {
-			dst.blitrect(point, entry_text_im, Recti(0, 0, maxw, lineheight));
-		}
-
+		rendered_text->draw(dst, point, Recti(0, 0, maxw, lineheight), alignment, RenderedText::CropMode::kSelf);
 		y += get_lineheight();
 		++idx;
 	}

=== modified file 'src/ui_basic/messagebox.cc'
--- src/ui_basic/messagebox.cc	2017-02-23 17:58:25 +0000
+++ src/ui_basic/messagebox.cc	2017-05-23 21:33:09 +0000
@@ -48,14 +48,14 @@
 	const int margin = 5;
 	int width, height = 0;
 	{
-		const Image* temp_rendered_text = g_fh1->render(as_uifont(text), maxwidth);
+		std::shared_ptr<const UI::RenderedText> temp_rendered_text = g_fh1->render(as_uifont(text), maxwidth);
 		width = temp_rendered_text->width();
 		height = temp_rendered_text->height();
 	}
 
 	// Stupid heuristic to avoid excessively long lines
 	if (height < 2 * UI_FONT_SIZE_SMALL) {
-		const Image* temp_rendered_text = g_fh1->render(as_uifont(text), maxwidth / 2);
+		std::shared_ptr<const UI::RenderedText> temp_rendered_text = g_fh1->render(as_uifont(text), maxwidth / 2);
 		width = temp_rendered_text->width();
 		height = temp_rendered_text->height();
 	}

=== modified file 'src/ui_basic/multilineeditbox.cc'
--- src/ui_basic/multilineeditbox.cc	2017-05-13 11:25:24 +0000
+++ src/ui_basic/multilineeditbox.cc	2017-05-23 21:33:09 +0000
@@ -91,7 +91,7 @@
                                    const Image* button_background)
    : Panel(parent, x, y, w, h), d_(new Data(*this, button_background)) {
 	d_->background = background;
-	d_->lineheight = text_height(g_fh1->fontset()->representative_character(), UI_FONT_SIZE_SMALL);
+	d_->lineheight = text_height();
 	set_handle_mouse(true);
 	set_can_focus(true);
 	set_thinks(false);

=== modified file 'src/ui_basic/multilinetextarea.cc'
--- src/ui_basic/multilinetextarea.cc	2017-05-13 11:25:24 +0000
+++ src/ui_basic/multilinetextarea.cc	2017-05-23 21:33:09 +0000
@@ -55,10 +55,7 @@
 
 	scrollbar_.moved.connect(boost::bind(&MultilineTextarea::scrollpos_changed, this, _1));
 
-	scrollbar_.set_singlestepsize(
-	   UI::g_fh1->render(
-	               as_uifont(UI::g_fh1->fontset()->representative_character(), UI_FONT_SIZE_SMALL))
-	      ->height());
+	scrollbar_.set_singlestepsize(text_height());
 	scrollbar_.set_steps(1);
 	scrollbar_.set_force_draw(scrollmode_ == ScrollMode::kScrollNormalForced ||
 	                          scrollmode_ == ScrollMode::kScrollLogForced);
@@ -88,13 +85,10 @@
 	for (int i = 0; i < 2; ++i) {
 		if (!is_richtext(text_)) {
 			use_old_renderer_ = false;
-			const Image* text_im =
-			   UI::g_fh1->render(make_richtext(), get_eff_w() - 2 * RICHTEXT_MARGIN);
-			height = text_im->height();
+			height = UI::g_fh1->render(make_richtext(), get_eff_w() - 2 * RICHTEXT_MARGIN)->height();
 		} else if (force_new_renderer_) {
 			use_old_renderer_ = false;
-			const Image* text_im = UI::g_fh1->render(text_, get_eff_w() - 2 * RICHTEXT_MARGIN);
-			height = text_im->height();
+			height = UI::g_fh1->render(text_, get_eff_w() - 2 * RICHTEXT_MARGIN)->height();
 		} else {
 			use_old_renderer_ = true;
 			rt.set_width(get_eff_w() - 2 * RICHTEXT_MARGIN);
@@ -150,19 +144,14 @@
 	if (use_old_renderer_) {
 		rt.draw(dst, Vector2i(RICHTEXT_MARGIN, RICHTEXT_MARGIN - scrollbar_.get_scrollpos()));
 	} else {
-		const Image* text_im;
-		if (!is_richtext(text_)) {
-			text_im = UI::g_fh1->render(make_richtext(), get_eff_w() - 2 * RICHTEXT_MARGIN);
-		} else {
-			text_im = UI::g_fh1->render(text_, get_eff_w() - 2 * RICHTEXT_MARGIN);
-		}
-
-		uint32_t blit_width = std::min(text_im->width(), static_cast<int>(get_eff_w()));
-		uint32_t blit_height = std::min(text_im->height(), static_cast<int>(get_inner_h()));
+		std::shared_ptr<const UI::RenderedText> rendered_text = UI::g_fh1->render(
+		   is_richtext(text_) ? text_ : make_richtext(), get_eff_w() - 2 * RICHTEXT_MARGIN);
+		uint32_t blit_width = std::min(rendered_text->width(), static_cast<int>(get_eff_w()));
+		uint32_t blit_height = std::min(rendered_text->height(), get_inner_h());
 
 		if (blit_width > 0 && blit_height > 0) {
 			int anchor = 0;
-			Align alignment = mirror_alignment(align_);
+			Align alignment = mirror_alignment(align_, text_);
 			switch (alignment) {
 			case UI::Align::kCenter:
 				anchor = (get_eff_w() - blit_width) / 2;
@@ -173,10 +162,8 @@
 			case UI::Align::kLeft:
 				anchor = RICHTEXT_MARGIN;
 			}
-
-			dst.blitrect(Vector2i(anchor, 0), text_im,
-			             Recti(0, scrollbar_.get_scrollpos(), blit_width, blit_height),
-			             BlendMode::UseAlpha);
+			rendered_text->draw(dst, Vector2i(anchor, 0),
+			                    Recti(0, scrollbar_.get_scrollpos(), blit_width, blit_height));
 		}
 	}
 }

=== modified file 'src/ui_basic/panel.cc'
--- src/ui_basic/panel.cc	2017-05-13 11:25:24 +0000
+++ src/ui_basic/panel.cc	2017-05-23 21:33:09 +0000
@@ -1060,13 +1060,14 @@
 		text_to_render = as_tooltip(text);
 	}
 
-	static const uint32_t TIP_WIDTH_MAX = 360;
-	const Image* rendered_text = g_fh1->render(text_to_render, TIP_WIDTH_MAX);
-	if (!rendered_text) {
+	constexpr uint32_t kTipWidthMax = 360;
+	std::shared_ptr<const UI::RenderedText> rendered_text = g_fh1->render(text_to_render, kTipWidthMax);
+	if (rendered_text->rects.empty()) {
 		return false;
 	}
-	uint16_t tip_width = rendered_text->width() + 4;
-	uint16_t tip_height = rendered_text->height() + 4;
+
+	const uint16_t tip_width = rendered_text->width() + 4;
+	const uint16_t tip_height = rendered_text->height() + 4;
 
 	Recti r(WLApplication::get()->get_mouse_position() + Vector2i(2, 32), tip_width, tip_height);
 	const Vector2i tooltip_bottom_right = r.opposite_of_origin();
@@ -1078,7 +1079,7 @@
 
 	dst.fill_rect(r, RGBColor(63, 52, 34));
 	dst.draw_rect(r, RGBColor(0, 0, 0));
-	dst.blit(r.origin() + Vector2i(2, 2), rendered_text);
+	rendered_text->draw(dst, r.origin() + Vector2i(2, 2));
 	return true;
 }
 }

=== modified file 'src/ui_basic/panel.h'
--- src/ui_basic/panel.h	2017-02-27 13:53:04 +0000
+++ src/ui_basic/panel.h	2017-05-23 21:33:09 +0000
@@ -28,7 +28,10 @@
 #include <boost/signals2/trackable.hpp>
 
 #include "base/macros.h"
+#include "base/rect.h"
 #include "base/vector.h"
+#include "graphic/align.h"
+#include "graphic/font_handler1.h"
 
 class RenderTarget;
 class Image;

=== modified file 'src/ui_basic/progressbar.cc'
--- src/ui_basic/progressbar.cc	2017-04-22 12:19:21 +0000
+++ src/ui_basic/progressbar.cc	2017-05-23 21:33:09 +0000
@@ -88,10 +88,9 @@
 	const std::string progress_text = (boost::format("<font color=%s>%u%%</font>") %
 	                                   UI_FONT_CLR_BRIGHT.hex_value() % floor(fraction * 100.f))
 	                                     .str();
-	const Image* rendered_text = UI::g_fh1->render(as_uifont(progress_text));
+	std::shared_ptr<const UI::RenderedText> rendered_text = UI::g_fh1->render(as_uifont(progress_text));
 	Vector2i pos(get_w() / 2, get_h() / 2);
-	UI::correct_for_align(UI::Align::kCenter, rendered_text->width(), &pos);
 	UI::center_vertically(rendered_text->height(), &pos);
-	dst.blit(pos, rendered_text, BlendMode::UseAlpha);
+	rendered_text->draw(dst, pos, UI::Align::kCenter);
 }
 }

=== modified file 'src/ui_basic/progresswindow.cc'
--- src/ui_basic/progresswindow.cc	2017-05-13 18:48:26 +0000
+++ src/ui_basic/progresswindow.cc	2017-05-23 21:33:09 +0000
@@ -63,8 +63,7 @@
 	label_center_.x = get_w() / 2;
 	label_center_.y = get_h() * PROGRESS_LABEL_POSITION_Y / 100;
 
-	const uint32_t h =
-	   UI::g_fh1->render(as_uifont(UI::g_fh1->fontset()->representative_character()))->height();
+	const uint32_t h = text_height();
 
 	label_rectangle_.x = get_w() / 4;
 	label_rectangle_.w = get_w() / 2;
@@ -99,11 +98,10 @@
 	draw(rt);
 
 	rt.fill_rect(label_rectangle_, PROGRESS_FONT_COLOR_BG);
-	const Image* rendered_text =
+	std::shared_ptr<const UI::RenderedText> rendered_text =
 	   UI::g_fh1->render(as_uifont(description, UI_FONT_SIZE_SMALL, PROGRESS_FONT_COLOR_FG));
-	UI::correct_for_align(UI::Align::kCenter, rendered_text->width(), &label_center_);
 	UI::center_vertically(rendered_text->height(), &label_center_);
-	rt.blit(label_center_, rendered_text, BlendMode::UseAlpha);
+	rendered_text->draw(rt, label_center_, UI::Align::kCenter);
 
 #ifdef _WIN32
 	// Pump events to prevent "not responding" on windows

=== modified file 'src/ui_basic/slider.cc'
--- src/ui_basic/slider.cc	2017-04-22 12:19:21 +0000
+++ src/ui_basic/slider.cc	2017-05-23 21:33:09 +0000
@@ -508,12 +508,7 @@
             w / (2 * labels_in.size()) - cursor_size / 2,
             0,
             w - (w / labels_in.size()) + cursor_size,
-            h -
-               UI::g_fh1->render(as_condensed(UI::g_fh1->fontset()->representative_character(),
-                                              UI::Align::kLeft,
-                                              UI_FONT_SIZE_SMALL - 2))
-                  ->height() -
-               2,
+            h - text_height(UI_FONT_SIZE_SMALL - 2, UI::FontSet::Face::kCondensed) - 2,
             0,
             labels_in.size() - 1,
             value_,
@@ -538,11 +533,10 @@
 	uint32_t gap_n = get_w() / labels.size();
 
 	for (uint32_t i = 0; i < labels.size(); i++) {
-		const Image* rendered_text =
+		std::shared_ptr<const UI::RenderedText> rendered_text =
 		   UI::g_fh1->render(as_condensed(labels[i], UI::Align::kCenter, UI_FONT_SIZE_SMALL - 2));
-		Vector2i point(gap_1 + i * gap_n, get_h() - rendered_text->height());
-		UI::correct_for_align(UI::Align::kCenter, rendered_text->width(), &point);
-		dst.blit(point, rendered_text, BlendMode::UseAlpha);
+		rendered_text->draw(
+		   dst, Vector2i(gap_1 + i * gap_n, get_h() - rendered_text->height()), UI::Align::kCenter);
 	}
 }
 
@@ -557,13 +551,8 @@
 	uint32_t h = get_h();
 	assert(labels.size());
 	slider.set_pos(Vector2i(w / (2 * labels.size()) - slider.cursor_size_ / 2, 0));
-	slider.set_size(
-	   w - (w / labels.size()) + slider.cursor_size_,
-	   h -
-	      UI::g_fh1->render(as_condensed(UI::g_fh1->fontset()->representative_character(),
-	                                     UI::Align::kLeft, UI_FONT_SIZE_SMALL - 2))
-	         ->height() +
-	      2);
+	slider.set_size(w - (w / labels.size()) + slider.cursor_size_,
+	                h - text_height(UI_FONT_SIZE_SMALL - 2, UI::FontSet::Face::kCondensed) + 2);
 	Panel::layout();
 }
 }

=== modified file 'src/ui_basic/table.cc'
--- src/ui_basic/table.cc	2017-05-14 14:40:24 +0000
+++ src/ui_basic/table.cc	2017-05-23 21:33:09 +0000
@@ -51,11 +51,8 @@
                     TableRows rowtype)
    : Panel(parent, x, y, w, h),
      total_width_(0),
-     headerheight_(
-        UI::g_fh1->render(as_uifont(UI::g_fh1->fontset()->representative_character()))->height() +
-        4),
-     lineheight_(
-        UI::g_fh1->render(as_uifont(UI::g_fh1->fontset()->representative_character()))->height()),
+     headerheight_(text_height() + 4),
+     lineheight_(text_height()),
      button_background_(button_background),
      scrollbar_(nullptr),
      scrollbar_filler_button_(
@@ -235,7 +232,7 @@
 		Columns::size_type const nr_columns = columns_.size();
 		for (uint32_t i = 0, curx = 0; i < nr_columns; ++i) {
 			const Column& column = columns_[i];
-			int const curw = column.width;
+			const int curw = column.width;
 			Align alignment = mirror_alignment(column.alignment);
 
 			const Image* entry_picture = er.get_picture(i);
@@ -288,52 +285,37 @@
 					}
 					dst.blit(Vector2i(draw_x, point.y + (lineheight - pich) / 2), entry_picture);
 				}
-				point.x += picw;
+				if (alignment != Align::kRight) {
+					point.x += picw;
+				}
 			}
 
-			++picw;  // A bit of margin between image and text
-
 			if (entry_string.empty()) {
 				curx += curw;
 				continue;
 			}
-			const Image* entry_text_im = UI::g_fh1->render(as_uifont(richtext_escape(entry_string)));
-
+			std::shared_ptr<const UI::RenderedText> rendered_text =
+			   UI::g_fh1->render(as_uifont(richtext_escape(entry_string)));
+
+			// Fix text alignment for BiDi languages if the entry contains an RTL character. We want
+			// this always on, e.g. for mixed language savegame filenames.
+			alignment = mirror_alignment(column.alignment, entry_string);
+
+			// Position the text according to alignment
 			switch (alignment) {
 			case UI::Align::kCenter:
 				point.x += (curw - picw) / 2;
 				break;
 			case UI::Align::kRight:
-				point.x += curw - 2 * picw;
+				point.x += curw - picw;
 				break;
 			case UI::Align::kLeft:
 				break;
 			}
 
-			// Add an offset for rightmost column when the scrollbar is shown.
-			int text_width = entry_text_im->width();
-			if (i == nr_columns - 1 && scrollbar_->is_enabled()) {
-				text_width = text_width + scrollbar_->get_w();
-			}
-			UI::correct_for_align(alignment, text_width, &point);
-
-			// Crop to column width while blitting
-			if ((curw + picw) < text_width) {
-				// Fix positioning for BiDi languages.
-				if (UI::g_fh1->fontset()->is_rtl()) {
-					point.x = (alignment == UI::Align::kRight) ? curx : curx + picw;
-				}
-				// We want this always on, e.g. for mixed language savegame filenames
-				if (i18n::has_rtl_character(
-				       entry_string.c_str(), 20)) {  // Restrict check for efficiency
-					dst.blitrect(
-					   point, entry_text_im, Recti(text_width - curw + picw, 0, text_width, lineheight));
-				} else {
-					dst.blitrect(point, entry_text_im, Recti(0, 0, curw - picw, lineheight));
-				}
-			} else {
-				dst.blitrect(point, entry_text_im, Recti(0, 0, curw - picw, lineheight));
-			}
+			constexpr int kMargin = 1;
+			rendered_text->draw(dst, point, Recti(kMargin, 0, curw - picw - 2 * kMargin, lineheight),
+			                    alignment, RenderedText::CropMode::kSelf);
 			curx += curw;
 		}
 

=== modified file 'src/ui_basic/tabpanel.cc'
--- src/ui_basic/tabpanel.cc	2017-05-13 11:25:24 +0000
+++ src/ui_basic/tabpanel.cc	2017-05-23 21:33:09 +0000
@@ -47,19 +47,23 @@
 Tab::Tab(TabPanel* const tab_parent,
          size_t const tab_id,
          int32_t x,
-         int32_t w,
          const std::string& name,
          const std::string& init_title,
          const Image* init_pic,
          const std::string& tooltip_text,
          Panel* const contents)
-   : NamedPanel(tab_parent, name, x, 0, w, kTabPanelButtonHeight, tooltip_text),
+   : NamedPanel(tab_parent, name, x, 0, kTabPanelButtonHeight, kTabPanelButtonHeight, tooltip_text),
      parent(tab_parent),
      id(tab_id),
      pic(init_pic),
-     title(init_title),
+     rendered_title(nullptr),
      tooltip(tooltip_text),
      panel(contents) {
+	if (!init_title.empty()) {
+		rendered_title = UI::g_fh1->render(as_uifont(init_title));
+		set_size(std::max(kTabPanelButtonHeight, rendered_title->width() + 2 * kTabPanelTextMargin),
+		         kTabPanelButtonHeight);
+	}
 }
 
 /**
@@ -165,9 +169,7 @@
                        const std::string& title,
                        Panel* const panel,
                        const std::string& tooltip_text) {
-	const Image* pic = UI::g_fh1->render(as_uifont(title));
-	return add_tab(std::max(kTabPanelButtonHeight, pic->width() + 2 * kTabPanelTextMargin), name,
-	               title, pic, tooltip_text, panel);
+	return add_tab(name, title, nullptr, tooltip_text, panel);
 }
 
 /**
@@ -177,12 +179,11 @@
                        const Image* pic,
                        Panel* const panel,
                        const std::string& tooltip_text) {
-	return add_tab(kTabPanelButtonHeight, name, "", pic, tooltip_text, panel);
+	return add_tab(name, "", pic, tooltip_text, panel);
 }
 
 /** Common adding function for textual and pictorial tabs. */
-uint32_t TabPanel::add_tab(int32_t width,
-                           const std::string& name,
+uint32_t TabPanel::add_tab(const std::string& name,
                            const std::string& title,
                            const Image* pic,
                            const std::string& tooltip_text,
@@ -192,7 +193,7 @@
 
 	size_t id = tabs_.size();
 	int32_t x = id > 0 ? tabs_[id - 1]->get_x() + tabs_[id - 1]->get_w() : 0;
-	tabs_.push_back(new Tab(this, id, x, width, name, title, pic, tooltip_text, panel));
+	tabs_.push_back(new Tab(this, id, x, name, title, pic, tooltip_text, panel));
 
 	// Add a margin if there is a border
 	if (border_type_ == TabPanel::Type::kBorder) {
@@ -282,10 +283,8 @@
 			dst.brighten_rect(Recti(x, 0, tab_width, kTabPanelButtonHeight), MOUSE_OVER_BRIGHT_FACTOR);
 		}
 
-		assert(tabs_[idx]->pic);
-
-		// If the title is empty, we will assume a pictorial tab
-		if (tabs_[idx]->title.empty()) {
+		// If pic is there, we will assume a pictorial tab
+		if (tabs_[idx]->pic != nullptr) {
 			// Scale the image down if needed, but keep the ratio.
 			constexpr int kMaxImageSize = kTabPanelButtonHeight - 2 * kTabPanelImageMargin;
 			double image_scale =
@@ -299,10 +298,10 @@
 			         (kTabPanelButtonHeight - picture_height) / 2, picture_width, picture_height),
 			   tabs_[idx]->pic, Recti(0, 0, tabs_[idx]->pic->width(), tabs_[idx]->pic->height()), 1,
 			   BlendMode::UseAlpha);
-		} else {
-			dst.blit(Vector2i(x + kTabPanelTextMargin,
-			                  (kTabPanelButtonHeight - tabs_[idx]->pic->height()) / 2),
-			         tabs_[idx]->pic, BlendMode::UseAlpha);
+		} else if (tabs_[idx]->rendered_title != nullptr) {
+			tabs_[idx]->rendered_title->draw(
+			   dst, Vector2i(x + kTabPanelTextMargin,
+			                 (kTabPanelButtonHeight - tabs_[idx]->rendered_title->height()) / 2));
 		}
 
 		// Draw top part of border

=== modified file 'src/ui_basic/tabpanel.h'
--- src/ui_basic/tabpanel.h	2017-02-12 09:10:57 +0000
+++ src/ui_basic/tabpanel.h	2017-05-23 21:33:09 +0000
@@ -46,7 +46,6 @@
 	Tab(TabPanel* parent,
 	    size_t id,
 	    int32_t x,
-	    int32_t w,
 	    const std::string& name,
 	    const std::string& title,
 	    const Image* pic,
@@ -68,7 +67,7 @@
 	uint32_t id;
 
 	const Image* pic;
-	std::string title;
+	std::shared_ptr<const UI::RenderedText> rendered_title;
 	std::string tooltip;
 	Panel* panel;
 };
@@ -136,8 +135,7 @@
 
 private:
 	// Common adding function for textual and pictorial tabs
-	uint32_t add_tab(int32_t width,
-	                 const std::string& name,
+	uint32_t add_tab(const std::string& name,
 	                 const std::string& title,
 	                 const Image* pic,
 	                 const std::string& tooltip,

=== modified file 'src/ui_basic/textarea.cc'
--- src/ui_basic/textarea.cc	2017-04-22 10:17:39 +0000
+++ src/ui_basic/textarea.cc	2017-05-23 21:33:09 +0000
@@ -127,8 +127,7 @@
 	if (!text_.empty()) {
 		Vector2i anchor(
 		   (align_ == Align::kCenter) ? get_w() / 2 : (align_ == UI::Align::kRight) ? get_w() : 0, 0);
-		UI::correct_for_align(align_, rendered_text_->width(), &anchor);
-		dst.blit(anchor, rendered_text_, BlendMode::UseAlpha);
+		rendered_text_->draw(dst, anchor, align_);
 	}
 }
 
@@ -188,14 +187,12 @@
 	uint32_t w = 0;
 	uint16_t h = 0;
 
-	if (rendered_text_) {
+	if (rendered_text_.get()) {
 		w = fixed_width_ > 0 ? fixed_width_ : rendered_text_->width();
 		h = rendered_text_->height();
 		// We want empty textareas to have height
 		if (text_.empty()) {
-			h = UI::g_fh1->render(
-			                as_uifont(UI::g_fh1->fontset()->representative_character(), fontsize_))
-			       ->height();
+			h = text_height(fontsize_);
 		}
 	}
 	set_desired_size(w, h);

=== modified file 'src/ui_basic/textarea.h'
--- src/ui_basic/textarea.h	2017-02-23 19:38:51 +0000
+++ src/ui_basic/textarea.h	2017-05-23 21:33:09 +0000
@@ -94,7 +94,7 @@
 
 	LayoutMode layoutmode_;
 	std::string text_;
-	const Image* rendered_text_;
+	std::shared_ptr<const UI::RenderedText> rendered_text_;
 	Align align_;
 	RGBColor color_;
 	int fontsize_;

=== modified file 'src/ui_basic/window.cc'
--- src/ui_basic/window.cc	2017-05-13 11:25:24 +0000
+++ src/ui_basic/window.cc	2017-05-23 21:33:09 +0000
@@ -272,14 +272,13 @@
 	// draw the title if we have one
 	if (!title_.empty()) {
 		// The title shouldn't be richtext, but we escape it just to make sure.
-		const Image* text =
+		std::shared_ptr<const UI::RenderedText> text =
 		   autofit_ui_text(richtext_escape(title_), get_inner_w(), UI_FONT_CLR_FG, 13);
 
 		// Blit on pixel boundary (not float), so that the text is blitted pixel perfect.
 		Vector2i pos(get_lborder() + get_inner_w() / 2, TP_B_PIXMAP_THICKNESS / 2);
-		UI::correct_for_align(UI::Align::kCenter, text->width(), &pos);
 		UI::center_vertically(text->height(), &pos);
-		dst.blit(pos, text, BlendMode::UseAlpha);
+		text->draw(dst, pos, UI::Align::kCenter);
 	}
 
 	if (!is_minimal_) {

=== modified file 'src/ui_fsmenu/loadgame.cc'
--- src/ui_fsmenu/loadgame.cc	2017-03-05 17:55:29 +0000
+++ src/ui_fsmenu/loadgame.cc	2017-05-23 21:33:09 +0000
@@ -332,19 +332,9 @@
 }
 
 std::string FullscreenMenuLoadGame::filename_list_string() {
-	std::set<uint32_t> selections = table_.selections();
 	boost::format message;
-	int counter = 0;
-	for (const uint32_t index : selections) {
-		++counter;
-		// TODO(GunChleoc): We can exceed the texture size for the font renderer,
-		// so we have to restrict this for now.
-		if (counter > 50) {
-			message = boost::format("%s\n%s") % message % "...";
-			break;
-		}
+	for (const uint32_t index : table_.selections()) {
 		const SavegameData& gamedata = games_data_[table_.get(table_.get_record(index))];
-
 		if (gamedata.errormessage.empty()) {
 			message =
 			   boost::format("%s\n%s") % message %

=== modified file 'src/wui/chatoverlay.cc'
--- src/wui/chatoverlay.cc	2017-04-22 12:19:21 +0000
+++ src/wui/chatoverlay.cc	2017-05-23 21:33:09 +0000
@@ -167,15 +167,15 @@
 	if (!m->havemessages_)
 		return;
 
-	const Image* im = nullptr;
+	std::shared_ptr<const UI::RenderedText> im = std::shared_ptr<const UI::RenderedText>(nullptr);
 	try {
 		im = UI::g_fh1->render(m->all_text_, get_w());
 	} catch (RT::WidthTooSmall&) {
 		// Oops, maybe one long word? We render again, not limiting the width, but
 		// render everything in one single line.
-		im = UI::g_fh1->render(m->all_text_, 0);
+		im = UI::g_fh1->render(m->all_text_);
 	}
-	assert(im != nullptr);
+	assert(im.get() != nullptr);
 
 	// Background
 	const int32_t height = im->height() > get_h() ? get_h() : im->height();
@@ -185,8 +185,6 @@
 	if (!m->transparent_) {
 		dst.fill_rect(Recti(0, top, width, height), RGBAColor(50, 50, 50, 128), BlendMode::Default);
 	}
-	int32_t topcrop = im->height() - height;
-	Recti cropRect(0, topcrop, width, height);
-
-	dst.blitrect(Vector2i(0, top), im, cropRect);
+	const int topcrop = im->height() - height;
+	im->draw(dst, Vector2i(0, top), Recti(0, topcrop, width, height));
 }

=== modified file 'src/wui/game_tips.cc'
--- src/wui/game_tips.cc	2017-05-13 18:48:26 +0000
+++ src/wui/game_tips.cc	2017-05-23 21:33:09 +0000
@@ -99,20 +99,17 @@
 }
 
 void GameTips::show_tip(int32_t index) {
-	// try to load a background
+	RenderTarget& rt = *g_gr->get_render_target();
+
 	const Image* pic_background = g_gr->images().get(BG_IMAGE);
-	assert(pic_background);
-
-	RenderTarget& rt = *g_gr->get_render_target();
-
-	uint16_t w = pic_background->width();
-	uint16_t h = pic_background->height();
+	const int w = pic_background->width();
+	const int h = pic_background->height();
 	Vector2i pt((g_gr->get_xres() - w) / 2, (g_gr->get_yres() - h) / 2);
-	Recti tips_area(pt, w, h);
 	rt.blit(pt, pic_background);
 
-	const Image* rendered_text = UI::g_fh1->render(as_game_tip(tips_[index].text), tips_area.w);
-	rt.blit(tips_area.center().cast<int>() -
-	           Vector2i(rendered_text->width() / 2, rendered_text->height() / 2),
-	        rendered_text);
+	std::shared_ptr<const UI::RenderedText> rendered_text =
+	   UI::g_fh1->render(as_game_tip(tips_[index].text), w);
+	pt = Vector2i((g_gr->get_xres() - rendered_text->width()) / 2,
+	              (g_gr->get_yres() - rendered_text->height()) / 2);
+	rendered_text->draw(rt, pt);
 }

=== modified file 'src/wui/interactive_base.cc'
--- src/wui/interactive_base.cc	2017-05-14 14:40:24 +0000
+++ src/wui/interactive_base.cc	2017-05-23 21:33:09 +0000
@@ -356,8 +356,8 @@
 		std::string node_text;
 		if (is_game) {
 			const std::string gametime(gametimestring(egbase().get_gametime(), true));
-			const std::string gametime_text = as_condensed(gametime);
-			dst.blit(Vector2i(5, 5), UI::g_fh1->render(gametime_text), BlendMode::UseAlpha);
+			std::shared_ptr<const UI::RenderedText> rendered_text = UI::g_fh1->render(as_condensed(gametime));
+			rendered_text->draw(dst, Vector2i(5, 5));
 
 			static boost::format node_format("(%i, %i)");
 			node_text = as_condensed((node_format % sel_.pos.node.x % sel_.pos.node.y).str());
@@ -366,20 +366,17 @@
 			const int32_t height = map[sel_.pos.node].get_height();
 			node_text = as_condensed((node_format % sel_.pos.node.x % sel_.pos.node.y % height).str());
 		}
-
-		const Image* rendered_text = UI::g_fh1->render(node_text);
-		Vector2i point(get_w() - 5, get_h() - rendered_text->height() - 5);
-		UI::correct_for_align(UI::Align::kRight, rendered_text->width(), &point);
-		dst.blit(point, rendered_text, BlendMode::UseAlpha);
+		std::shared_ptr<const UI::RenderedText> rendered_text = UI::g_fh1->render(node_text);
+		rendered_text->draw(
+		   dst, Vector2i(get_w() - 5, get_h() - rendered_text->height() - 5), UI::Align::kRight);
 	}
 
 	// Blit FPS when playing a game in debug mode.
 	if (get_display_flag(dfDebug) && is_game) {
 		static boost::format fps_format("%5.1f fps (avg: %5.1f fps)");
-		const Image* rendered_text = UI::g_fh1->render(as_condensed(
+		std::shared_ptr<const UI::RenderedText> rendered_text = UI::g_fh1->render(as_condensed(
 		   (fps_format % (1000.0 / frametime_) % (1000.0 / (avg_usframetime_ / 1000))).str()));
-		dst.blit(
-		   Vector2i((get_w() - rendered_text->width()) / 2, 5), rendered_text, BlendMode::UseAlpha);
+		rendered_text->draw(dst, Vector2i((get_w() - rendered_text->width()) / 2, 5));
 	}
 }
 

=== modified file 'src/wui/interactive_base.h'
--- src/wui/interactive_base.h	2017-03-03 18:13:55 +0000
+++ src/wui/interactive_base.h	2017-05-23 21:33:09 +0000
@@ -29,11 +29,11 @@
 #include "logic/map.h"
 #include "notifications/notifications.h"
 #include "profile/profile.h"
+#include "sound/note_sound.h"
+#include "sound/sound_handler.h"
 #include "ui_basic/box.h"
 #include "ui_basic/textarea.h"
 #include "ui_basic/unique_window.h"
-#include "sound/note_sound.h"
-#include "sound/sound_handler.h"
 #include "wui/chatoverlay.h"
 #include "wui/debugconsole.h"
 #include "wui/edge_overlay_manager.h"

=== modified file 'src/wui/interactive_gamebase.cc'
--- src/wui/interactive_gamebase.cc	2017-04-22 10:17:39 +0000
+++ src/wui/interactive_gamebase.cc	2017-05-23 21:33:09 +0000
@@ -126,10 +126,8 @@
 		}
 
 		if (!game_speed.empty()) {
-			Vector2i point(get_w() - 5, 5);
-			const Image* rendered_speed = UI::g_fh1->render(game_speed);
-			UI::correct_for_align(UI::Align::kRight, rendered_speed->width(), &point);
-			dst.blit(point, rendered_speed, BlendMode::UseAlpha);
+			std::shared_ptr<const UI::RenderedText> rendered_text = UI::g_fh1->render(game_speed);
+			rendered_text->draw(dst, Vector2i(get_w() - 5, 5), UI::Align::kRight);
 		}
 	}
 }

=== modified file 'src/wui/mapdetails.cc'
--- src/wui/mapdetails.cc	2017-02-23 17:58:25 +0000
+++ src/wui/mapdetails.cc	2017-05-23 21:33:09 +0000
@@ -102,9 +102,7 @@
 }
 
 void MapDetails::layout() {
-	name_label_.set_size(
-	   get_w() - padding_,
-	   UI::g_fh1->render(as_uifont(UI::g_fh1->fontset()->representative_character()))->height() + 2);
+	name_label_.set_size(get_w() - padding_, text_height() + 2);
 
 	// Adjust sizes for show / hide suggested teams
 	if (suggested_teams_box_->is_visible()) {

=== modified file 'src/wui/maptable.cc'
--- src/wui/maptable.cc	2017-03-05 17:55:29 +0000
+++ src/wui/maptable.cc	2017-05-23 21:33:09 +0000
@@ -33,7 +33,7 @@
 	add_column(35, _("Pl."), _("Number of players"), UI::Align::kCenter);
 	add_column(0, _("Filename"), _("The name of the map or scenario"), UI::Align::kLeft,
 	           UI::TableColumnType::kFlexible);
-	add_column(115, _("Size"), _("The size of the map (Width x Height)"));
+	add_column(90, _("Size"), _("The size of the map (Width x Height)"));
 	set_sort_column(0);
 }
 

=== modified file 'src/wui/plot_area.cc'
--- src/wui/plot_area.cc	2017-05-13 13:14:29 +0000
+++ src/wui/plot_area.cc	2017-05-23 21:33:09 +0000
@@ -178,17 +178,15 @@
                 const RGBColor& color,
                 const Vector2i& pos,
                 RenderTarget& dst) {
-	const Image* pic = UI::g_fh1->render(ytick_text_style(value, color));
+	std::shared_ptr<const UI::RenderedText> tick = UI::g_fh1->render(ytick_text_style(value, color));
 	Vector2i point(pos);  // Un-const this
-	UI::correct_for_align(UI::Align::kRight, pic->width(), &point);
-	UI::center_vertically(pic->height(), &point);
-	dst.blit(point, pic, BlendMode::UseAlpha);
+	UI::center_vertically(tick->height(), &point);
+	tick->draw(dst, point, UI::Align::kRight);
 }
 
 uint32_t calc_plot_x_max_ticks(int32_t plot_width) {
 	// Render a number with 3 digits (maximal length which should appear)
-	const Image* pic = UI::g_fh1->render(ytick_text_style(" -888 ", kAxisLineColor));
-	return plot_width / pic->width();
+	return plot_width / UI::g_fh1->render(ytick_text_style(" -888 ", kAxisLineColor))->width();
 }
 
 int calc_slider_label_width(const std::string& label) {
@@ -264,12 +262,11 @@
 
 		// The space at the end is intentional to have the tick centered
 		// over the number, not to the left
-		const Image* xtick = UI::g_fh1->render(
+		std::shared_ptr<const UI::RenderedText> xtick = UI::g_fh1->render(
 		   xtick_text_style((boost::format("-%u ") % (max_x / how_many_ticks * i)).str()));
 		Vector2i pos(posx, inner_h - kSpaceBottom + 10);
-		UI::correct_for_align(UI::Align::kCenter, xtick->width(), &pos);
 		UI::center_vertically(xtick->height(), &pos);
-		dst.blit(pos, xtick, BlendMode::UseAlpha);
+		xtick->draw(dst, pos, UI::Align::kCenter);
 
 		posx -= sub;
 	}
@@ -284,10 +281,10 @@
 	   kAxisLineColor, kAxisLinesWidth);
 
 	//  print the used unit
-	const Image* xtick = UI::g_fh1->render(xtick_text_style(get_generic_unit_name(unit)));
+	std::shared_ptr<const UI::RenderedText> xtick = UI::g_fh1->render(xtick_text_style(get_generic_unit_name(unit)));
 	Vector2i pos(2, kSpacing + 2);
 	UI::center_vertically(xtick->height(), &pos);
-	dst.blit(pos, xtick, BlendMode::UseAlpha);
+	xtick->draw(dst, pos);
 }
 
 }  // namespace

=== modified file 'src/wui/waresdisplay.cc'
--- src/wui/waresdisplay.cc	2017-05-13 13:14:29 +0000
+++ src/wui/waresdisplay.cc	2017-05-23 21:33:09 +0000
@@ -331,11 +331,10 @@
 	dst.fill_rect(Recti(p + Vector2i(0, WARE_MENU_PIC_HEIGHT), w, WARE_MENU_INFO_SIZE),
 	              info_color_for_ware(id));
 
-	const Image* text = UI::g_fh1->render(as_waresinfo(info_for_ware(id)));
-	if (text)  // might be zero when there is no info text.
-		dst.blit(p + Vector2i(w - text->width() - 1,
-		                      WARE_MENU_PIC_HEIGHT + WARE_MENU_INFO_SIZE + 1 - text->height()),
-		         text);
+	std::shared_ptr<const UI::RenderedText> rendered_text = UI::g_fh1->render(as_waresinfo(info_for_ware(id)));
+	rendered_text->draw(
+	   dst, Vector2i(p.x + w - rendered_text->width() - 1,
+	                 p.y + WARE_MENU_PIC_HEIGHT + WARE_MENU_INFO_SIZE + 1 - rendered_text->height()));
 }
 
 // Wares highlighting/selecting