#priority init -500
import elements.BaseGuiElement;
import elements.GuiIconGrid;
import elements.GuiMarkupText;
import elements.GuiResources;
import elements.GuiButton;
import elements.GuiContextMenu;
import elements.MarkupTooltip;
import elements.GuiOverlay;
import elements.GuiSkinElement;
import elements.GuiSprite;
import elements.GuiPanel;
import elements.GuiInfluenceCard;
import dialogs.MessageDialog;
import util.icon_view;
import util.formatting;
import resources;
import influence;
import traits;
import ftl;
import artifacts;
import statuses;
import abilities;
import targeting.ObjectTarget;
import targeting.PointTarget;
import planet_levels;
from orbitals import getOrbitalModuleID;
from traits import getTraitID;
from overlays.ContextMenu import openContextMenu;
from obj_selection import selectObject, uiObject, selectedObjects;
import tabs.Tab;
import void zoomTabTo(Object@ obj) from "tabs.GalaxyTab";
import void openOverlay(Object@ obj) from "tabs.GalaxyTab";
import void doQuickExport(Object@,bool) from "commands";
import void doQuickExport(const array<Object@>&,bool) from "commands";
from gui import animate_speed;

export Quickbar;

const int QUICKBAR_WIDTH = 256;
const int ANIM_SPEED = 512;

class QuickOption : GuiContextOption {
	Quickbar@ bar;
	uint index;

	QuickOption(Quickbar@ bar, uint index) {
		@this.bar = bar;
		this.index = index;
	}

	void call(GuiContextMenu@ menu) override {
		bar.modes[index].closed = !bar.modes[index].closed;
	}
};

class Quickbar : BaseGuiElement, Savable {
	array<QuickbarMode@> modes;
	GuiButton@ quickButton;
	GuiButton@ helpButton;
	Empire@ prevEmpire;

	Quickbar(IGuiElement@ parent) {
		super(parent, recti());

		@quickButton = GuiButton(this, recti(), "...");
		quickButton.noClip = true;

		@helpButton = GuiButton(this, recti());
		helpButton.setIcon(Sprite(spritesheet::MenuIcons, 3));
		helpButton.noClip = true;

		refresh();
	}

	void refresh() {
		@prevEmpire = playerEmpire;
		for(uint i = 0, cnt = modes.length; i < cnt; ++i)
			modes[i].remove();
		modes.length = 0;

		auto@ flingTrait = getTrait("Fling");
		auto@ scTrait = getTrait("StarChildren");
		auto@ anTrait = getTrait("Ancient");
		auto@ exTrait = getTrait("Extragalactic");

		add(CardMode(this), closed=true);
		if(exTrait !is null && playerEmpire.hasTrait(exTrait.id))
			add(Beacons(this));
		if(anTrait !is null && playerEmpire.hasTrait(anTrait.id))
			add(Replicators(this));
		else
			add(FreeResources(this));
		add(AutoImportMode(this));
		add(DisabledResources(this));
		if((scTrait is null || !playerEmpire.hasTrait(scTrait.id)) && (anTrait is null || !playerEmpire.hasTrait(anTrait.id)))
			add(OverPressurePlanets(this));
		add(NoPopResources(this), closed=true);
		add(DecayingPlanets(this));
		add(ColonizingPlanets(this));
		add(ColonizeSafePlanets(this), closed=true);
		add(SiegePlanets(this));
		add(LaborPlanets(this), closed=true);
		add(DefenseTargets(this), closed=true);
		add(FlingBeacons(this), closed=(flingTrait is null || !playerEmpire.hasTrait(flingTrait.id)));
		add(CombatFleets(this));
		add(LowSupplyFleets(this));
		add(AllFleets(this), closed=true);
		add(CivilianFleets(this), closed=true);
		if(playerEmpire.isUnlocked(subsystem::MothershipHull))
			add(Motherships(this));
		add(DefenseStations(this), closed=true);
		add(ArtifactMode(this));
		updateAbsolutePosition();
	}

	void save(SaveFile& file) {
		uint cnt = modes.length;
		file << cnt;
		for(uint i = 0; i < cnt; ++i) {
			file << getClass(modes[i]).name;
			file << modes[i].closed;
		}
	}

	void load(SaveFile& file) {
		uint cnt = 0;
		file >> cnt;
		for(uint i = 0; i < cnt; ++i) {
			string name;
			file >> name;
			bool closed = false;
			file >> closed;

			for(uint n = 0, ncnt = modes.length; n < ncnt; ++n) {
				if(getClass(modes[i]).name == name) {
					modes[i].closed = closed;
					break;
				}
			}
		}
	}

	bool get_isRoot() const override {
		return true;
	}

	void add(QuickbarMode@ mode, bool closed = false) {
		mode.closed = closed;
		modes.insertLast(mode);
	}

	void openMenu() {
		GuiContextMenu menu(mousePos);
		for(uint i = 0, cnt = modes.length; i < cnt; ++i) {
			auto@ mode = modes[i];

			auto@ option = QuickOption(this, i);
			option.text = mode.name;

			if(mode.closed)
				option.icon = Sprite(spritesheet::ContextIcons, 10);
			else
				option.icon = Sprite(spritesheet::ContextIcons, 1);

			menu.addOption(option);
		}
		menu.updateAbsolutePosition();
	}

	bool onGuiEvent(const GuiEvent& evt) override {
		if(evt.caller is quickButton && evt.type == GUI_Clicked) {
			openMenu();
			return true;
		}
		if(evt.caller is helpButton && evt.type == GUI_Clicked) {
			showHelp();
			return true;
		}
		return BaseGuiElement::onGuiEvent(evt);
	}

	void updateAbsolutePosition() override {
		if(size.width != QUICKBAR_WIDTH)
			size = vec2i(QUICKBAR_WIDTH, size.height);
		int height = 4;
		for(uint i = 0, cnt = modes.length; i < cnt; ++i) {
			auto@ mode = modes[i];
			bool visible = mode.show && !mode.closed;
			if(!visible) {
				if(mode.visible && !mode.removing) {
					mode.removing = true;
					mode.moveTo(vec2i(size.width, height));
				}
				continue;
			}
			else {
				if(!mode.visible)
					mode.position = vec2i(size.width, height);
				mode.visible = true;
			}
			mode.updateAbsolutePosition();
			if(mode.collapsed)
				mode.moveTo(vec2i(max(size.width - 32, size.width - mode.size.width), height));
			else
				mode.moveTo(vec2i(max(0, size.width - mode.size.width), height));
			height += mode.size.height + 4;
		}
		if(height != size.height)
			size = vec2i(QUICKBAR_WIDTH, height);
		position = vec2i(parent.size.width-size.width, 0);
		if(quickButton !is null) {
			quickButton.rect = recti_area(size.width-32,height, 32,32);
			if(height+32 > parent.size.height) {
				for(uint i = 0, cnt = modes.length; i < cnt; ++i) {
					if(!modes[i].closed && modes[i].show) {
						quickButton.rect = recti_area(modes[i].position - vec2i(36,0), vec2i(32,32));
						break;
					}
				}
			}
			if(helpButton !is null)
				helpButton.rect = quickButton.rect - vec2i(36, 0);
		}
		BaseGuiElement::updateAbsolutePosition();
	}

