import elements.GuiContextMenu;
import tabs.Tab;
from tabs.tabbar import ActiveTab;
from obj_selection import selectedObject, selectedObjects, isSelected;
from overlays.AnomalyOverlay import AnomalyOverlay;
import resources;
import pickups;
import orbitals;
import abilities;
import util.icon_view;
import systems;
import constructions;

import dialogs.MessageDialog;
import dialogs.QuestionDialog;
import dialogs.InputDialog;

import void openSupportOverlay(Object@ obj, Object@ to) from "tabs.GalaxyTab";
import void openSupportOverlay(Object@ obj) from "tabs.GalaxyTab";
import bool switchToTab(TabCategory cat) from "tabs.tabbar";

const Sprite EXPORT_ARROW(spritesheet::ContextIcons, 0);
const Sprite COLONIZE_ICON(spritesheet::ContextIcons, 1);
const Sprite IMPORT_ARROW(spritesheet::ContextIcons, 2);
TradePath pathCheck;

#include "include/resource_constants.as"

bool playedSound = false;
void playOptionSound(const SoundSource@ sound) {
	if(sound is null || playedSound)
		return;
	
	playedSound = true;
	sound.play(priority=true);
}

const string tag_Weapon = "Weapon";
bool hasWeapons(Object@ obj) {
	Ship@ ship = cast<Ship>(obj);
	if(ship is null)
		return false;

	return ship.blueprint.design.hasTag(tag_Weapon);
}

class AutoColonize : MultiOption {
	void call(Object@ selected) {
		if(selected.isPlanet) {
			Empire@ owner = selected.visibleOwner;
			if(owner is null || !owner.valid) {
				playerEmpire.autoColonize(selected);
				playOptionSound(sound::generic_click);
			}
		}
	}
};

class AutoColonizeLevel : MultiOption {
	void call(Object@ selected) {
		if(selected.isPlanet && !selected.owner.valid) {
			playerEmpire.autoColonize(selected);
			auto@ resType = getResource(selected.primaryResourceType);
			if(resType !is null && resType.level > 0)
				playerEmpire.autoImportToLevel(selected, resType.level);
			playOptionSound(sound::generic_click);
		}
	}
};

class AutoColonizeSystem : MultiOption {
	bool level = false;
	AutoColonizeSystem(bool importLevel = false) {
		level = importLevel;
	}

	void call(Object@ selected) {
		Region@ region = cast<Region>(selected);
		if(selected.isStar)
			@region = selected.region;
		if(region !is null) {
			uint plCnt = region.planetCount;
			for(uint i = 0; i < plCnt; ++i) {
				Planet@ pl = region.planets[i];
				if(pl is null)
					continue;
				if(pl.owner is null || pl.owner.valid)
					continue;
				if(!pl.known)
					continue;
				playerEmpire.autoColonize(pl);
				if(level) {
					auto@ resType = getResource(pl.primaryResourceType);
					if(resType.level != 0)
						playerEmpire.autoImportToLevel(pl, resType.level);
				}
			}
			playOptionSound(sound::generic_click);
		}
	}
};

class CancelColonizeSystem : MultiOption {
	void call(Object@ selected) {
		Region@ region = cast<Region>(selected);
		if(selected.isStar)
			@region = selected.region;
		if(region !is null) {
			uint plCnt = region.planetCount;
			for(uint i = 0; i < plCnt; ++i) {
				Planet@ pl = region.planets[i];
				if(pl is null)
					continue;
				if(pl.owner is null || pl.owner.valid)
					continue;
				if(!pl.known)
					continue;
				if(!pl.isBeingColonized)
					continue;
				playerEmpire.cancelColonization(pl);
				playerEmpire.cancelAutoImportTo(pl);
				pl.exportResource(0, null);
			}
			playOptionSound(sound::generic_click);
		}
	}
};

class CancelAutoColonize : MultiOption {
	void call(Object@ selected) {
		if(selected.hasSurfaceComponent && selected.isBeingColonized) {
			playerEmpire.cancelColonization(selected);
			playerEmpire.cancelAutoImportTo(selected);
			selected.exportResource(0, null);
			playOptionSound(sound::generic_click);
		}
	}
}

class Colonize : MultiOption, QuestionDialogCallback {
	void call(GuiContextMenu@ menu) {
		if(selected.canSafelyColonize)
			MultiOption::call(menu);
		else
			question(locale::COLONIZE, locale::COLONIZE_UNSAFE_PROMPT,
				locale::COLONIZE, locale::CANCEL, this);
	}

	void questionCallback(QuestionDialog@ dialog, int answer) {
		if(answer == QA_Yes) {
			GuiContextMenu@ m;
			MultiOption::call(m);
		}
	}

	void call(Object@ obj) {
		if(selected is obj)
			return;
		if(selected !is null && selected.isPlanet && selected.owner.controlled) {
			selected.colonize(obj, 1.0);
			playOptionSound(sound::order_goto);
		}
	}

	void draw(GuiListbox@ ele, uint flags, const recti& absPos) override {
		if(!selected.canSafelyColonize)
			drawRectangle(absPos, Color(0xff900040));
		MultiOption::draw(ele, flags, absPos);
	}
};

class RepackOrbital : Option {
	void call() {
		/*cast<Orbital>(selected).repack();*/
		playOptionSound(sound::generic_click);
	}
};

class CancelColonize : MultiOption {
	void call(Object@ obj) {
		if(obj is selected)
			return;
		if(selected.isPlanet && selected.owner.controlled) {
			selected.stopColonizing(obj);
			playOptionSound(sound::generic_click);
		}
	}
};

class CancelColonizeTarget : Option {
	Object@ target;
	CancelColonizeTarget(Object@ target) {
		@this.target = target;
	}

	void call() {
		if(selected.isPlanet && selected.owner.controlled) {
			selected.stopColonizing(target);
			playOptionSound(sound::generic_click);
		}
	}
};

class MoveTo : SelectionOption {
	void call(Object@ selected) {
		if(selected.hasLeaderAI) {
			Region@ region = clicked.region;
			if(clicked.isStar && region !is null)
				selected.addGotoOrder(region, shiftKey);
			else
				selected.addGotoOrder(clicked, shiftKey);
			playOptionSound(sound::order_move);
		}
	}
};

class OddityGate : SelectionOption {
	void call(Object@ selected) {
		if(selected.hasLeaderAI) {
			selected.addOddityGateOrder(cast<Oddity>(clicked), shiftKey);
			playOptionSound(sound::order_gate);
		}
	}
};

