|
DefineClass.DevDock = { |
|
__parents = { "XDialog" }, |
|
ZOrder = 100, |
|
IdNode = true, |
|
Background = white, |
|
BorderWidth = 1, |
|
BorderColor = black, |
|
MinWidth = 32, |
|
MinHeight = 32, |
|
MaxWidth = 32, |
|
MaxHeight = 32, |
|
HAlign = "left", |
|
VAlign = "top", |
|
|
|
dock_side = false, |
|
popup = false, |
|
} |
|
|
|
function DevDock:Init() |
|
local dock = self |
|
local mover = XMoveControl:new({ |
|
Id = "idMover", |
|
last_delta = false, |
|
any_movement = false, |
|
popup_visible_before_drag = false, |
|
OnDragDelta = function(self, delta) |
|
local dlg = GetDialog(self) |
|
self.last_delta = delta |
|
if not self.any_movement and delta ~= point20 then |
|
self.any_movement = true |
|
self.popup_visible_before_drag = dlg.popup:GetVisible() |
|
dlg.popup:SetVisible(false) |
|
end |
|
dlg:UpdatePopupAnchor() |
|
end, |
|
OnDragStart = function(self) |
|
local dlg = GetDialog(self) |
|
end, |
|
OnDragEnd = function(self) |
|
local dlg = GetDialog(self) |
|
if not self.any_movement then |
|
dlg:OnClick() |
|
else |
|
dlg:SnapToEdge() |
|
end |
|
self.last_delta = false |
|
self.any_movement = false |
|
end, |
|
}, self) |
|
local btn = XText:new({ |
|
Id = "idArrow", |
|
}, mover) |
|
btn:SetText("?") |
|
|
|
self.popup = DevDockPopup:new({ |
|
Id = "idPopup", |
|
dock = self, |
|
}, self) |
|
self.popup:SetVisible(table.get(LocalStorage, "DevDock", "Popup")) |
|
|
|
local dock_pos = table.get(LocalStorage, "DevDock", "DockPos") |
|
local dock_side = table.get(LocalStorage, "DevDock", "DockSide") |
|
if dock_pos and dock_side then |
|
mover:ApplyOffsetToTarget(self, dock_pos) |
|
self:SetDockSide(dock_side) |
|
end |
|
end |
|
|
|
function DevDock:OnLayoutComplete() |
|
self:UpdatePopupAnchor() |
|
self.OnLayoutComplete = empty_func |
|
end |
|
|
|
function DevDock:Flash() |
|
if self:IsThreadRunning("Flash") then return end |
|
if self:IsThreadRunning("Notify") then return end |
|
self:CreateThread("Flash", function(self) |
|
local win = self:ResolveId("idArrow") |
|
local original = win:GetBackground() |
|
local interval = 100 |
|
for i=1,5 do |
|
win:SetBackground(black) |
|
Sleep(interval) |
|
win:SetBackground(original) |
|
Sleep(interval) |
|
end |
|
win:SetBackground(original) |
|
end, self) |
|
end |
|
|
|
function DevDock:Notify() |
|
if self:IsThreadRunning("Notify") then return end |
|
if self.popup:GetVisible() then return end |
|
self:CreateThread("Notify", function(self) |
|
local win = self:ResolveId("idArrow") |
|
local original = win:GetBackground() |
|
local interval = 500 |
|
while win.window_state ~= "destroying" do |
|
win:SetBackground(yellow) |
|
Sleep(interval) |
|
win:SetBackground(original) |
|
Sleep(interval) |
|
end |
|
end, self) |
|
end |
|
|
|
function DevDock:OnClick() |
|
local popup = self.popup |
|
local visible = popup:GetVisible() |
|
popup:SetVisible(not visible) |
|
self:UpdatePopupAnchor() |
|
if self.popup:GetVisible() then |
|
if self:IsThreadRunning("Notify") then |
|
self:DeleteThread("Notify") |
|
self:ResolveId("idArrow"):SetBackground(white) |
|
end |
|
end |
|
end |
|
|
|
function DevDock:SnapToEdge(direction) |
|
local mover = self:ResolveId("idMover") |
|
direction = direction or mover.last_delta or point20 |
|
local origin = self.box:Center() |
|
local sx, sy = self.parent.box:sizexyz() |
|
local target |
|
if direction == point20 then |
|
local projections = { |
|
ClosestPtPointSegment(point(0, 0), point(0, sy), origin), |
|
ClosestPtPointSegment(point(0, sy), point(sx, sy), origin), |
|
ClosestPtPointSegment(point(sx, sy), point(sx, 0), origin), |
|
ClosestPtPointSegment(point(sx, 0), point(0, 0), origin), |
|
nil, |
|
} |
|
local min_dist = Max(sx, sy) |
|
for _, p in ipairs(projections) do |
|
local dist = p:SetInvalidZ():Dist2D(origin) |
|
if dist < min_dist then |
|
min_dist = dist |
|
target = p |
|
end |
|
end |
|
else |
|
target = |
|
IntersectRayWithSegment2D(origin, direction, point(0, 0), point(0, sy)) or |
|
IntersectRayWithSegment2D(origin, direction, point(0, sy), point(sx, sy)) or |
|
IntersectRayWithSegment2D(origin, direction, point(sx, sy), point(sx, 0)) or |
|
IntersectRayWithSegment2D(origin, direction, point(sx, 0), point(0, 0)) |
|
end |
|
if not target then |
|
return |
|
end |
|
if target:x() == 0 then self:SetDockSide("left") end |
|
if target:y() == 0 then self:SetDockSide("top") end |
|
if target:x() == sx then self:SetDockSide("right") end |
|
if target:y() == sy then self:SetDockSide("bottom") end |
|
target = target - self.box:size() / 2 |
|
table.set(LocalStorage, "DevDock", "DockPos", target) |
|
local dist = target:Dist2D(origin) |
|
local interpolation = { |
|
id = "SnapToEdge", |
|
type = const.intRect, |
|
originalRect = sizebox(target, self.box:size()), |
|
targetRect = self.box, |
|
duration = direction ~= point20 and Max(500, dist / direction:Len()) or 500, |
|
flags = const.intfInverse, |
|
} |
|
mover:ApplyOffsetToTarget(self, target) |
|
self:AddInterpolation(interpolation) |
|
if not self:IsThreadRunning("UpdatePopupAnchor") then |
|
self:CreateThread("UpdatePopupAnchor", function(self) |
|
Sleep(interpolation.duration) |
|
self:UpdatePopupAnchor() |
|
self.popup:SetVisible(mover.popup_visible_before_drag) |
|
mover.popup_visible_before_drag = nil |
|
end, self) |
|
end |
|
end |
|
|
|
local arrow_props = { |
|
left = { text = ">", h = "right", v = "center" }, |
|
right = { text = "<", h = "left", v = "center" }, |
|
top = { text = "v", h = "center", v = "bottom" }, |
|
bottom = { text = "^", h = "center", v = "top" }, |
|
} |
|
function DevDock:SetDockSide(side) |
|
self.dock_side = side |
|
local arrow = self:ResolveId("idArrow") |
|
arrow:SetText(arrow_props[side].text) |
|
arrow:SetTextHAlign(arrow_props[side].h) |
|
arrow:SetTextVAlign(arrow_props[side].v) |
|
table.set(LocalStorage, "DevDock", "DockSide", side) |
|
end |
|
|
|
local popup_props = { |
|
left = { anchor = "right" }, |
|
right = { anchor = "left" }, |
|
top = { anchor = "bottom" }, |
|
bottom = { anchor = "top" }, |
|
} |
|
function DevDock:UpdatePopupAnchor() |
|
local side = self.dock_side |
|
local popup = self.popup |
|
local anchor = table.get(popup_props, side, "anchor") |
|
popup:SetAnchorType(anchor or "smart") |
|
popup:SetAnchor(self.box) |
|
popup:InvalidateLayout() |
|
end |
|
|
|
function DevDock:MouseInWindow(pt, for_target) |
|
if not for_target then |
|
return true |
|
end |
|
return XDialog.MouseInWindow(self, pt) |
|
end |
|
|
|
function DevDock:GetMouseTarget(pt) |
|
local function get_target(win, pt) |
|
for i,child in ipairs(win) do |
|
local target, cursor = get_target(child, pt) |
|
if target then |
|
return target, cursor |
|
end |
|
end |
|
if win:MouseInWindow(pt, true) then |
|
if IsKindOf(win, "XPopup") then |
|
return win:GetMouseTarget(pt) |
|
elseif IsKindOf(win, "DevDock") then |
|
return XWindow.GetMouseTarget(win, pt) |
|
end |
|
end |
|
end |
|
return get_target(self, pt) |
|
end |
|
|
|
function DevDock:Close() |
|
return XDialog.Close(self) |
|
end |
|
|
|
|
|
|
|
DefineClass.DevDockXTextButton = { |
|
__parents = { "XTextButton" }, |
|
BorderWidth = 1, |
|
BorderColor = RGBA(0, 0, 0, 0), |
|
RolloverTemplate = "GedPropRollover" |
|
} |
|
|
|
DefineClass.DevDockXToggleButton = { |
|
__parents = { "XToggleButton" }, |
|
BorderWidth = 1, |
|
BorderColor = RGBA(0, 0, 0, 0), |
|
ToggledBorderColor = RGB(0, 0, 0), |
|
RolloverTemplate = "GedPropRollover" |
|
} |
|
|
|
DefineClass.DevDockPopup = { |
|
__parents = { "XPopup" }, |
|
IdNode = true, |
|
HandleMouse = true, |
|
LayoutMethod = "VList", |
|
BorderWidth = 1, |
|
BorderColor = black, |
|
|
|
autohide = true, |
|
pinned = false, |
|
dock = false, |
|
plugins = false, |
|
} |
|
|
|
function DevDockPopup:Init() |
|
self.pinned = table.get(LocalStorage, "DevDock", "Pinned") |
|
self:CreateThread("AutoHideThread", function(self) |
|
local desktop = self.desktop |
|
while self.window_state ~= "destroying" do |
|
Sleep(250) |
|
if not self.pinned and self.autohide and self:GetVisible() then |
|
local target = desktop.last_mouse_target or desktop.mouse_capture |
|
if not GetParentOfKind(target, "DevDock") then |
|
self:SetVisible(false) |
|
end |
|
end |
|
end |
|
end, self) |
|
local toolbar = XToolBar:new({ |
|
Toolbar = "toolbar", |
|
Show = "icon", |
|
ButtonTemplate = "DevDockXTextButton", |
|
ToggleButtonTemplate = "DevDockXToggleButton", |
|
FocusOnClick = false, |
|
AutoHide = false, |
|
MaxHeight = 16, |
|
HAlign = "right", |
|
}, self) |
|
self:InitControls() |
|
self:InitPlugins() |
|
end |
|
|
|
function DevDockPopup:InitControls(container) |
|
XAction:new({ |
|
ActionSortKey = "100", |
|
ActionId = "Preferences", |
|
ActionIcon = "CommonAssets/UI/Icons/spanner", |
|
ActionToolbar = "toolbar", |
|
OnAction = function(self, host, source, ...) |
|
host.popup:OpenPreferences(source) |
|
end, |
|
}, self) |
|
XAction:new({ |
|
ActionSortKey = "101", |
|
ActionId = "Pin", |
|
ActionIcon = "CommonAssets/UI/Icons/pin", |
|
ActionToolbar = "toolbar", |
|
ActionToggle = true, |
|
ActionToggled = function(self, host) |
|
return host.popup.pinned |
|
end, |
|
OnAction = function(self, host, source, ...) |
|
local new_pinned = not host.popup.pinned |
|
host.popup.pinned = new_pinned |
|
table.set(LocalStorage, "DevDock", "Pinned", new_pinned) |
|
end, |
|
ActionState = function(self, host) |
|
if not host.popup.autohide then |
|
return "hidden" |
|
end |
|
end, |
|
}, self) |
|
end |
|
|
|
function DevDockPopup:InitPlugins() |
|
self.plugins = {} |
|
self:UpdatePlugins() |
|
end |
|
|
|
function DevDockPopup:UpdatePlugins() |
|
local classes = ClassDescendantsList("DevDockPlugin") |
|
for i, name in ipairs(classes) do |
|
local plugin_class = g_Classes[name] |
|
local is_valid = table.get(LocalStorage, "DevDock", "Plugins", name) and plugin_class:IsValid() |
|
if not self.plugins[name] and is_valid then |
|
local plugin = plugin_class:new({ |
|
dock = self.dock, |
|
}, self) |
|
self.plugins[name] = plugin |
|
if self.window_state ~= "new" then |
|
plugin:Open() |
|
end |
|
elseif self.plugins[name] and not is_valid then |
|
self.plugins[name]:Close() |
|
self.plugins[name] = nil |
|
end |
|
end |
|
|
|
if not next(self.plugins) then |
|
local text = XLabel:new({}, self) |
|
text:SetText(next(classes) and "Check the wrench icon." or "Nothing to see here...") |
|
if self.window_state ~= "new" then |
|
text:Open() |
|
end |
|
self.plugins["__empty"] = text |
|
elseif self.plugins["__empty"] then |
|
self.plugins["__empty"]:Close() |
|
self.plugins["__empty"] = nil |
|
end |
|
end |
|
|
|
function DevDockPopup:OpenPreferences(anchor) |
|
local list = XPopupList:new({ |
|
Anchor = anchor.box, |
|
AnchorType = "smart", |
|
ZOrder = 10, |
|
}, self) |
|
local classes = ClassDescendantsList("DevDockPlugin") |
|
for i, name in ipairs(classes) do |
|
local plugin_class = g_Classes[name] |
|
local checkbox = XCheckButton:new({}, list) |
|
checkbox:SetCheck(table.get(LocalStorage, "DevDock", "Plugins", name)) |
|
local display_name = name |
|
if display_name:starts_with("DevDock") then |
|
display_name = display_name:sub(#"DevDock" + 1) |
|
end |
|
if display_name:ends_with("Plugin") then |
|
display_name = display_name:sub(1, -#"Plugin" - 1) |
|
end |
|
checkbox:SetText(display_name) |
|
function checkbox:OnChange(check) |
|
table.set(LocalStorage, "DevDock", "Plugins", name, check) |
|
GetParentOfKind(self, "DevDockPopup"):UpdatePlugins() |
|
end |
|
end |
|
if not next(classes) then |
|
local text = XLabel:new({}, list) |
|
text:SetText("No plugins available.") |
|
end |
|
list:Open() |
|
end |
|
|
|
function DevDockPopup:SetAutohide(autohide) |
|
self.autohide = autohide |
|
GetActionsHost(self, true):UpdateActionViews() |
|
end |
|
|
|
function DevDockPopup:SetVisible(visible, instant, callback) |
|
table.set(LocalStorage, "DevDock", "Popup", not not visible) |
|
return XPopup.SetVisible(self, visible, instant, callback) |
|
end |
|
|
|
function DevDockPopup:OnKillFocus(new_focus) |
|
return XWindow.OnKillFocus(self, new_focus) |
|
end |
|
|
|
function DevDockPopup:OnMouseButtonDown(pt, button) |
|
return XWindow.OnMouseButtonDown(self, pt, button) |
|
end |
|
|
|
|
|
|
|
DefineClass.DevDockPlugin = { |
|
__parents = { "XWindow", "XActionsHost" }, |
|
HostInParent = true, |
|
dock = false, |
|
} |
|
|
|
function DevDockPlugin.IsValid() |
|
return true |
|
end |
|
|
|
function GetDevDockPlugin(class) |
|
return table.get(GetDialog("DevDock"), "popup", "plugins", class) |
|
end |
|
|
|
|
|
|
|
function OnMsg.DesktopCreated() |
|
if Platform.ged then return end |
|
if not config.DevDock then return end |
|
OpenDialog("DevDock", terminal.desktop, nil, "auto") |
|
end |
|
|
|
local function update_plugins() |
|
local dlg = GetDialog("DevDock") |
|
if not dlg then return end |
|
dlg.popup:UpdatePlugins() |
|
end |
|
OnMsg.ChangeMapDone = update_plugins |
|
OnMsg.PostLoadGame = update_plugins |
|
OnMsg.InGameInterfaceCreated = update_plugins |
|
|
|
function DevDockOpen() |
|
OpenDialog("DevDock", terminal.desktop) |
|
end |
|
|
|
function DevDockClose() |
|
CloseDialog("DevDock") |
|
end |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