	void update(double time) {
		if(prevEmpire !is playerEmpire)
			refresh();
		helpButton.visible = HELP_TEXT.length != 0;
		bool changed = false;
		for(uint i = 0, cnt = modes.length; i < cnt; ++i) {
			auto@ mode = modes[i];
			if(mode.closed) {
				if(mode.visible && !mode.animating)
					changed = true;
				continue;
			}
			mode.update(time);

			if(mode.show != mode.visible)
				changed = true;
		}
		if(changed)
			updateAbsolutePosition();
	}
};

class QuickbarMode : BaseGuiElement {
	GuiSprite@ picture;
	Color color;
	bool closed = false;
	bool collapsed = false;
	bool removing = false;
	bool animating = false;

	QuickbarMode(IGuiElement@ parent) {
		super(parent, recti());
		visible = false;
		@picture = GuiSprite(this, Alignment(Left+2, Top+0.5f-18, Left+31, Top+0.5f+18), icon);
		setMarkupTooltip(picture, name, hoverStyle=false);
	}

	string get_name() {
		return "---";
	}

	Sprite get_icon() {
		return Sprite();
	}

	int get_needHeight() {
		return 32;
	}

	int get_maxHeight() {
		return 400;
	}

	int get_needWidth() {
		return 256;
	}

	bool get_show() {
		return true;
	}

	Color get_tabColor() {
		return Color();
	}

	void moveTo(const vec2i& pos) {
		if(rect == recti()) {
			rect = recti_area(pos, size);
		}
		else {
			animate_speed(this, recti_area(pos, size), ANIM_SPEED);
			animating = true;
		}
	}

	bool onMouseEvent(const MouseEvent& evt, IGuiElement@ caller) override {
		recti tabPos = recti_area(AbsolutePosition.topLeft, vec2i(32, size.height));
		if(tabPos.isWithin(mousePos)) {
			if(evt.type == MET_Button_Down && evt.button == 0) {
				return true;
			}
			else if(evt.type == MET_Button_Up && evt.button == 0) {
				collapsed = !collapsed;
				parent.updateAbsolutePosition();
				return true;
			}
			else if(evt.type == MET_Button_Down && evt.button == 1) {
				return true;
			}
			else if(evt.type == MET_Button_Up && evt.button == 1) {
				closed = true;
				parent.updateAbsolutePosition();
				return true;
			}
		}
		return BaseGuiElement::onMouseEvent(evt, caller);
	}

	bool onGuiEvent(const GuiEvent& evt) override {
		if(evt.type == GUI_Animation_Complete) {
			animating = false;
			if(removing) {
				visible = false;
				removing = false;
			}
			return true;
		}
		return BaseGuiElement::onGuiEvent(evt);
	}

	double timer = randomd(0.5, 1.0);
	void update(double time) {
		timer -= time;
		if(timer <= 0) {
			longUpdate();
			timer += randomd(0.5, 1.0);
		}

		shortUpdate();

		if(!animating) {
			if(min(needHeight, maxHeight) != size.height || min(needWidth, 256) != size.width)
				parent.updateAbsolutePosition();
		}
	}

	void shortUpdate() {}
	void longUpdate() {}

	void updateAbsolutePosition() override {
		if(parent !is null)
			size = vec2i(min(needWidth, parent.size.width), min(needHeight, maxHeight));
		BaseGuiElement::updateAbsolutePosition();
	}

	void draw() override {
		recti boxPos = recti_area(AbsolutePosition.topLeft, size+vec2i(8, 0));
		skin.draw(SS_Panel, SF_Normal, boxPos);
		skin.draw(SS_SmallHexPattern, SF_Normal, boxPos.padded(3, 3));

		recti tabPos = recti_area(AbsolutePosition.topLeft, vec2i(32, size.height));
		skin.draw(SS_FullTitle, SF_Normal, tabPos, tabColor);

		BaseGuiElement::draw();
	}
};

final class FleetData {
	double fleetStr = 0, fleetMaxStr = 0, nextStrUpdate = -1;
	double fleetSupply = 0, fleetMaxSupply = 0;
	int updateMax = 3;
};

//{{{ Object Modes
class ObjectGrid : GuiIconGrid {
	private array<Resource@> resources;
	private array<FleetData> fleetData;
	array<int> counts;
	bool showFleetSupply = false;
	bool showManage = false;
	string ttip;

	vec2i pressedPos;
	bool pressed = false;

	ObjectGrid(IGuiElement@ parent, Alignment@ align) {
		super(parent, align);
		iconSize = vec2i(46, 46);
		spacing.y = 0;
	}

	void activateTooltip(string text) {
		ttip = text;

		MarkupTooltip tt(400, 0.f, true, true);
		tt.Lazy = true;
		tt.LazyUpdate = false;
		tt.Padding = 4;
		@tooltipObject = tt;
	}

	string get_tooltip() override {
		if(hovered < 0 || hovered >= int(length))
			return "";
		auto@ obj = resources[hovered].origin;
		return format(ttip, obj.name);
	}

	uint get_length() override {
		return resources.length;
	}

	void setHovered(int prev, int current) {
		if(prev != hovered) {
			if(hovered == -1 || uint(hovered) >= resources.length)
				@uiObject = null;
			else
				@uiObject = resources[hovered].origin;
		}
	}

	void drawElement(uint index, const recti& pos) override {
		if(hovered == int(index) || resources[index].origin.selected)
			drawRectangle(pos.padded(2, 3), color=Color(0xffffff30));
		Object@ obj = resources[index].origin;
		if(obj !is null) {
			if(obj.isShip && obj.hasLeaderAI) {
				FleetData@ data = fleetData[index];
				if(gameTime >= data.nextStrUpdate) {
					if(data.nextStrUpdate >= 0) {
						if(data.updateMax <= 0) {
							data.fleetMaxStr = obj.getFleetMaxStrength();
							data.updateMax = 3;
						}
						else {
							data.fleetStr = obj.getFleetStrength();
							data.updateMax -= 1;
						}
						data.fleetSupply = cast<Ship>(obj).Supply;
						data.fleetMaxSupply = cast<Ship>(obj).MaxSupply;
					}
					else {
						data.fleetStr = obj.getFleetStrength();
						data.fleetMaxStr = obj.getFleetMaxStrength();
					}
					data.nextStrUpdate = gameTime + randomd(1.8,2.2);
				}
				
				if(!showFleetSupply)
					drawFleetIcon(cast<Ship>(obj), pos, data.fleetStr*0.001, data.fleetMaxStr*0.001);
				else
					drawFleetIcon(cast<Ship>(obj), pos, data.fleetSupply, data.fleetMaxSupply,
						Color(0x4a9487ff), Color(0x4a9487ff));
			}
			else {
				drawObjectIcon(obj, pos, resources[index]);
			}
			int count = counts[index];
			if(count != 1) {
				Colorf shifted;
				Empire@ owner = obj.owner;
				if(owner !is null)
					shifted = Colorf(owner.color);
				shifted.fromHSV((shifted.hue + 180.f)%360.f, shifted.saturation, shifted.value);
				skin.getFont(FT_Bold).draw(horizAlign=0.85, vertAlign=0.85, text=count,
						pos=pos, color=Color(shifted),
						stroke=colors::Black);
			}
		}
	}