class Rally : SelectionOption {
	void call(Object@ selected) {
		if(selected.hasConstruction) {
			selected.rallyTo(clicked);
			playOptionSound(sound::order_move);
		}
	}
};

class ClearRally : SelectionOption {
	void call(Object@ selected) {
		if(selected.hasConstruction) {
			selected.clearRally();
			playOptionSound(sound::order_move);
		}
	}
};

class Attack : SelectionOption {
	void call(Object@ selected) {
		selected.addAttackOrder(clicked, shiftKey);
		playOptionSound(sound::order_attack);
	}
};

class CaptureOption : SelectionOption {
	void call(Object@ selected) {
		if(selected.hasLeaderAI && clicked.isPlanet) {
			selected.addCaptureOrder(cast<Planet>(clicked), shiftKey);
			playOptionSound(sound::order_attack);
		}
	}
};

class ProtectedOption : MultiOption {
	void draw(GuiListbox@ ele, uint flags, const recti& absPos) override {
		if(clicked.isProtected(playerEmpire))
			drawRectangle(absPos, Color(0x00c0ff40));
		MultiOption::draw(ele, flags, absPos);
	}
};

class PickUp : SingleSelectionOption {
	void call(Object@ selected) {
		if(selected.hasLeaderAI && clicked.isPickup) {
			selected.addPickupOrder(cast<Pickup>(clicked), shiftKey);
			playOptionSound(sound::order_pickup);
		}
	}
};

class ScanAnomaly : SelectionOption {
	void call(Object@ selected) {
		if(selected.hasLeaderAI && clicked.isAnomaly) {
			selected.addScanOrder(cast<Anomaly>(clicked), shiftKey);
			playOptionSound(sound::order_scan);
		}
	}
};

class InvestigateAnomaly : Option {
	void call() {
		if(clicked.isAnomaly) {
			AnomalyOverlay(ActiveTab, cast<Anomaly>(clicked));
			playOptionSound(sound::generic_click);
		}
	}
};

class TransferSupport : Option {
	void call() {
		if(clicked !is null && clicked !is selected)
			openSupportOverlay(selected, clicked);
		else
			openSupportOverlay(selected);
	}
};

class ClaimPlanet : Option {
	void call() {
		clicked.annex();
		playOptionSound(sound::order_attack);
	}
};

class RefreshOption : SelectionOption {
	void call(Object@ selected) {
		if(selected.hasLeaderAI) {
			selected.addRefreshOrder(clicked, shiftKey);
			playOptionSound(sound::order_refresh);
		}
	}
};

class ScuttleOrbital : Option, QuestionDialogCallback {
	void questionCallback(QuestionDialog@ dialog, int answer) {
		if(answer == QA_Yes)
			cast<Orbital>(clicked).scuttle();
	}
	
	void call() {
		question(
			locale::SCUTTLE,
			format(locale::PROMPT_SCUTTLE, clicked.name),
			locale::SCUTTLE, locale::CANCEL,
			this).titleBox.color = Color(0xe00000ff);
	}
};

class ScuttleFlagship : Option, QuestionDialogCallback {
	void questionCallback(QuestionDialog@ dialog, int answer) {
		if(answer == QA_Yes)
			cast<Ship>(clicked).scuttle();
	}
	
	void call() {
		question(
			locale::SCUTTLE,
			format(locale::PROMPT_SCUTTLE, clicked.name),
			locale::SCUTTLE, locale::CANCEL,
			this).titleBox.color = Color(0xe00000ff);
	}
};

class RetrofitOption : Option {
	Object@ constructAt;
	Object@ constructFrom;

	RetrofitOption(Object@ constructAt, Object@ constructFrom) {
		@this.constructAt = constructAt;
		@this.constructFrom = constructFrom;
	}

	void call() {
		selected.retrofitFleetAt(constructAt, constructFrom=constructFrom);
		playOptionSound(sound::order_refresh);
	}
};

class TerraformOption : Option, IInputDialogCallback {
	array<const ResourceType@> types;
	double laborFactor;
	double costFactor;

	void call() {
		@pathCheck.forEmpire = playerEmpire;
		pathCheck.generate(getSystem(selected.region), getSystem(clicked.region));
		if(!pathCheck.isUsablePath)
			return;

		laborFactor = 1.0 + config::TERRAFORM_COST_STEP * double(pathCheck.pathSize - 1);
		costFactor = selected.terraformCostMod * laborFactor;

		InputDialog@ dialog = InputDialog(this, null);
		dialog.addTitle(locale::TERRAFORM+" "+clicked.name);
		dialog.accept.text = locale::TERRAFORM;
		dialog.addSelection(locale::RESOURCE);

		for(uint i = 0, cnt = getResourceCount(); i < cnt; ++i) {
			const ResourceType@ res = getResource(i);
			if(res.terraformLabor > 0 && res.canTerraform(selected, clicked)) {
				dialog.addItem(format(locale::TERRAFORM_ITEM, res.name, formatMoney(
					res.terraformCost * costFactor), standardize(res.terraformLabor * laborFactor)));
				types.insertLast(res);
			}
		}

		addDialog(dialog);
		changeCallback(dialog);
	}

	void changeCallback(InputDialog@ dialog) {
		uint index = uint(dialog.getSelection(0));
		if(index < types.length)
			dialog.accept.disabled = !playerEmpire.canPay(types[index].terraformCost * costFactor);
		else
			dialog.accept.disabled = true;
	}

	void inputCallback(InputDialog@ dialog, bool accepted) {
		if(accepted) {
			uint index = uint(dialog.getSelection(0));
			if(index < types.length)
				selected.startTerraform(cast<Planet>(clicked), types[index].id);
		}
	}
};

class FinanceDryDock : Option, IInputDialogCallback {
	Object@ buildAt;
	const Design@ design;
	double curPct = 0.0;
	bool isFree = false;

	FinanceDryDock() {}
	FinanceDryDock(Object@ obj) {
		@selected = obj;
		call();
	}

	FinanceDryDock(const Design@ dsg, Object@ at) {
		@design = dsg;
		@buildAt = at;
		call();
	}

