public void SetVisualizing(bool ui, bool drawing)
{
m_IsVisualizingUI = ui;
m_IsVisualizingDrawing = drawing;
if (m_VisualWindow != null)
{
m_VisualWindow.SetActive(ui);
}
else if (ui)
{
m_VisualWindow = new HudWindow(Title);
HudPanel.AddWindow(m_VisualWindow);
}
if ((ui || drawing) && m_Visual == null)
{
m_Visual = GetVisualFactory().GetOrCreateVisual(Topic);
}
if (m_Visual != null)
{
m_Visual.SetDrawingEnabled(drawing);
if (m_VisualWindow != null)
{
m_VisualWindow.SetOnGUI(m_Visual.OnGUI);
}
}
}
public void LoadSaveState(SaveState save)
{
if (m_TopicState.ServiceResponseTopic != null && save.Subtopic == MessageSubtopic.Response)
{
// this save actually applies to the response topic
m_ServiceResponseTopic.LoadSaveState(save);
return;
}
if (save.HasRect && save.Rect.width > 0 && save.Rect.height > 0)
{
m_VisualWindow = new HudWindow(Title, save.Rect);
}
else if (save.ShowWindow)
{
m_VisualWindow = new HudWindow(Title);
}
if (m_VisualWindow != null)
{
HudPanel.AddWindow(m_VisualWindow);
}
SetVisualizing(save.ShowWindow, save.ShowDrawing);
}
private static WindowInteropHelper CreateWindowInteropHelper(HudWindow window, HudLayout hudLayout, IntPtr windowHandle)
{
if (hudLayout.IsSpecialMode)
{
return(new WindowInteropHelper(window));
}
return(new WindowInteropHelper(window)
{
Owner = windowHandle
});
}
/// <summary>
/// Calculates hudElement position in window
/// </summary>
/// <param name="hudElement">HUD element view model</param>
/// <param name="window">Overlay window</param>
/// <returns>Item1 - X, Item2 - Y</returns>
public virtual Tuple <double, double> CalculatePositions(HudBaseToolViewModel toolViewModel, FrameworkElement toolElement, HudWindow window)
{
Check.ArgumentNotNull(() => toolViewModel);
Check.ArgumentNotNull(() => window);
Check.ArgumentNotNull(() => toolElement);
var panelOffset = window.ViewModel.GetPanelOffset(toolViewModel);
var xPosition = panelOffset.X != 0 ? panelOffset.X : toolViewModel.Position.X;
var yPosition = panelOffset.Y != 0 ? panelOffset.Y : toolViewModel.Position.Y;
var scaledXPosition = xPosition * window.ScaleX;
var scaledYPosition = yPosition * window.ScaleY;
// border limits
var toolWidth = toolElement.ActualWidth != 0 && !double.IsNaN(toolElement.ActualWidth) ?
toolElement.ActualWidth :
(!double.IsNaN(toolViewModel.Width) ? toolViewModel.Width : 0);
var toolHeight = toolElement.ActualHeight != 0 && !double.IsNaN(toolElement.ActualHeight) ?
toolElement.ActualHeight :
!double.IsNaN(toolViewModel.Height) ? toolViewModel.Height : 0;
var widthLimit = toolWidth >= HudDefaultSettings.MinimumDistanceToTheBorder ? HudDefaultSettings.MinimumDistanceToTheBorder : toolWidth;
var heightLimit = toolHeight >= HudDefaultSettings.MinimumDistanceToTheBorder ? HudDefaultSettings.MinimumDistanceToTheBorder : toolHeight;
if (toolWidth == 0 || toolWidth >= window.Width ||
widthLimit >= window.Width || toolHeight == 0 ||
toolHeight >= window.Height || (heightLimit + HudDefaultSettings.HudIconHeaderHeight) >= window.Height)
{
return(new Tuple <double, double>(scaledXPosition, scaledYPosition));
}
if (scaledXPosition > window.Width - widthLimit)
{
scaledXPosition = window.Width - widthLimit;
toolViewModel.OffsetX = window.ScaleX != 0 ? scaledXPosition / window.ScaleX : toolViewModel.OffsetX;
}
else if (scaledXPosition < widthLimit - toolWidth)
{
scaledXPosition = widthLimit - toolWidth;
toolViewModel.OffsetX = widthLimit - toolWidth;
}
if (scaledYPosition > window.Height - heightLimit - HudDefaultSettings.HudIconHeaderHeight)
{
scaledYPosition = window.Height - heightLimit - HudDefaultSettings.HudIconHeaderHeight;
toolViewModel.OffsetY = window.ScaleY != 0 ?
((window.Height - heightLimit) / window.ScaleY - HudDefaultSettings.HudIconHeaderHeight) :
toolViewModel.OffsetY;
}
else if (scaledYPosition < heightLimit - toolHeight - HudDefaultSettings.HudIconHeaderHeight)
{
scaledYPosition = heightLimit - toolHeight - HudDefaultSettings.HudIconHeaderHeight;
toolViewModel.OffsetY = heightLimit - toolHeight - HudDefaultSettings.HudIconHeaderHeight;
}
return(new Tuple <double, double>(scaledXPosition, scaledYPosition));
}
/// <summary>
/// Calculates y-scale for the specified window
/// </summary>
/// <param name="window">Window to calculate y-scale</param>
/// <returns>Y-scale</returns>
public virtual double GetScaleY(HudWindow window)
{
return(window.Height / InitialTableSize.Y);
}
/// <summary>
/// Calculates x-scale for the specified window
/// </summary>
/// <param name="window">Window to calculate x-scale</param>
/// <returns>X-scale</returns>
public virtual double GetScaleX(HudWindow window)
{
return(window.Width / InitialTableSize.X);
}
private static void CreateHudWindow(IntPtr hwnd, HudLayout hudLayout)
{
var thread = new Thread(() =>
{
try
{
var hudPanelService = ServiceLocator.Current.GetInstance <IHudPanelService>(hudLayout.PokerSite.ToString());
var window = new HudWindow();
var windowHandle = hudPanelService.GetWindowHandle(hwnd);
if (!WinApi.IsWindow(windowHandle))
{
LogProvider.Log.Info(typeof(HudPainter), $"Window {windowHandle} doesn't exist. HUD window can't be created.");
return;
}
var windowInteropHelper = CreateWindowInteropHelper(window, hudLayout, hwnd);
var windowItem = new HudWindowItem
{
Window = window,
Handle = windowHandle,
OverlayHandle = windowInteropHelper.EnsureHandle()
};
using (rwWindowsLock.Write())
{
if (windows.ContainsKey(hwnd))
{
return;
}
windows.Add(hwnd, windowItem);
}
window.Closed += (s, e) => window.Dispatcher.InvokeShutdown();
window.Initialize(hudLayout, hwnd);
window.Show();
WinApi.GetWindowRect(windowHandle, out RECT rect);
SizeF dpi = Utils.GetCurrentDpi();
SizeF scale = new SizeF()
{
Width = 96f / dpi.Width,
Height = 96f / dpi.Height
};
window.Top = rect.Top * scale.Height;
window.Left = rect.Left * scale.Width;
window.Height = rect.Height * scale.Height;
window.Width = rect.Width * scale.Width;
windowItem.IsInitialized = true;
PrepareWindow(windowItem, hudLayout, hwnd);
if (!WinApi.IsIconic(hwnd))
{
window.Refresh();
}
// workaround for unresponsive PB window after attaching HUD
if (hudLayout.PokerSite == EnumPokerSites.PokerBaazi)
{
WinApi.GetWindowRect(hwnd, out RECT rct);
WinApi.SetWindowPos(hwnd, IntPtr.Zero, 0, 0, rct.Width + 1, rct.Height + 1, Swp.NOMOVE | Swp.NOZORDER | Swp.NOACTIVATE);
WinApi.SetWindowPos(hwnd, IntPtr.Zero, 0, 0, rct.Width, rct.Height, Swp.NOMOVE | Swp.NOZORDER | Swp.NOACTIVATE);
}
System.Windows.Threading.Dispatcher.Run();
}
catch (Exception e)
{
LogProvider.Log.Error(typeof(HudPainter), $"Failed to create HUD window for {hwnd}", e);
}
});
thread.SetApartmentState(ApartmentState.STA);
thread.Start();
}
public Plugin()
{
_pluginConfiguration = (PluginConfiguration)(PluginInterface.GetPluginConfig() ?? new PluginConfiguration());
PluginInterface.UiBuilder.BuildFonts += UiBuilderOnBuildFonts;
PluginInterface.UiBuilder.RebuildFonts();
_hudWindowWindow = new HudWindow(_pluginConfiguration);
_configurationWindow = new ConfigurationWindow(this, _pluginConfiguration);
var items = new[]
{
"CleanCurves",
"GlowArc",
"RivetBar"
};
foreach (var item in items)
{
LoadStyle(item, Path.Combine(PluginInterface.AssemblyLocation.DirectoryName !, "Styles"), false);
}
if (!string.IsNullOrEmpty(_pluginConfiguration.UserStylePath))
{
if (!Directory.Exists(_pluginConfiguration.UserStylePath))
{
PluginLog.Error($"{_pluginConfiguration.UserStylePath} was not found.");
}
else
{
foreach (var item in Directory.GetDirectories(_pluginConfiguration.UserStylePath))
{
LoadStyle(item, _pluginConfiguration.UserStylePath, true);
}
}
}
if (_pluginConfiguration.IsUserStyle && !UserStyles.ContainsKey(_pluginConfiguration.SelectedStyle))
{
_pluginConfiguration.IsUserStyle = false;
_pluginConfiguration.SelectedStyle = items[0];
_pluginConfiguration.Save();
}
if (_pluginConfiguration.IsUserStyle)
{
_pluginConfiguration.BarImage = UserStyles[_pluginConfiguration.SelectedStyle][0];
_pluginConfiguration.BarBackgroundImage =
UserStyles[_pluginConfiguration.SelectedStyle][1];
_pluginConfiguration.BarCastImage = UserStyles[_pluginConfiguration.SelectedStyle][2];
_pluginConfiguration.BarCastBackgroundImage =
UserStyles[_pluginConfiguration.SelectedStyle][3];
}
else
{
_pluginConfiguration.BarImage = Styles[_pluginConfiguration.SelectedStyle][0];
_pluginConfiguration.BarBackgroundImage =
Styles[_pluginConfiguration.SelectedStyle][1];
_pluginConfiguration.BarCastImage = Styles[_pluginConfiguration.SelectedStyle][2];
_pluginConfiguration.BarCastBackgroundImage =
Styles[_pluginConfiguration.SelectedStyle][3];
}
CommandManager.AddHandler("/pside", new CommandInfo(PluginCommand)
{
HelpMessage = "Opens configuration window",
ShowInHelp = true
});
PluginInterface.UiBuilder.Draw += UiBuilderOnOnBuildUi;
PluginInterface.UiBuilder.OpenConfigUi += UiBuilderOnOnOpenConfigUi;
}
/// <summary>
/// Calculates x-scale for the specified Winamax windowk
/// </summary>
/// <param name="window"></param>
/// <returns></returns>
public override double GetScaleX(HudWindow window)
{
return(base.GetScaleY(window));
}