	bool onGuiEvent(const GuiEvent& evt) override {
		if(evt.type == GUI_Clicked) {
			if(hovered == -1)
				return true;
			auto@ r = resources[hovered];
			if(evt.value == 0) {
				if(r.origin.selected || ctrlKey) {
					selectObject(r.origin);
					zoomTabTo(r.origin);
					if(showManage || ctrlKey)
						openOverlay(r.origin);
				}
				else
					selectObject(r.origin);
			}
			else if(evt.value == 1) {
				openContextMenu(r.origin);
			}
			else if(evt.value == 2) {
				zoomTabTo(r.origin);
			}
			return true;
		}
		return GuiIconGrid::onGuiEvent(evt);
	}

	bool onMouseEvent(const MouseEvent& evt, IGuiElement@ source) override {
		if(source is this) {
			if(evt.type != MET_Moved)
				updateHover();
			switch(evt.type) {
				case MET_Moved:
					if(hovered != -1 && uint(hovered) <= resources.length && pressed) {
						Object@ obj = resources[hovered].origin;
						if(evt.type == MET_Moved && pressedPos.distanceTo(mousePos) > 4 && mouseLeft) {
							if(obj !is null && obj.selected)
								doQuickExport(selectedObjects, true);
							else if(obj !is null && obj.hasResources && getResource(obj.primaryResourceType) !is null)
								doQuickExport(obj, true);
							pressed = false;
						}
					}
					updateHover();
				break;
				case MET_Button_Down:
					if(uint(hovered) < length && evt.button == 0) {
						pressed = true;
						pressedPos = mousePos;
					}
				break;
				case MET_Button_Up:
					if(evt.button == 0)
						pressed = false;
				break;
			}
		}
		return GuiIconGrid::onMouseEvent(evt, source);
	}

	void add(Object@ obj) {
		set(resources.length, obj);
	}

	void set(uint index, Object@ obj) {
		if(index >= resources.length) {
			resources.insertLast(Resource());
			counts.insertLast(1);
			fleetData.length = fleetData.length + 1;
		}
		counts[index] = 1;

		if(!obj.hasResources || !receive(obj.getNativeResources(), resources[index])) {
			@resources[index].type = null;
			@resources[index].origin = obj;
		}
	}

	void set(uint index, ObjectData@ dat) {
		if(index >= resources.length) {
			resources.insertLast(dat.resource);
			counts.insertLast(1);
			fleetData.length = fleetData.length + 1;
		}
			
		@resources[index] = dat.resource;
		@resources[index].origin = dat.obj;
		fleetData[index] = FleetData();
		counts[index] = 1;
	}

	void truncate(uint index, bool sort = true) {
		if(resources.length > index) {
			resources.length = index;
			fleetData.length = index;
			counts.length = index;
		}
		if(sort)
			resources.sortDesc();
		updateHover();
	}
};

class ObjectMode : QuickbarMode {
	ObjectGrid@ grid;

	ObjectMode(IGuiElement@ parent) {
		super(parent);
		@grid = ObjectGrid(this, Alignment(Left+32, Top, Right, Bottom-4));
		grid.horizAlign = 1.0;
	}

	bool get_show() override {
		return grid.length != 0;
	}

	int get_needHeight() override {
		int perRow = size.width / 40;
		if(perRow == 0)
			return 20;
		return max(ceil(double(grid.length) / double(perRow)), 1.0) * 49;
	}

	int get_needWidth() override {
		return grid.length * 50 + 40;
	}

	bool filter(ObjectData@ obj) {
		return true;
	}

	void longUpdate() override {
		uint index = 0;
		for(uint i = 0, cnt = empirePlanets.length; i < cnt; ++i) {
			if(!filter(empirePlanets[i]))
				continue;
			grid.set(index, empirePlanets[i]);
			++index;
		}
		grid.truncate(index);
	}
};

bool sentFreePlanetsWarning = false;
int freeWarningDelay = 180;

class FreeResources : ObjectMode {
	FreeResources(IGuiElement@ parent) {
		super(parent);
		color = Color(0x00fa99ff);
	}

	string get_name() override {
		return locale::FREE_RESOURCES;
	}

	Sprite get_icon() override {
		return Sprite(spritesheet::QuickbarIcons, 2);
	}

	void longUpdate() override {
		uint unusedPlanets = 0;
	
		array<uint> types(getResourceCount(), UINT_MAX);
	
		uint index = 0;
		for(uint i = 0, cnt = empirePlanets.length; i < cnt; ++i) {
			auto@ dat = empirePlanets[i];
			if(!filter(dat))
				continue;
			if(dat.obj.level == 0)
				++unusedPlanets;
			if(dat.resource.type !is null) {
				uint tID = dat.resource.type.id;
				if(types[tID] != UINT_MAX) {
					grid.counts[types[tID]]++;
					continue;
				}
				types[tID] = index;
			}
			grid.set(index, dat);
			++index;
		}
		
		if(!sentFreePlanetsWarning) {
			if(unusedPlanets >= 5 && playerEmpire.TotalBudget < playerEmpire.MaintenanceBudget) {
				if(--freeWarningDelay == 0) {
					auto@ msg = message(locale::HINT_USE_PLANETS);
					msg.addTitle(locale::HINT_USE_PLANETS_TITLE);
					sentFreePlanetsWarning = true;
				}
			}
			else {
				freeWarningDelay = 180;
			}
		}

		array<Asteroid@> list;
		DataList@ objs = playerEmpire.getAsteroids();
		Object@ obj;
		while(receive(objs, obj)) {
			Asteroid@ asteroid = cast<Asteroid>(obj);
			if(asteroid !is null && asteroid.nativeResourceCount != 0)
				list.insertLast(asteroid);
		}
		
		for(uint i = 0, cnt = list.length; i < cnt; ++i) {
			auto@ dat = cache(list[i]);
			if(!filter(dat))
				continue;
			grid.set(index, dat);
			++index;
		}
		
		grid.truncate(index, sort=false);
	}