	void call() {
		Orbital@ orb = cast<Orbital>(selected);
		if(orb !is null) {
			@design = orb.getDesign(OV_DRY_Design);
			curPct = orb.getValue(OV_DRY_Financed);
			isFree = orb.getValue(OV_DRY_Free) != 0.0;
		}

		int price = getBuildCost(design);
		price = double(price) * config::DRYDOCK_BUILDCOST_FACTOR * playerEmpire.DrydockCostFactor;
		double have = playerEmpire.RemainingBudget;
		if(buildAt !is null)
			have -= 100.0;
		double remain = ceil((1.0 - curPct) * double(price));
		double maxPct = curPct + clamp(have / remain, 0.0, 1.0) * (1.0 - curPct);

		InputDialog@ dialog = InputDialog(this, null);
		dialog.addTitle(format(locale::FINANCE_DRY_DOCK, design.name));
		dialog.accept.text = locale::FINANCE;
		dialog.addSpinboxInput(locale::PERCENTAGE, defaultValue=max(maxPct*100.0,1.0),
			minValue=max(curPct*100.0,1.0), maxValue=100.0, decimals=0, step=5.0);
		dialog.addLabel("", FT_Medium, 0.5, true);

		addDialog(dialog);
		changeCallback(dialog);
	}

	void changeCallback(InputDialog@ dialog) {
		double nextPct = dialog.getSpinboxInput(0) / 100.0;

		int price = ceil(double(getBuildCost(design) * config::DRYDOCK_BUILDCOST_FACTOR) * (nextPct - curPct) * playerEmpire.DrydockCostFactor);
		if(buildAt !is null)
			price += 100;
		int maintain = ceil(double(getMaintenanceCost(design)) * (nextPct - curPct));
		if(isFree)
			maintain = 0;
		dialog.accept.disabled = !playerEmpire.canPay(price);
		dialog.setLabel(1, formatMoney(price, maintain));
	}

	void inputCallback(InputDialog@ dialog, bool accepted) {
		if(accepted) {
			double pct = dialog.getSpinboxInput(0) / 100.0;
			Orbital@ orb = cast<Orbital>(selected);
			if(orb is null)
				buildAt.buildDryDock(design, pct);
			else
				orb.sendValue(OV_DRY_Financed, pct);
		}
	}
};

class WorkDryDock : Option {
	void call() {
		selected.workDryDock(cast<Orbital>(clicked));
		playOptionSound(sound::order_goto);
	}
};

class ExportLabor : SelectionOption {
	void call(Object@ selected) {
		selected.exportLaborTo(clicked);
		playOptionSound(sound::order_goto);
	}
};

class SetDefending : Option {
	Object@ obj;
	bool val;
	SetDefending(Object@ obj, bool value) {
		@this.obj = obj;
		this.val = value;
	}

	void call() {
		playerEmpire.setDefending(obj, val);
		playOptionSound(sound::order_refresh);
	}
};

class ExportResource : Option {
	Object@ from;
	Object@ to;
	const ResourceType@ type;
	uint index;

	ExportResource(Object@ From, Object@ To, const ResourceType@ Type, uint Index) {
		@from = From;
		@to = To;
		@type = Type;
		index = Index;
	}

	void call() {
		from.exportResource(index, to);
		playOptionSound(sound::order_goto);
	}

	int getWidth(GuiListbox@ ele) override {
		return Option::getWidth(ele) + 84;
	}

	void draw(GuiListbox@ ele, uint flags, const recti& absPos) override {
		const Font@ font = ele.skin.getFont(ele.TextFont);
		int baseLine = font.getBaseline();

		type.smallIcon.draw(recti_area(absPos.topLeft + vec2i(ele.horizPadding+3, (ele.lineHeight - 20) / 2), vec2i(20, 20)));
		EXPORT_ARROW.draw(recti_area(absPos.topLeft + vec2i(ele.horizPadding+26, (ele.lineHeight - 24) / 2), vec2i(24, 24)));
		drawObjectIcon(to, recti_area(absPos.topLeft + vec2i(ele.horizPadding+50, (ele.lineHeight - 26) / 2), vec2i(26, 26)));

		vec2i textOffset(ele.horizPadding+84, (ele.lineHeight - baseLine) / 2);
		font.draw(absPos.topLeft + textOffset, text);
	}
};

class ExportAnyResource : SelectionOption {
	void call(Object@ selected) {	
		if(selected.isPlanet) {
			if(selected !is clicked) {
				selected.exportResource(0, clicked);
				playOptionSound(sound::order_goto);
			}
		}
		else if(selected.isAsteroid) {
			if(selected.nativeResourceCount == 1) {
				selected.exportResource(0, clicked);
				playOptionSound(sound::order_goto);
			}
		}
	}
};

class BuildMiningBase : Option {
	uint resource;
	Object@ obj;
	Object@ slaved;

	BuildMiningBase(Object@ obj, uint resId, Object@ slaved = null) {
		@this.obj = obj;
		resource = resId;
		@this.slaved = slaved;
	}

	void call() {
		obj.buildAsteroid(cast<Asteroid>(clicked), resource, constructFrom=slaved);
		playOptionSound(sound::order_goto);
	}
};

class ImportResource : Option {
	Object@ from;
	Object@ to;
	const ResourceType@ type;
	uint index;

	ImportResource(Object@ From, Object@ To, const ResourceType@ Type, uint Index) {
		@from = From;
		@to = To;
		@type = Type;
		index = Index;
	}

	void call() {
		from.exportResource(index, to);
		playOptionSound(sound::generic_click);
	}

	int getWidth(GuiListbox@ ele) override {
		return Option::getWidth(ele) + 84;
	}

	void draw(GuiListbox@ ele, uint flags, const recti& absPos) override {
		const Font@ font = ele.skin.getFont(ele.TextFont);
		int baseLine = font.getBaseline();

		drawObjectIcon(to, recti_area(absPos.topLeft + vec2i(ele.horizPadding, (ele.lineHeight - 26) / 2), vec2i(26, 26)));
		IMPORT_ARROW.draw(recti_area(absPos.topLeft + vec2i(ele.horizPadding+26, (ele.lineHeight - 24) / 2), vec2i(24, 24)));
		type.smallIcon.draw(recti_area(absPos.topLeft + vec2i(ele.horizPadding+53, (ele.lineHeight - 20) / 2), vec2i(20, 20)));

		vec2i textOffset(ele.horizPadding+84, (ele.lineHeight - baseLine) / 2);
		font.draw(absPos.topLeft + textOffset, text);
	}
};

class AutoAssign : Option {
	const ResourceClass@ resCls;