	bool filter(ObjectData@ dat) {
		Object@ obj = dat.obj;
		auto@ type = dat.resource.type;
		if(type is null)
			return false;
		Object@ dest = dat.destination;
		if(dest !is null) {
			Empire@ destOwner = dest.owner;
			if(destOwner is playerEmpire || destOwner is null || !destOwner.valid)
				return false;
		}
		if(!dat.resource.usable)
			return false;
		if(obj.isPlanet) {
			if(type.isMaterial(obj.level))
				return false;
			if(obj.decayTime > 0)
				return false;
			if(obj.resourceLevel > obj.level)
				return false;
			if(!obj.exportEnabled)
				return false;
		}
		if(!type.exportable || type.mode == RM_NonRequirement)
			return false;
		return true;
	}
};

class DisabledResources : ObjectMode {
	DisabledResources(IGuiElement@ parent) {
		super(parent);
		color = Color(0xfa0099ff);
	}

	Sprite get_icon() override {
		return Sprite(spritesheet::QuickbarIcons, 3);
	}

	bool filter(ObjectData@ dat) {
		auto@ type = dat.resource.type;
		if(type is null)
			return false;
		if(!dat.resource.usable) {
			double pop = dat.obj.population;
			if(!dat.obj.inCombat && pop < getPlanetLevelRequiredPop(dat.obj, dat.obj.resourceLevel))
				return false;
			if(dat.obj.population < 1.0)
				return false;
			return true;
		}
		return false;
	}

	string get_name() override {
		return locale::DISABLED_RESOURCES;
	}
};

class OverPressurePlanets : ObjectMode {
	OverPressurePlanets(IGuiElement@ parent) {
		super(parent);
		color = Color(0xfa0099ff);
	}

	Sprite get_icon() override {
		return icons::Pressure;
	}

	bool filter(ObjectData@ dat) {
		if(!dat.obj.isPlanet)
			return false;
		if(dat.obj.level == 0)
			return false;
		return dat.obj.isOverPressure;
	}

	string get_name() override {
		return locale::OVERPRESSURE_PLANETS;
	}
};

class Replicators : ObjectMode {
	uint statusId = uint(-1);
	uint orbId = uint(-1);

	Replicators(IGuiElement@ parent) {
		super(parent);

		auto@ status = getStatusType("AncientReplicator");
		if(status !is null)
			statusId = status.id;

		orbId = getOrbitalModuleID("AncientReplicator");
	}

	Sprite get_icon() override {
		return spritesheet::GuiOrbitalIcons+20;
	}

	bool filter(ObjectData@ dat) {
		if(!dat.obj.isPlanet)
			return false;
		return dat.obj.hasStatusEffect(statusId);
	}

	string get_name() override {
		return locale::REPLICATORS;
	}

	void longUpdate() override {
		uint index = 0;
		for(uint i = 0, cnt = empirePlanets.length; i < cnt; ++i) {
			if(!filter(empirePlanets[i]))
				continue;
			grid.set(index, empirePlanets[i]);
			++index;
		}

		DataList@ objs = playerEmpire.getOrbitals();
		Object@ obj;
		while(receive(objs, obj)) {
			Orbital@ orb = cast<Orbital>(obj);
			if(orb !is null && uint(orb.coreModule) == orbId) {
				if(!orb.inOrbit && !orb.hasLockedOrbit()) {
					auto@ dat = cache(orb);
					grid.set(index, dat);
					++index;
				}
			}
		}
		grid.truncate(index);
	}
};

class NoPopResources : ObjectMode {
	NoPopResources(IGuiElement@ parent) {
		super(parent);
		color = Color(0xfa0099ff);
	}

	Sprite get_icon() override {
		return Sprite(spritesheet::QuickbarIcons, 3, colors::Green);
	}

	bool filter(ObjectData@ dat) {
		auto@ type = dat.resource.type;
		if(type is null)
			return false;
		if(!dat.resource.usable) {
			if(dat.obj.population >= getPlanetLevelRequiredPop(dat.obj, dat.obj.resourceLevel))
				return false;
			if(dat.obj.inCombat)
				return false;
			return true;
		}
		return false;
	}

	string get_name() override {
		return locale::NO_POP_RESOURCES;
	}
};

class DecayingPlanets : ObjectMode {
	DecayingPlanets(IGuiElement@ parent) {
		super(parent);
		color = Color(0xfaf099ff);
	}

	bool filter(ObjectData@ dat) {
		if(dat.obj.decayTime > 0)
			return true;
		return false;
	}

	Sprite get_icon() override {
		return Sprite(spritesheet::QuickbarIcons, 4);
	}

	string get_name() override {
		return locale::DECAYING_PLANETS;
	}
};

bool shownColonizeWarning = false;
uint colonizeWarningDelay = 100;

class ColonizingPlanets : ObjectMode {
	ColonizingPlanets(IGuiElement@ parent) {
		super(parent);
		color = Color(0x8060ffff);
	}

	bool filter(ObjectData@ dat) {
		if(dat.obj.population < 1.0 || dat.obj.isBeingColonized)
			return true;
		return false;
	}

	Sprite get_icon() override {
		return Sprite(spritesheet::QuickbarIcons, 5);
	}

	string get_name() override {
		return locale::COLONIZING_PLANETS;
	}

	void longUpdate() override {
		uint index = 0;
		for(uint i = 0, cnt = empirePlanets.length; i < cnt; ++i) {
			if(!filter(empirePlanets[i]))
				continue;
			grid.set(index, empirePlanets[i]);
			++index;
		}
		
		if(!shownColonizeWarning) {
			int colonyCost = -playerEmpire.getMoneyFromType(0);
			int budget = playerEmpire.TotalBudget;
			int netBudget = budget - playerEmpire.MaintenanceBudget;
			
			if(netBudget < 0 && colonyCost > 200 && colonyCost > budget/6) {
				if(--colonizeWarningDelay == 0) {
					auto@ msg = message(locale::HINT_COLONIZE);
					msg.addTitle(locale::HINT_COLONIZE_TITLE);
					shownColonizeWarning = true;
				}
			}
			else {
				colonizeWarningDelay = 100;
			}
		}
		
		set_int listed;
		array<Planet@> list;
		DataList@ objs = playerEmpire.getQueuedColonizations();
		Object@ obj;
		while(receive(objs, obj)) {
			Planet@ pl = cast<Planet>(obj);
			if(pl !is null && !listed.contains(pl.id)) {
				listed.insert(pl.id);
				list.insertLast(pl);
			}
		}

		for(uint i = 0, cnt = list.length; i < cnt; ++i) {
			auto@ dat = cache(list[i]);
			if(!filter(dat))
				continue;
			grid.set(index, dat);
			++index;
		}
		grid.truncate(index, sort=false);
	}
};

class ColonizeSafePlanets : ObjectMode {
	ColonizeSafePlanets(IGuiElement@ parent) {
		super(parent);
	}

	bool filter(ObjectData@ dat) {
		return dat.obj.canSafelyColonize;
	}

	Sprite get_icon() override {
		return Sprite(spritesheet::QuickbarIcons, 5, Color(0x00ff00ff));
	}

	string get_name() override {
		return locale::COLONIZE_SAFE_PLANETS;
	}
};

class LaborPlanets : ObjectMode {
	LaborPlanets(IGuiElement@ parent) {
		super(parent);
		color = Color(0x606080ff);
		grid.showManage = true;
	}

	bool filter(ObjectData@ dat) {
		if(dat.obj.getResourceProduction(TR_Labor) > 0)
			return true;
		return false;
	}

	Sprite get_icon() override {
		return Sprite(spritesheet::QuickbarIcons, 1);
	}

	string get_name() override {
		return locale::LABOR_PLANETS;
	}

	void longUpdate() override {
		uint index = 0;
		for(uint i = 0, cnt = empirePlanets.length; i < cnt; ++i) {
			if(!filter(empirePlanets[i]))
				continue;
			grid.set(index, empirePlanets[i]);
			++index;
		}

		DataList@ objs = playerEmpire.getOrbitals();
		Object@ obj;
		while(receive(objs, obj)) {
			Orbital@ orb = cast<Orbital>(obj);
			if(orb !is null && orb.hasConstruction) {
				auto@ dat = cache(orb);
				grid.set(index, dat);
				++index;
			}
		}
		grid.truncate(index);
	}
};

class DefenseTargets : ObjectMode {
	DefenseTargets(IGuiElement@ parent) {
		super(parent);
		color = Color(0x606080ff);

		grid.activateTooltip(format("[font=Medium]$1[/font]\n$2",
				"$1", locale::TT_IS_DEFENDING));
	}

	Sprite get_icon() override {
		return Sprite(spritesheet::QuickbarIcons, 8);
	}

	string get_name() override {
		return locale::DEFENSE_TARGETS;
	}

	void longUpdate() override {
		DataList@ objs = playerEmpire.getDefending();
		Object@ obj;
		uint index = 0;
		while(receive(objs, obj)) {
			if(obj !is null) {
				auto@ dat = cache(obj);
				grid.set(index, dat);
				++index;
			}
		}
		grid.truncate(index);
	}
};

class SiegePlanets : ObjectMode {
	SiegePlanets(IGuiElement@ parent) {
		super(parent);
		color = Color(0xfaf099ff);
	}

	bool filter(ObjectData@ dat) {
		Empire@ captEmp = dat.obj.captureEmpire;
		if(captEmp is null || captEmp is playerEmpire)
			return false;
		return true;
	}

	Sprite get_icon() override {
		return Sprite(spritesheet::QuickbarIcons, 7);
	}

	Color get_tabColor() override {
		return Color(0xff0000ff);
	}

	string get_name() override {
		return locale::UNDER_SIEGE_PLANETS;
	}
};

class FlingBeacons : ObjectMode {
	FlingBeacons(IGuiElement@ parent) {
		super(parent);
	}

	Sprite get_icon() override {
		return Sprite(spritesheet::GuiOrbitalIcons, 0);
	}

	string get_name() override {
		return locale::FLING_BEACONS;
	}

	void longUpdate() override {
		DataList@ objs = playerEmpire.getFlingBeacons();
		Object@ obj;
		uint index = 0;
		while(receive(objs, obj)) {
			Orbital@ beacon = cast<Orbital>(obj);
			if(beacon !is null) {
				auto@ dat = cache(beacon);
				grid.set(index, dat);
				++index;
			}
		}
		grid.truncate(index);
	}
};

class Beacons : ObjectMode {
	Beacons(IGuiElement@ parent) {
		super(parent);
	}

	Sprite get_icon() override {
		return Sprite(spritesheet::GuiOrbitalIcons, 0);
	}

	string get_name() override {
		return locale::ORB_BEACON;
	}

	void longUpdate() override {
		auto@ core = getOrbitalModule("Beacon");
		uint index = 0;
		DataList@ objs = playerEmpire.getOrbitals();
		Object@ obj;
		while(receive(objs, obj)) {
			Orbital@ orb = cast<Orbital>(obj);
			if(orb !is null && core !is null && orb.coreModule == core.id) {
				auto@ dat = cache(orb);
				grid.set(index, dat);
				++index;
			}
		}
		grid.truncate(index);
	}
};

class AllFleets : ObjectMode {
	AllFleets(IGuiElement@ parent) {
		super(parent);
	}

	Sprite get_icon() override {
		return Sprite(spritesheet::ShipIcons, 0);
	}

	string get_name() override {
		return locale::ALL_FLEETS;
	}

	void longUpdate() override {
		DataList@ objs = playerEmpire.getFlagships();
		Object@ obj;
		uint index = 0;
		while(receive(objs, obj)) {
			Ship@ ship = cast<Ship>(obj);
			if(ship !is null && !ship.blueprint.design.hasTag(ST_Mothership)) {
				if(ship.getFleetMaxStrength() < 1000.0)
					continue;
				grid.set(index, ship);
				++index;
			}
		}
		grid.truncate(index);
	}
};

class CivilianFleets : ObjectMode {
	CivilianFleets(IGuiElement@ parent) {
		super(parent);
	}

	Sprite get_icon() override {
		return Sprite(spritesheet::ShipIcons, 0);
	}

	string get_name() override {
		return locale::CIVILIAN_FLEETS;
	}

	void longUpdate() override {
		DataList@ objs = playerEmpire.getFlagships();
		Object@ obj;
		uint index = 0;
		while(receive(objs, obj)) {
			Ship@ ship = cast<Ship>(obj);
			if(ship !is null && !ship.blueprint.design.hasTag(ST_Mothership)) {
				if(ship.getFleetMaxStrength() > 1000.0)
					continue;
				grid.set(index, ship);
				++index;
			}
		}
		grid.truncate(index);
	}
};

class Motherships : ObjectMode {
	Motherships(IGuiElement@ parent) {
		super(parent);
	}

	Sprite get_icon() override {
		return Sprite(spritesheet::ShipIcons, 0);
	}

	string get_name() override {
		return locale::MOTHERSHIPS;
	}

	void longUpdate() override {
		DataList@ objs = playerEmpire.getFlagships();
		Object@ obj;
		uint index = 0;
		while(receive(objs, obj)) {
			Ship@ ship = cast<Ship>(obj);
			if(ship !is null && ship.blueprint.design.hasTag(ST_Mothership)) {
				grid.set(index, ship);
				++index;
			}
		}
		grid.truncate(index);
	}
};

class DefenseStations : ObjectMode {
	DefenseStations(IGuiElement@ parent) {
		super(parent);
	}

	Sprite get_icon() override {
		return Sprite(spritesheet::GuiOrbitalIcons, 0);
	}

	string get_name() override {
		return locale::DEFENSE_STATIONS;
	}