	AutoAssign(const ResourceClass@ cls) {
		@resCls = cls;
	}

	void call() {
		playerEmpire.autoImportResourceOfClass(clicked, resCls.id);
		playOptionSound(sound::generic_click);
	}
};

class AutoAssignBoth : Option {
	const ResourceClass@ clsOne;
	const ResourceClass@ clsTwo;

	AutoAssignBoth(const ResourceClass@ one, const ResourceClass@ two) {
		@clsOne = one;
		@clsTwo = two;
	}

	void call() {
		playerEmpire.autoImportResourceOfClass(clicked, clsOne.id);
		playerEmpire.autoImportResourceOfClass(clicked, clsTwo.id);
		playOptionSound(sound::generic_click);
	}
};

class AutoAssignLevel : Option {
	uint level;

	AutoAssignLevel(uint level) {
		this.level = level;
	}

	void call() {
		playerEmpire.autoImportToLevel(clicked, level);
		playOptionSound(sound::generic_click);
	}
};

class CancelAutoAssign : Option {
	void call() {
		playerEmpire.cancelAutoImportTo(clicked);
		playOptionSound(sound::generic_click);
	}
}

class StopExportResource : SingleSelectionOption {
	uint index;

	StopExportResource(uint Index) {
		index = Index;
	}

	void call(Object@ selected) {
		selected.exportResource(index, null);
		playOptionSound(sound::generic_click);
	}
};

class StopImportResource : Option {
	uint index;

	StopImportResource(uint Index) {
		index = Index;
	}

	void call() {
		clicked.exportResource(index, null);
		playOptionSound(sound::generic_click);
	}
};

class Abandon : SingleSelectionOption, QuestionDialogCallback {
	Object@ planet;
	Abandon() {
	}

	void questionCallback(QuestionDialog@ dialog, int answer) {
		if(answer == QA_Yes)
			planet.abandon();
	}

	void call(Object@ selected) {
		@planet = selected;
		question(
			locale::ABANDON,
			format(locale::PROMPT_ABANDON, selected.name),
			locale::ABANDON_ACCEPT, locale::CANCEL,
			this).titleBox.color = Color(0xe00000ff);
	}
};

class TriggerAbility : SingleSelectionOption {
	int id;
	TriggerAbility(int ID) {
		id = ID;
	}

	void call(Object@ selected) {
		selected.activateAbility(id);
		playOptionSound(sound::order_attack);
	}
};

class TargetAbility : MultiOption {
	int id;
	Object@ target;
	double range;
	Color bg = colors::Invisible;
	const AbilityType@ type;

	TargetAbility(int ID, Object@ targ, double range, const AbilityType@ type) {
		id = ID;
		@target = targ;
		this.range = range;
		@this.type = type;
	}

	void call(Object@ obj) {
		if(obj is null || (!obj.isArtifact && !obj.owner.controlled) || !obj.hasAbilities)
			return;
		int ablId = -1;
		if(obj is this.selected) {
			ablId = id;
			playOptionSound(type.activateSound);
		}
		else {
			ablId = obj.findAbilityOfType(type.id);
		}
		if(ablId != -1) {
			if(!obj.hasLeaderAI || range == INFINITY)
				obj.activateAbility(id, target);
			else
				obj.addAbilityOrder(id, target, shiftKey);
		}
	}

	void draw(GuiListbox@ ele, uint flags, const recti& absPos) override {
		drawRectangle(absPos, bg);
		MultiOption::draw(ele, flags, absPos);
	}
};

class ConstructionOption : Option {
	const ConstructionType@ type;
	Object@ from;
	Targets targets;
	Color bg(0x00000000);

	ConstructionOption(const ConstructionType@ type, Object@ from, Targets@ targets) {
		@this.type = type;
		@this.from = from;
		this.targets = targets;
	}

	void call() {
		from.buildConstruction(type.id, objTarg=targets[0].obj);
	}

	void draw(GuiListbox@ ele, uint flags, const recti& absPos) override {
		drawRectangle(absPos, bg);
		Option::draw(ele, flags, absPos);
	}
};