	void longUpdate() override {
		DataList@ objs = playerEmpire.getStations();
		Object@ obj;
		uint index = 0;
		while(receive(objs, obj)) {
			Ship@ ship = cast<Ship>(obj);
			if(ship !is null) {
				grid.set(index, ship);
				++index;
			}
		}
		grid.truncate(index);
	}
};

class LowSupplyFleets : ObjectMode {
	LowSupplyFleets(IGuiElement@ parent) {
		super(parent);
		grid.showFleetSupply = true;
	}

	Sprite get_icon() override {
		return icons::Supply;
	}

	string get_name() override {
		return locale::FLEETS_LOW_SUPPLY;
	}

	void longUpdate() override {
		DataList@ objs = playerEmpire.getFlagships();
		Object@ obj;
		uint index = 0;
		while(receive(objs, obj)) {
			Ship@ ship = cast<Ship>(obj);
			if(ship !is null && ship.Supply < ship.MaxSupply * 0.5) {
				grid.set(index, ship);
				++index;
			}
		}
		grid.truncate(index);
	}
};

class CombatFleets : ObjectMode {
	CombatFleets(IGuiElement@ parent) {
		super(parent);
	}

	Sprite get_icon() override {
		return Sprite(spritesheet::ShipIcons, 0);
	}

	Color get_tabColor() override {
		return Color(0xff0000ff);
	}

	string get_name() override {
		return locale::COMBAT_FLEETS;
	}

	void longUpdate() override {
		DataList@ objs = playerEmpire.getFlagships();
		Object@ obj;
		uint index = 0;
		while(receive(objs, obj)) {
			Ship@ ship = cast<Ship>(obj);
			if(ship !is null && ship.inCombat) {
				grid.set(index, ship);
				++index;
			}
		}
		grid.truncate(index);
	}
};

class ObjectData {
	Object@ obj;
	int resMod;
	Resource resource;
	Object@ destination;
};

double timer = randomd(0.5, 2.0);
dictionary objCache;
array<ObjectData@> empirePlanets;

void update(ObjectData@ dat) {
	if(dat.obj.hasResources) {
		receive(dat.obj.getNativeResources(), dat.resource);
		@dat.destination = dat.obj.nativeResourceDestination[0];
	}
}

ObjectData@ cache(Object@ obj) {
	ObjectData@ dat;
	if(objCache.get(obj.id, @dat)) {
		int newMod = obj.hasResources ? obj.resourceModID : 0;
		if(newMod != dat.resMod) {
			dat.resMod = newMod;
			update(dat);
		}
		return dat;
	}

	@dat = ObjectData();
	@dat.obj = obj;
	dat.resMod = obj.hasResources ? obj.resourceModID : 0;
	objCache.set(obj.id, @dat);
	update(dat);
	return dat;
}

void tick(double time) {
	timer -= time;
	if(timer <= 0) {
		empirePlanets.length = 0;
		DataList@ objs = playerEmpire.getPlanets();
		Object@ obj;
		while(receive(objs, obj)) {
			Planet@ pl = cast<Planet>(obj);
			if(pl !is null)
				empirePlanets.insertLast(cache(pl));
		}

		timer += randomd(0.5, 2.0);
	}
}
//}}}
//{{{ Influence Mode
const int CARD_W = 55;
const int CARD_H = 36;

class CardGrid : GuiIconGrid {
	array<StackInfluenceCard@> cards;

	CardGrid(IGuiElement@ parent, Alignment@ align) {
		super(parent, align);
		iconSize = vec2i(CARD_W, CARD_H);
		spacing.y = 0;

		MarkupTooltip tt(400, 0.f, true, true);
		tt.Lazy = true;
		tt.LazyUpdate = false;
		tt.Padding = 4;
		@tooltipObject = tt;
	}

	uint get_length() override {
		return cards.length;
	}

	string get_tooltip() override {
		if(hovered < 0 || hovered >= int(length))
			return "";
		return cards[hovered].formatTooltip(playerEmpire);
	}

	void drawElement(uint index, const recti& pos) override {
		if(hovered == int(index))
			drawRectangle(pos.padded(2, 2), color=Color(0xffffff30));
		auto@ card  = cards[index];

		Color col;
		if(card.purchasedBy !is null)
			col = card.purchasedBy.color;
		skin.draw(SS_LightPanel, SF_Normal, pos.padded(3, 3), col);

		drawCardIcon(card, pos);
	}

	IGuiElement@ findTab() {
		IGuiElement@ elem = parent;
		while(elem !is null && cast<Tab>(elem) is null)
			@elem = elem.parent;
		return elem;
	}

	bool onGuiEvent(const GuiEvent& evt) override {
		if(evt.type == GUI_Clicked) {
			if(hovered == -1)
				return true;
			if(ctrlKey) {
				sound::card_draw.play(priority=true);
				buyCardFromInfluenceStack(cards[hovered].id);
				emitConfirmed();
			}
			else {
				sound::card_examine.play(priority=true);
				StackInfluenceCard card = cards[hovered];
				GuiInfluenceCardPopup(findTab(), parent, card);
			}
			return true;
		}
		return GuiIconGrid::onGuiEvent(evt);
	}

	void add(StackInfluenceCard@ card) {
		set(cards.length, card);
	}

	void set(uint index, StackInfluenceCard@ card) {
		if(index >= cards.length)
			cards.insertLast(card);
		else
			@cards[index] = card;
	}

	void truncate(uint index) {
		if(cards.length > index)
			cards.length = index;
		updateHover();
	}
};

class CardMode : QuickbarMode {
	CardGrid@ grid;
	array<StackInfluenceCard> cards;
	double stackTimer = 0.0;

	CardMode(IGuiElement@ parent) {
		super(parent);
		@grid = CardGrid(this, Alignment(Left+36, Top+1, Right-4, Bottom-4));
		color = Color(0x20adffff);
	}

	bool get_show() override {
		return grid.length != 0;
	}

	Sprite get_icon() override {
		return Sprite(spritesheet::QuickbarIcons, 0);
	}

	string get_name() override {
		return locale::INFLUENCE_STACK;
	}

	int get_needHeight() {
		int perRow = size.width / (CARD_W + 4);
		if(perRow == 0)
			return CARD_H + 4;
		return max(ceil(double(grid.length) / double(perRow)), 1.0) * (CARD_H + 4);
	}

	int get_needWidth() {
		return min(grid.length, 3) * (CARD_W + 4) + 40;
	}

	void shortUpdate() {
		QuickbarMode::shortUpdate();

		double prevTimer = stackTimer;
		stackTimer = getInfluenceDrawTimer();
		if(prevTimer < stackTimer)
			longUpdate();
	}

	void longUpdate() {
		cards.syncFrom(getInfluenceCardStack());
		uint i = 0;
		for(uint cnt = cards.length; i < cnt; ++i)
			grid.set(i, cards[i]);
		grid.truncate(i);
	}