bool openContextMenu(Object& clicked, Object@ selected = null) {
	//Play only one sound per context menu
	playedSound = false;

	if(selected is null)
		@selected = selectedObject;
	GuiContextMenu menu(mousePos);

	//Find the right visible owners
	Empire@ selOwner = null, clickedOwner = null;
	Region@ clickedRegion;
	if(selected !is null) {
		if(selected.hasSurfaceComponent)
			@selOwner = selected.visibleOwner;
		else
			@selOwner = selected.owner;
	}
	if(clicked !is null) {
		if(clicked.hasSurfaceComponent)
			@clickedOwner = clicked.visibleOwner;
		else
			@clickedOwner = clicked.owner;

		@clickedRegion = cast<Region>(clicked);
		if(clicked.isStar)
			@clickedRegion = clicked.region;
	}

	Orbital@ orbitalMaster;
	if(selected !is null && selected.isOrbital) {
		Orbital@ selOrb = cast<Orbital>(selected);
		if(selOrb.hasMaster())
			@orbitalMaster = selOrb.getMaster();
	}

	Object@ constructObj;
	Object@ constructSlave;
	if(orbitalMaster !is null && orbitalMaster.hasConstruction) {
		@constructObj = orbitalMaster;
		@constructSlave = selected;
	}
	else if(selected !is null && selected.hasConstruction)
		@constructObj = selected;


	//GuiContextMenu@ sub = menu.addSubMenu("Test");
	//sub.addOption("A");
	//sub.addOption("B");
	//sub.addOption("C");
	
	if(selected !is null && selOwner is playerEmpire && selected.hasLeaderAI && selected.isShip) {
		if(clicked.isAnomaly && cast<Anomaly>(clicked).progress < 1.f)
			addOption(menu, selected, clicked, locale::SCAN_ANOMALY, ScanAnomaly(), icons::Anomaly);
	}
	else if(clicked.isAnomaly) {
		addOption(menu, selected, clicked, locale::INVESTIGATE_ANOMALY, InvestigateAnomaly(), icons::Anomaly);
	}

	//Resource exporting
	if(selected !is null && selected.hasResources && clicked.hasResources) {
		if(selectedObjects.length > 1)
			addOption(menu, selected, clicked, format(locale::EXPORT_RESOURCES, clicked.name), ExportAnyResource());
		
		//Exports
		uint cnt = selected.nativeResourceCount;
		if(clicked is selected) {
			if(selected.owner is playerEmpire) {
				for(uint i = 0; i < cnt; ++i) {
					Object@ dest = selected.nativeResourceDestination[i];
					if(dest is null)
						continue;
					const ResourceType@ type = getResource(selected.nativeResourceType[i]);
					if(!type.exportable)
						continue;
					if(selected.nativeResourceLocked[i])
						continue;
					
					string text;
					
					if(selected.nativeResourceUsable[i] && dest.owner is playerEmpire)
						text = format(locale::STOP_EXPORT_RESOURCE, type.name, dest.name);
					else
						text = format(locale::STOP_EXPORT_RES_QUEUE, type.name, dest.name);
					addOption(menu, selected, clicked, text, StopExportResource(i), type.smallIcon);
				}
			}
		}
		else if(selected.exportEnabled && clicked.importEnabled
				&& (selected.region !is null && clicked.region !is null)) {
			for(uint i = 0; i < cnt; ++i) {
				const ResourceType@ type = getResource(selected.nativeResourceType[i]);
				if(!type.exportable)
					continue;
				if(selected.nativeResourceLocked[i])
					continue;

				bool usable = false;
				Object@ dest = selected.nativeResourceDestination[i];
				string text;

				if(selected.owner is playerEmpire)
					usable = selected.nativeResourceUsable[i];

				if(dest is clicked) {
					if(usable && clicked.owner is playerEmpire)
						text = format(locale::STOP_EXPORT_RESOURCE, type.name, dest.name);
					else
						text = format(locale::STOP_EXPORT_RES_QUEUE, type.name, dest.name);
					addOption(menu, selected, clicked, text, StopExportResource(i), type.smallIcon);
				}
				else {
					if(usable && clicked.owner is playerEmpire)
						text = format(locale::EXPORT_RESOURCE, type.name, clicked.name);
					else
						text = format(locale::QUEUE_EXPORT_RESOURCE, type.name, clicked.name);
					addOption(menu, selected, clicked, text, ExportResource(selected, clicked, type, i));
				}
			}
		}

		//Imports
		if(clicked !is selected) {
			if(selected.importEnabled && clicked.exportEnabled
					&& (selected.region !is null && clicked.region !is null)) {
				cnt = clicked.nativeResourceCount;
				for(uint i = 0; i < cnt; ++i) {
					const ResourceType@ type = getResource(clicked.nativeResourceType[i]);
					if(!type.exportable)
						continue;

					bool usable = false;
					Object@ dest = clicked.nativeResourceDestination[i];
					string text;

					if(clicked.owner is playerEmpire)
						usable = clicked.nativeResourceUsable[i];

					if(dest is selected) {
						if(usable && selected.owner is playerEmpire)
							text = format(locale::STOP_IMPORT_RESOURCE, type.name, clicked.name);
						else
							text = format(locale::STOP_IMPORT_RES_QUEUE, type.name, clicked.name);
						addOption(menu, selected, clicked, text, StopImportResource(i), type.smallIcon);
					}
					else {
						if(usable && selected.owner is playerEmpire)
							text = format(locale::IMPORT_RESOURCE, type.name, clicked.name);
						else
							text = format(locale::QUEUE_IMPORT_RESOURCE, type.name, clicked.name);
						addOption(menu, clicked, selected, text, ImportResource(clicked, selected, type, i));
					}
				}
			}
		}
	}

	//Auto-assign resources
	if(clicked.isPlanet && (clickedOwner is playerEmpire || clicked.isBeingColonized)) {
		if(clicked.hasAutoImports) {
			addOption(menu, selected, clicked, locale::CANCEL_AUTO_IMPORT, CancelAutoAssign());
		}
		else {
			uint clickedLevel = clicked.level;
			uint assignLevel = 0;
			auto@ resType = getResource(clicked.primaryResourceType);
			if(resType !is null) {
				if(clickedLevel > resType.level) {
					assignLevel = min(5, clickedLevel+1);
				}
				else if(clickedLevel == resType.level) {
					if(clicked.nativeResourceDestination[0] is null)
						assignLevel = clickedLevel+1;
					else
						assignLevel = 0;
				}
				else {
					assignLevel = resType.level;
				}
			}
			if(assignLevel != 0 && assignLevel > clickedLevel && assignLevel < uint(clicked.maxLevel)) {
				Sprite icon;
				if(assignLevel <= 3)
					icon = Sprite(spritesheet::ResourceClassIcons, clamp(assignLevel-1, 0, 2));

				addOption(menu, selected, clicked, format(locale::AUTO_IMPORT_LEVEL, toString(assignLevel)),
						AutoAssignLevel(assignLevel), icon);
			}
		}
	}

	//Colonization
	if(clicked.isPlanet && playerEmpire.NoAutoColonize == 0) {
		bool quarantined = clicked.quarantined;
		bool addedColonyOptions = false;
		
		if(selected !is null && selected.owner is playerEmpire && selected.isPlanet
				&& selected !is clicked && selected.maxPopulation > 1) {
			//Colonization from selected planet
			if(!selected.hasColonyTarget(clicked)) {
				if(clickedOwner is null || !clickedOwner.valid) {
					if(!quarantined) {
						addedColonyOptions = true;
						
						//TODO: Take slipstream & gate into account
						double eta = 1.0;
						eta += newtonArrivalTime(selected.colonyShipAccel, clicked.position - selected.position, vec3d()) / 60.0;
						if(selected.isColonizing)
							eta += double(selected.colonyOrderCount);
						if(selected.owner.HasFlux != 0)
							eta = 0;
						
						if(playerEmpire.ForbidColonization == 0) {
							if(eta <= 0)
								addOption(menu, selected, clicked, format(locale::COLONIZE_WITH_BASIC, selected.name), Colonize(), COLONIZE_ICON);
							else
								addOption(menu, selected, clicked, format(locale::COLONIZE_WITH, selected.name, toString(eta, 1)), Colonize(), COLONIZE_ICON);
						}
						
						if(clicked.isBeingColonized)
							addOption(menu, selected, clicked, locale::CANCEL_AUTO_COLONIZE, CancelAutoColonize());
					}
				}
				else if(clicked.owner is playerEmpire && clicked.population < 1) {
					if(playerEmpire.ForbidColonization == 0)
						addOption(menu, selected, clicked, locale::COLONIZE_CONTINUE, Colonize(), COLONIZE_ICON);
					addedColonyOptions = true;
				}
			}
			else {
				string text = format(locale::COLONIZE_CANCEL, clicked.name);
				addOption(menu, selected, clicked, text, CancelColonize());
				addedColonyOptions = true;
			}
		}
		
		if(!addedColonyOptions) {		
			//Auto-colonization
			if(clicked.isBeingColonized) {
				addOption(menu, selected, clicked, locale::CANCEL_AUTO_COLONIZE, CancelAutoColonize());
			}
			else {
				if(clickedOwner is null || !clickedOwner.valid) {
					addOption(menu, selected, clicked, quarantined ? locale::AUTO_COLONIZE_BLOCKED : locale::AUTO_COLONIZE, AutoColonize(), COLONIZE_ICON);

					auto@ resType = getResource(clicked.primaryResourceType);
					if(resType !is null && resType.level > 0) {
						addOption(menu, selected, clicked,
								format(locale::AUTO_COLONIZE_LEVEL, resType.level),
								AutoColonizeLevel(),
								Sprite(spritesheet::ResourceClassIcons, clamp(resType.level-1, 0, 2)));
					}
				}
			}
		}
	}

	if(selected !is null && selected.owner.controlled) {
		if(selected.isPlanet && clicked.isPlanet) {
			//Colonization order management
			if(selected is clicked) {
				uint colonyOrders = selected.colonyOrderCount;
				for(uint i = 0; i < colonyOrders; ++i) {
					Object@ target = selected.colonyTarget[i];
					if(target is null)
						break;
					string text = format(locale::COLONIZE_CANCEL, target.name);
					addOption(menu, selected, clicked, text, CancelColonizeTarget(target));
				}
			}
		}

		//Transfering support ships
		if(clicked !is null && clicked.owner is selected.owner) {
			if(selected.hasLeaderAI && selected.SupplyCapacity > 0) {
				if(selected is clicked) {
					addOption(menu, selected, clicked, locale::MANAGE_SUPPORTS, TransferSupport(), icons::ManageSupports);
				}
				else if(clicked.hasLeaderAI && clicked.SupplyCapacity > 0) {
					addOption(menu, selected, clicked, locale::TRANSFER_SUPPORT_SHIPS, TransferSupport(), icons::ManageSupports);
				}
			}
		}

		//Pickup goodies
		if(selected.hasLeaderAI && clicked.isPickup && selected.hasMover && selected.maxAcceleration > 0) {
			Pickup@ pickup = cast<Pickup>(clicked);
			const PickupType@ type = getPickupType(pickup.PickupType);

			Object@ prot = pickup.getProtector();
			if(prot !is null)
				addOption(menu, selected, prot, locale::ATTACK, Attack());
			if(shiftKey || (!pickup.isPickupProtected && type.canPickup(pickup, selected)))
				addOption(menu, selected, clicked, format(type.verb, type.name), PickUp());
		}

		//Combat options
		if(clickedOwner !is selected.owner && clickedOwner !is null && clickedOwner.valid) {
			Ship@ ship = cast<Ship>(selected);
			if(ship !is null && ship.hasLeaderAI) {
				const Design@ dsg = ship.blueprint.design;
				if(dsg !is null) {
					bool hasWeapons = dsg.hasTag(ST_Weapon);
					bool hasSupportAttack = ship.supportCount > 0 && ship.getFleetDPS() > 0;
					if((hasWeapons && ship.blueprint.canTarget(ship, clicked)) || (hasSupportAttack && (clicked.isShip || clicked.isOrbital)))
						addOption(menu, selected, clicked, locale::ATTACK, Attack(), icons::Strength);
				}
			}
		}

		if(selected.isShip && selected.hasLeaderAI && clicked.isPlanet
				&& clickedOwner !is null && clickedOwner.valid && clickedOwner !is playerEmpire) {
			if(playerEmpire.isHostile(clickedOwner) && !selected.hasOrbit) {
				if(clicked.isProtected(playerEmpire)) {
					addOption(menu, selected, clicked, locale::PROTECTED_OPTION, ProtectedOption(), icons::Strength * Color(0xff0000ff));
				}
				else {
					double base = clicked.baseLoyalty;
					double loy = clicked.currentLoyalty;
					double timer = config::SIEGE_LOYALTY_TIME * ceil(base / 10.0) * (loy / max(base, 1.0));
					timer *= selected.owner.CaptureTimeFactor;
					timer *= clicked.owner.CaptureTimeDifficulty;
					double cost = config::SIEGE_LOYALTY_SUPPLY_COST * loy;
					cost *= selected.owner.CaptureSupplyFactor;
					cost *= clicked.owner.CaptureSupplyDifficulty;
					addOption(menu, selected, clicked, format(locale::CAPTURE_OPTION, standardize(cost), formatTime(timer)), CaptureOption(), icons::Strength * Color(0xff8000ff));
				}
			}
		}

		//Movement options
		if(selected.hasMover && selected.hasLeaderAI && (!selected.hasOrbit || selected.maxAcceleration > 0)) {
			if(clicked !is null && clicked.isOddity && cast<Oddity>(clicked).isGate())
				addOption(menu, selected, clicked, locale::ODDITY_GATE, OddityGate());

			Object@ nameObj = clickedRegion is null ? @clicked : @clickedRegion;
			addOption(menu, selected, clicked, format(locale::MOVE_TO_OBJ, formatObjectName(nameObj)), MoveTo(),
					Sprite(spritesheet::ContextIcons, 0, Color(0xffcd00ff)));
		}
	}

	//System actions
	if(selected !is null && selected.owner is playerEmpire) {
		//Support resupply
		if(clicked !is null && selected.isShip && selected.hasLeaderAI) {
			if(clicked.isStar && clicked.region.AvailSupportMask & playerEmpire.mask != 0) {
				addOption(menu, selected, clicked.region, format(locale::REFRESH_SUPPORTS, clicked.region.name), RefreshOption(),
						icons::ManageSupports);
			}
			else if((clicked.isPlanet || (clicked.isOrbital && clicked.hasLeaderAI)) && clickedOwner is playerEmpire && clicked.supportCount > 0) {
				addOption(menu, selected, clicked, format(locale::REFRESH_SUPPORTS, clicked.name), RefreshOption(),
						icons::ManageSupports);
			}
		}

		//Asteroid base construction

		if(clicked !is null && constructObj !is null && constructObj.hasConstruction
			&& constructObj.canBuildAsteroids && clicked.isAsteroid &&
			cast<Asteroid>(clicked).canDevelop(playerEmpire)
			&& clicked.region !is null && constructObj.region !is null) {
	
			Object@ pathFrom = constructObj;
			if(constructSlave !is null && constructSlave.region !is null)
				@pathFrom = constructSlave;

			@pathCheck.forEmpire = playerEmpire;
			pathCheck.generate(getSystem(pathFrom.region), getSystem(clicked.region));

			if(pathCheck.isUsablePath) {
				double costFactor = 1.0 + config::ASTEROID_COST_STEP * double(pathCheck.pathSize - 1);
	
				Asteroid@ asteroid = cast<Asteroid>(clicked);
				for(uint i = 0, cnt = asteroid.getAvailableCount(); i < cnt; ++i) {
					uint resId = asteroid.getAvailable(i);
					double cost = asteroid.getAvailableCost(i);
					const ResourceType@ type = getResource(resId);
	
					if(type !is null && cost > 0.0)
						addOption(menu, selected, clicked,
								format(locale::BUILD_ASTEROID_OPTION,
										type.name, standardize(cost*costFactor, true)),
								BuildMiningBase(constructObj, resId, constructSlave),
								type.smallIcon);
				}
			}
		}

		//Terraforming
		if(clicked !is null && selected.hasConstruction
			&& selected.canTerraform && clicked.isPlanet
			&& clickedOwner is playerEmpire && !clicked.isTerraforming()
			&& clicked.region !is null && selected.region !is null
			&& clicked !is selected
			&& config::ENABLE_TERRAFORMING != 0
			&& playerEmpire.ForbidTerraform == 0) {

			@pathCheck.forEmpire = playerEmpire;
			pathCheck.generate(getSystem(selected.region), getSystem(clicked.region));
			if(pathCheck.isUsablePath)
				addOption(menu, selected, clicked, locale::TERRAFORM_OPTION, TerraformOption());
		}

		if(selected is clicked && selected.isPlanet) {
			//Abandon planet
			if(!selected.isContested)
				addOption(menu, selected, clicked, locale::ABANDON, Abandon(), icons::UnderSiege * colors::Red);
		}

		//Retrofit options
		if(selected.hasLeaderAI && clicked !is null && clicked.owner is playerEmpire
				&& selected.region !is null && selected.region is clicked.region) {

			//Figure out if we should redirect this
			Object@ constructFrom;
			Object@ constructAt;

			if(clicked.isOrbital) {
				Orbital@ orb = cast<Orbital>(clicked);
				if(orb.hasMaster()) {
					@constructAt = orb.getMaster();
					@constructFrom = clicked;
				}
				else {
					@constructAt = clicked;
				}
			}
			else {
				@constructAt = clicked;
			}

			if(constructAt.hasConstruction && constructAt.canBuildShips) {
				int cost = selected.getRetrofitCost();
				if(cost >= 0) {
					double labor = selected.getRetrofitLabor();
					addOption(menu, selected, clicked, format(locale::RETROFIT_OPTION, formatMoney(cost), standardize(labor, true)), RetrofitOption(constructAt, constructFrom));
				}
			}
		}
	}
	
	//System colonization
	if(clicked.isStar && playerEmpire.NoAutoColonize == 0) {
		Region@ region = clicked.region;
		if(region !is null) {
			//Check if there are any uncolonized planets
			uint plCnt = region.planetCount;
			bool hasUncolonized = false, hasUnderleveled = false, hasColonizing = false;
			for(uint i = 0; i < plCnt; ++i) {
				Planet@ pl = region.planets[i];
				if(pl is null)
					continue;
				if(pl.owner is null || pl.owner.valid)
					continue;
				if(!pl.known)
					continue;
				if(pl.isBeingColonized) {
					hasColonizing = true;
					continue;
				}
				hasUncolonized = true;
				auto@ resType = getResource(pl.primaryResourceType);
				if(resType !is null && resType.level != 0)
					hasUnderleveled = true;
			}

			if(hasUncolonized) {
				addOption(menu, selected, clicked, format(locale::AUTO_COLONIZE_SYSTEM, region.name), AutoColonizeSystem(), COLONIZE_ICON);
				if(hasUnderleveled)
					addOption(menu, selected, clicked, format(locale::AUTO_COLONIZE_SYSTEM_LEVEL, region.name), AutoColonizeSystem(true), Sprite(spritesheet::ResourceClassIcons, 7));
			}
			if(hasColonizing)
				addOption(menu, selected, clicked, format(locale::STOP_COLONIZE_SYSTEM, region.name), CancelColonizeSystem());
		}
	}

	//Defense projection
	if((selected is clicked && selected.owner is playerEmpire && selected.isPlanet)
			|| (clickedRegion !is null && clickedRegion.PlanetsMask & playerEmpire.mask != 0)
			|| (clickedOwner is playerEmpire && clicked.isOrbital && clicked.hasLeaderAI && clicked.region !is null && clicked.region.TradeMask & playerEmpire.TradeMask.value != 0 && clicked.SupplyCapacity > 0)
			|| playerEmpire.isDefending(clicked)) {
		Object@ obj = clickedRegion is null ? @clicked : @clickedRegion;
		bool isDefending = playerEmpire.isDefending(obj);
		if(isDefending) {
			Sprite sprt = icons::Defense;
			sprt.color = colors::Red;
			addOption(menu, selected, obj, format(locale::DEFENSE_OFF_OPTION, obj.name),
					SetDefending(obj, false), sprt);
		}
		else {
			addOption(menu, selected, clicked, format(locale::DEFENSE_ON_OPTION, obj.name),
					SetDefending(obj, true), icons::Defense);
		}
	}
	
	//Finance options
	if(clicked is selected && clicked.owner is playerEmpire) {
		Orbital@ orb = cast<Orbital>(clicked);
		if(orb !is null && orb.getDesign(OV_DRY_Design) !is null && orb.getValue(OV_DRY_Financed) < 1.f)
			addOption(menu, selected, clicked, locale::FINANCE_OPTION, FinanceDryDock());
	}
	else if(selected !is null && clicked !is null && clicked !is selected && selected.owner is playerEmpire && clicked.owner is playerEmpire) {
		Orbital@ orb = cast<Orbital>(clicked);
		if(orb !is null && orb.getDesign(OV_DRY_Design) !is null && selected.hasConstruction && selected.canBuildShips)
			addOption(menu, selected, clicked, locale::WORK_DRY_DOCK, WorkDryDock());
	}

	//Labor exporting
	if(selected !is null && selected.owner is playerEmpire && clickedOwner is playerEmpire
		&& selected.hasConstruction && selected.canExportLabor && clicked.hasConstruction && clicked.canImportLabor
		&& selected.laborIncome > 0) {
		addOption(menu, selected, clicked, format(locale::EXPORT_LABOR, clicked.name), ExportLabor(), icons::Labor);
	}
	
	//Rallying
	if(selected !is null && selected.owner is playerEmpire && selected.hasConstruction)
		if(selected.isRallying && (selected is clicked || selected.rallyObject is clicked))
			addOption(menu, selected, clicked, locale::STOP_RALLY, ClearRally(), COLONIZE_ICON);
		else if(selected.canBuildShips)
			addOption(menu, selected, clicked, format(locale::RALLY_TO, clicked.name), Rally(), COLONIZE_ICON);

	//Scuttle options
	if(clicked is selected && clicked.owner.controlled) {
		if(clicked.isOrbital && !cast<Orbital>(clicked).isContested)
			addOption(menu, selected, clicked, locale::SCUTTLE, ScuttleOrbital());
		else if(clicked.isShip && clicked.hasLeaderAI)
			addOption(menu, selected, clicked, locale::SCUTTLE, ScuttleFlagship());
	}

	//Abilities
	if(selected !is null && selected.hasAbilities
			&& (selected.owner.controlled || selected.isArtifact)) {
		array<Ability> abilities;
		abilities.syncFrom(selected.getAbilities());

		Targets targs;
		@targs.add(TT_Object, fill=true).obj = clicked;

		for(uint i = 0, cnt = abilities.length; i < cnt; ++i) {
			Ability@ abl = abilities[i];
			if(abl.disabled)
				continue;
			if(selected.isArtifact)
				@abl.emp = playerEmpire;
			else
				@abl.emp = selected.owner;

			string option = format(locale::ABILITY_TRIGGER, abl.type.name);

			string costs = abl.formatCosts(targs);
			if(costs.length != 0)
				option += " ("+costs+")";
			if(abl.cooldown > 0)
				option += format(locale::ABILITY_CD, formatTime(abl.cooldown));
			else if(abl.type.cooldown > 0)
				option += format(locale::ABILITY_COOLDOWN, formatTime(abl.type.cooldown));

			if(abl.type.targets.length == 0) {
				if(selected !is clicked)
					continue;

				addOption(menu, selected, clicked, option,
					TriggerAbility(abl.id), abl.type.icon);
			}
			else if(abl.type.targets[0].type == TT_Object) {
				if(selected is clicked)
					continue;
				if(!abl.canActivate(targs, ignoreCost=true))
					continue;
				TargetAbility opt(abl.id, clicked, abl.getRange(targs), abl.type);
				if(!abl.canActivate(targs))
					opt.bg = Color(0xff900040);
				addOption(menu, selected, clicked, option, opt, abl.type.icon);
			}
		}
	}

	//Constructions
	if(constructObj !is null && clicked !is null) {
		Targets@ targs;
		for(uint i = 0, cnt = getConstructionTypeCount(); i < cnt; ++i) {
			auto@ cons = getConstructionType(i);
			if(!cons.inContext)
				continue;
			if(cons.targets.length == 0)
				continue;
			if(cons.targets[0].type != TT_Object)
				continue;

			if(targs is null) {
				@targs = Targets();
				@targs.add(TT_Object, true).obj = clicked;
			}

			if(!cons.canBuild(constructObj, targs, ignoreCost=true)) {
				continue;
			}

			bool haveCost = cons.canBuild(constructObj, targs, ignoreCost=false);
			ConstructionOption opt(cons, constructObj, targs);
			if(!haveCost)
				opt.bg = Color(0xff000030);

			string costs = cons.formatCosts(constructObj, targs);
			string optText;
			if(costs.length != 0)
				optText = format("$1: $2 ($3)", constructObj.name, cons.name, costs);
			else
				optText = format("$1: $2", constructObj.name, cons.name);

			addOption(menu, selected, clicked, optText, opt);
		}
	}

	//Only show the menu if there are options
	if(menu.list.itemCount == 0) {
		menu.remove();
		return false;
	}
	else {
		menu.updateAbsolutePosition();
		return true;
	}
}