	bool onGuiEvent(const GuiEvent& evt) override {
		if(evt.type == GUI_Confirmed) {
			longUpdate();
			timer = 0.15;
			return true;
		}
		return QuickbarMode::onGuiEvent(evt);
	}

	void draw() override {
		QuickbarMode::draw();

		string timeText = formatEstTime(stackTimer);
		const Font@ ft = skin.getFont(FT_Small);
		ft.draw(pos=picture.absolutePosition.padded(0, 3), text=timeText, horizAlign=0.5, vertAlign=1.0);
	}
};
//}}}
//{{{ Auto Imports Mode
class AutoImportGrid : GuiIconGrid {
	array<AutoImportDesc> list;
	array<uint> counts;

	AutoImportGrid(IGuiElement@ parent, Alignment@ align) {
		super(parent, align);
		iconSize = vec2i(36, 36);
		spacing.y = 0;

		MarkupTooltip tt(400, 0.f, true, true);
		tt.Lazy = true;
		tt.LazyUpdate = false;
		tt.Padding = 4;
		@tooltipObject = tt;
	}

	string get_tooltip() override {
		if(hovered < 0 || hovered >= int(length))
			return "";
		auto@ desc = list[hovered];
		string type;
		if(desc.type !is null)
			type = desc.type.name;
		else if(desc.cls !is null)
			type = desc.cls.name;
		else if(desc.level != -1)
			type = locale::LEVEL+" "+desc.level;
		return format(locale::TT_AUTO_IMPORTS, toString(counts[hovered]), type,
				getSpriteDesc(getAutoImportIcon(desc)));
	}

	uint get_length() override {
		return list.length;
	}

	void drawElement(uint index, const recti& pos) override {
		auto@ desc = list[index];
		getAutoImportIcon(desc).draw(pos.padded(4));

		uint count = counts[index];
		if(count > 1) {
			skin.getFont(FT_Bold).draw(horizAlign=0.85, vertAlign=0.85, text=count,
					pos=pos, color=Color(0xf268ffff),
					stroke=colors::Black);
		}
	}

	void add(AutoImportDesc@ desc, uint& index) {
		for(uint i = 0; i < index; ++i) {
			if(list[i].equivalent(desc)) {
				counts[i] += 1;
				return;
			}
		}
		set(index, desc);
		index += 1;
	}

	void set(uint index, AutoImportDesc@ desc) {
		if(index >= list.length) {
			list.insertLast(desc);
			counts.insertLast(1);
		}
		else {
			list[index] = desc;
			counts[index] = 1;
		}
	}

	void truncate(uint index) {
		if(list.length > index) {
			list.length = index;
			counts.length = index;
		}
		updateHover();
	}
};

class AutoImportMode : QuickbarMode {
	AutoImportGrid@ grid;

	AutoImportMode(IGuiElement@ parent) {
		super(parent);
		@grid = AutoImportGrid(this, Alignment(Left+36, Top+1, Right-4, Bottom-4));
	}

	bool get_show() override {
		return grid.length != 0;
	}

	Sprite get_icon() override {
		return Sprite(spritesheet::ContextIcons, 0);
	}

	string get_name() override {
		return locale::AUTO_IMPORTS;
	}

	int get_needHeight() override {
		int perRow = size.width / 30;
		if(perRow == 0)
			return 20;
		return max(ceil(double(grid.length) / double(perRow)), 1.0) * 39;
	}

	int get_needWidth() override {
		return grid.length * 40 + 30;
	}

	AutoImportDesc desc;
	void longUpdate() {
		DataList@ list = playerEmpire.getAutoImports();
		uint index = 0;
		while(receive(list, desc))
			grid.add(desc, index);
		grid.truncate(index);
	}

	bool onGuiEvent(const GuiEvent& evt) override {
		if(evt.type == GUI_Confirmed) {
			longUpdate();
			timer = 0.15;
			return true;
		}
		return QuickbarMode::onGuiEvent(evt);
	}
};
//}}}
//{{{ Artifact Mode
const int ARTIF_W = 45;
const int ARTIF_H = 36;
dictionary ablCache;

class ArtifDesc {
	Artifact@ artif;
	uint count = 1;
	const ArtifactType@ type;
	Ability@ ability;

	ArtifDesc(Artifact@ obj) {
		set(obj);
	}

	ArtifDesc() {
	}

	void set(Artifact@ obj) {
		@artif = obj;
		@type = getArtifactType(obj.ArtifactType);
		if(!ablCache.get(obj.id, @ability)) {
			@ability = Ability();
			receive(obj.getAbilities(), ability);
			@ability.emp = playerEmpire;
			ablCache.set(obj.id, @ability);
		}
		count = 1;
	}

	int opCmp(const ArtifDesc@ other) const {
		if(ability.type is null)
			return -1;
		if(other.ability.type is null)
			return 1;

		double myCost = ability.getEnergyCost();
		double theirCost = other.ability.getEnergyCost();
		if(myCost > theirCost)
			return 1;
		if(theirCost > myCost)
			return -1;
		return 0;
	}
};

class ArtifGrid : GuiIconGrid {
	array<ArtifDesc@> list;

	ArtifGrid(IGuiElement@ parent, Alignment@ align) {
		super(parent, align);
		iconSize = vec2i(ARTIF_W, ARTIF_H);
		spacing.y = 0;

		MarkupTooltip tt(400, 0.f, true, true);
		tt.Lazy = true;
		tt.LazyUpdate = false;
		tt.Padding = 4;
		@tooltipObject = tt;
	}

	uint get_length() override {
		return list.length;
	}

	string get_tooltip() override {
		if(hovered < 0 || hovered >= int(length))
			return "";
		auto@ desc = list[hovered];
		if(desc.ability.type is null)
			return "";
		string tt = format("[font=Medium][b]$1[/b][/font] [img=$2;24/]\n",
				desc.type.name, getSpriteDesc(desc.type.icon));
		tt += desc.ability.formatTooltip(playerEmpire);
		return tt;
	}

	void drawElement(uint index, const recti& pos) override {
		auto@ desc = list[index];
		Color col(0xffffffff);
		if(desc.ability !is null && desc.ability.type !is null) {
			auto@ abl = desc.ability;
			if(abl.cooldown > 0 || abl.getEnergyCost() > playerEmpire.EnergyStored)
				col = Color(0xff0000ff);
		}

		if(hovered == int(index))
			drawRectangle(pos, Color(0xffffff30));
		skin.draw(SS_LightPanel, SF_Normal, pos.padded(3, 3), col);

		desc.type.icon.draw(recti_area(pos.topLeft + vec2i(5, 5), vec2i(ARTIF_H - 14, ARTIF_H - 14)));
		if(desc.ability !is null && desc.ability.type !is null) {
			auto@ abl = desc.ability;
			abl.type.icon.draw(recti_area(pos.topLeft + vec2i(ARTIF_W - ARTIF_H + 9, 9), vec2i(ARTIF_H - 14, ARTIF_H - 14)));

		}

		//Draw amount
		if(desc.count > 1) {
			int x = pos.size.x - 9;
			if(desc.count > 5) {
				font::DroidSans_11_Bold.draw(
					pos=recti_area(vec2i(pos.topLeft.x + x - 30, pos.topLeft.y + 4), vec2i(35, 10)),
					text=toString(desc.count),
					color=Color(0xe32020ff),
					horizAlign=1.0);
			}
			else {
				for(uint i = 0; i < desc.count; ++i) {
					drawRectangle(recti_area(vec2i(pos.topLeft.x+x, pos.topLeft.y+4), vec2i(5, 5)), Color(0x991c1cff));
					x -= 8;
				}
			}
		}
	}

	void activate(ArtifDesc@ desc) {
		if(desc.ability is null && desc.ability.type !is null)
			return;
		Ability abl = desc.ability;
		if(abl.cooldown > 0 || abl.getEnergyCost() > playerEmpire.EnergyStored) {
			zoomTabTo(desc.artif);
			selectObject(desc.artif);
			return;
		}
		@abl.emp = playerEmpire;
		if(abl.type.targets.length == 0 || desc.artif.abilityCount > 1) {
			zoomTabTo(desc.artif);
			selectObject(desc.artif);
		}
		else if(abl.type.targets[0].type == TT_Point) {
			targetPoint(AbilityTargetPoint(abl));
		}
		else if(abl.type.targets[0].type == TT_Object) {
			targetObject(AbilityTargetObject(abl));
		}
	}

	bool onGuiEvent(const GuiEvent& evt) override {
		if(evt.type == GUI_Clicked) {
			if(hovered == -1)
				return true;
			auto@ desc = list[hovered];
			if(evt.value == 0)
				activate(desc);
			else if(evt.value == 2)
				zoomTabTo(desc.artif);
			return true;
		}
		return GuiIconGrid::onGuiEvent(evt);
	}

	void add(Artifact@ obj, uint& index) {
		auto@ type = getArtifactType(obj.ArtifactType);
		if(type.collapses) {
			for(uint i = 0, cnt = min(list.length, index); i < cnt; ++i) {
				if(list[i].type is type) {
					list[i].count += 1;
					return;
				}
			}
		}
		set(index, obj);
		index += 1;
	}

	void set(uint index, Artifact@ obj) {
		if(index >= list.length)
			list.insertLast(ArtifDesc(obj));
		else
			list[index].set(obj);
	}

	void truncate(uint index) {
		if(list.length > index)
			list.length = index;
		list.sortDesc();
		updateHover();
	}
};

class ArtifactMode : QuickbarMode {
	ArtifGrid@ grid;

	ArtifactMode(IGuiElement@ parent) {
		super(parent);
		@grid = ArtifGrid(this, Alignment(Left+36, Top+1, Right-4, Bottom-4));
		@picture.alignment = Alignment(Left+1, Top+0.5f-15, Left+31, Top+0.5f+15);
	}

	bool get_show() override {
		return grid.length != 0;
	}

	Sprite get_icon() override {
		return Sprite(spritesheet::ArtifactIcon, 0);
	}

	string get_name() override {
		return locale::AVAIL_ARTIFACTS;
	}

	int get_needHeight() {
		int perRow = size.width / (ARTIF_W + 4);
		if(perRow == 0)
			return ARTIF_H + 4;
		return max(ceil(double(grid.length) / double(perRow)), 1.0) * (ARTIF_H + 4);
	}

	int get_needWidth() {
		return min(grid.length, 4) * (ARTIF_W + 4) + 40;
	}

	void longUpdate() {
		DataList@ objs = playerEmpire.getArtifacts();
		Object@ obj;
		uint index = 0;
		while(receive(objs, obj)) {
			Artifact@ artif = cast<Artifact>(obj);
			if(artif !is null)
				grid.add(artif, index);
		}
		grid.truncate(index);
	}

	bool onGuiEvent(const GuiEvent& evt) override {
		if(evt.type == GUI_Confirmed) {
			longUpdate();
			timer = 0.15;
			return true;
		}
		return QuickbarMode::onGuiEvent(evt);
	}
};
//}}}
// {{{ Game help popup
class HelpOverlay : GuiOverlay {
	GuiSkinElement@ bg;
	GuiPanel@ panel;
	GuiMarkupText@ page;

	GuiButton@ okButton;
	double prevGameSpeed = -1.0;

	HelpOverlay() {
		super(null);
		closeSelf = false;

		@bg = GuiSkinElement(this, Alignment(Left+0.2f, Top+0.1f, Right-0.2f, Bottom-0.1f), SS_PlainOverlay);
		@panel = GuiPanel(bg, Alignment(Left, Top+2, Right-2, Bottom-60));
		updateAbsolutePosition();

		@page = GuiMarkupText(panel, recti_area(8, 2, panel.size.width-25, 100));
		page.text = HELP_TEXT;

		@okButton = GuiButton(bg, Alignment(Left+0.5f-100, Bottom-56, Left+0.5f+100, Bottom-4), locale::GOT_IT);

		updateAbsolutePosition();
	}

	void close() {
		if(prevGameSpeed >= 0) {
			gameSpeed = prevGameSpeed;
			prevGameSpeed = -1.0;
		}
		GuiOverlay::close();
	}

	void remove() {
		if(prevGameSpeed >= 0) {
			gameSpeed = prevGameSpeed;
			prevGameSpeed = -1.0;
		}
		GuiOverlay::remove();
	}

	bool onGuiEvent(const GuiEvent& evt) override {
		if(evt.caller is okButton && evt.type == GUI_Clicked) {
			close();
			return true;
		}
		return GuiOverlay::onGuiEvent(evt);
	}
};

string HELP_TEXT;
HelpOverlay@ overlay;
void addHelpText(const string& str) {
	if(HELP_TEXT.length != 0)
		HELP_TEXT += "\n\n\n[hr/]\n";
	HELP_TEXT += str;

	if(!isLoadedSave) {
		if(overlay is null || overlay.parent is null) {
			showHelp();
		}
		else {
			overlay.page.text = HELP_TEXT;
			overlay.updateAbsolutePosition();
		}
	}
}

void showHelp() {
	@overlay = HelpOverlay();
	if(!isServer && gameTime < 5.0 && gameSpeed != 0 && !isClient) {
		overlay.prevGameSpeed = gameSpeed;
		gameSpeed = 0;
	}
}

void init() {
	checkHelp();
}

void checkHelp() {
	if(hasInvasionMap())
		addHelpText(locale::HELP_INVASION);
	if(playerEmpire.hasTrait(getTraitID("Ancient")))
		addHelpText(locale::HELP_ANCIENT);
	else if(playerEmpire.hasTrait(getTraitID("Extragalactic")))
		addHelpText(locale::HELP_EXTRAGALACTIC);
}

void postReload(Message& msg) {
	checkHelp();
}
// }}}