// {{{ Shortcut helpers for context menu
class Option : GuiContextOption {
	Object@ clicked;
	Object@ selected;

	void call() {
	}

	void call(GuiContextMenu@ menu) {
		call();
	}
};

class SelectionOption : Option {
	void call(Object@ selected) {
	}

	void call(GuiContextMenu@ menu) {
		if(selectedObject is null) {
			call(selected);
			return;
		}
		array<Object@>@ selection = selectedObjects;
		for(uint i = 0, cnt = selection.length; i < cnt; ++i)
			call(selection[i]);
	}
};

class MultiOption : Option {
	void call(Object@ selected) {
	}

	void call(GuiContextMenu@ menu) {
		if(selectedObject is null) {
			if(selected !is null)
				call(selected);
			if(clicked !is null && selected !is clicked)
				call(clicked);
			return;
		}
		array<Object@>@ selection = selectedObjects;
		bool haveClicked = false;
		for(uint i = 0, cnt = selection.length; i < cnt; ++i) {
			if(selection[i] is clicked)
				haveClicked = true;
			call(selection[i]);
		}
		if(!haveClicked && clicked !is null)
			call(clicked);
	}
};

class SingleSelectionOption : Option {
	void call(Object@ selected) {
	}

	void call(GuiContextMenu@ menu) {
		if(selectedObject is null) {
			call(selected);
			return;
		}
		call(selectedObject);
	}
};

void addOption(GuiContextMenu@ menu, Object@ selected, Object@ clicked, const string& text, Option@ opt, int value = 0) {
	@opt.clicked = clicked;
	@opt.selected = selected;
	opt.value = value;
	opt.text = text;
	menu.addOption(opt);
}

void addOption(GuiContextMenu@ menu, Object@ selected, Object@ clicked, const string& text, Option@ opt, const Sprite& sprt, int value = 0) {
	@opt.clicked = clicked;
	@opt.selected = selected;
	opt.value = value;
	opt.text = text;
	opt.icon = sprt;
	menu.addOption(opt);
}
// }}}