public bool posizionaFinestraPubblico()
{
// carico la eventuale geometria salvata nella configurazione
// _pubblicoWindow.posizionamentoInCorso = true;
// Come concordato con Ciccio, la finestra pubblico deve avere la stessa posizione di quella dello Slide Show
// Quindi non ha una sua propria configurazione.
GeometriaFinestra geomPub = (geomSS == null || geomSS.isEmpty()) ? Configurazione.creaGeometriaSlideShowDefault() : geomSS;
// Primo tentativo
bool esito;
esito = posizionaFinestra(_pubblicoWindow, geomPub);
// Secondo tentativo con default
if (!esito)
{
geomPub = Configurazione.creaGeometriaSlideShowDefault();
esito = posizionaFinestra(_pubblicoWindow, geomPub);
}
// _pubblicoWindow.posizionamentoInCorso = false;
return(esito);
}
/// <summary>
/// Posiziono la finestra e la ridimensiono, per come indicato nella nuova geometria desiderata.
/// Verifico anche che la geometria indicata sia proiettabile nello schermo (quindi che si interna)
/// Per gestire lo stato di massimizzato, vedere descrizione qui:
/// https://social.msdn.microsoft.com/Forums/vstudio/en-US/2ca2fab6-b349-4c08-915f-373c71bd636a/show-and-maximize-wpf-window-on-a-specific-screen?forum=wpf
/// In pratica:
/// in prima battuta visualizzo la finestra in stato normal. Poi dopo che questa si è caricata e visualizzata,
/// tramite un evento, faccio chiamare una routine che la rende massimizzata.
/// </summary>
/// <param name="window">La finestra da ridimensionare/spostare</param>
/// <param name="newGoem">La nuova posizione e dimensione desiderata</param>
/// <returns>true se operazione a buon fine. false se condizioni errate</returns>
public static bool posizionaFinestra(Window window, GeometriaFinestra newGoem)
{
bool esito = verificaProiettabile(newGoem);
if (esito)
{
try {
// In prima battuta, devo visualizzare la finestra in stato normal
window.WindowState = WindowState.Normal;
// Nessun intervento di centratura automatico. Faccio tutto io manualmente su tutti i parametri
window.WindowStartupLocation = WindowStartupLocation.Manual;
// Screen[] _screens = Screen.AllScreens;
// System.Drawing.Rectangle rectangle1 = _screens[newGoem.deviceEnum].Bounds;
// System.Drawing.Rectangle rectangle2 = _screens[newGoem.deviceEnum].WorkingArea;
window.Left = newGoem.Left;
window.Top = newGoem.Top;
window.Width = newGoem.Width;
window.Height = newGoem.Height;
if (newGoem.fullScreen)
{
window.Loaded += Window_Loaded_posizionaFinestraFullScreen;
}
esito = true;
} catch (Exception) {
esito = false;
}
}
return(esito);
}
/// <summary>
/// Posiziono la finestra dello slide show sul monitor primario,
/// con una dimensione che sicuramente è visibile (cioè con una geometria di default)
/// </summary>
internal void normalizzareFinestraSlideShowSulMonitor1()
{
// Per prima cosa apro la finestra se questa è chiusa
aprireFinestraSlideShow();
// Creo una geometria dalle dimensioni del monitor.
GeometriaFinestra geo = Configurazione.creaGeometriaSlideShowDefault();
posizionaFinestra(_slideShowWindow, geo);
}
/// <summary>
/// Uso lo schermo indicato nella geometria stessa
/// </summary>
/// <param name="geom"></param>
/// <returns></returns>
public static bool verificaProiettabile(GeometriaFinestra geom)
{
// Verifico se lo schermo indicato esiste ancora. Potrebbe essere stato scollegato
if (geom.deviceEnum >= 0 && geom.deviceEnum < Screen.AllScreens.Count())
{
return(verificaProiettabile(WpfScreen.GetScreenFrom(geom.deviceEnum), geom));
}
else
{
return(false);
}
}
/// <summary>
/// Controllo se la geometria indicata è "interna" allo schermo indicato.
///
/// </summary>
/// <param name="scr">Schermo su cui disegnare. Esiste di sicuro</param>
/// <param name="gf">Geometria della finestra da aprire nello schermo</param>
/// <returns>true se la finestra è interna allo schermo (quindi ci sta)</returns>
public static bool verificaProiettabile(WpfScreen scr, GeometriaFinestra gf)
{
bool proiettabile = true;
if (gf.fullScreen)
{
return(true);
}
if (proiettabile && gf.isEmpty())
{
proiettabile = false;
}
if (proiettabile && gf.Left < 0)
{
proiettabile = false;
}
if (proiettabile && gf.Top < 0)
{
proiettabile = false;
}
if (proiettabile && gf.Width <= 10)
{
proiettabile = false;
}
if (proiettabile && gf.Height <= 10)
{
proiettabile = false;
}
if (proiettabile && gf.deviceEnum == WpfScreen.Primary.deviceEnum && (gf.Height + gf.Top > scr.WorkingArea.Height || gf.Width + gf.Left > scr.WorkingArea.Width))
{
proiettabile = false;
}
if (proiettabile && gf.deviceEnum != WpfScreen.Primary.deviceEnum && (gf.Height + gf.Top - scr.DeviceBounds.Y > scr.WorkingArea.Height || gf.Width + gf.Left - scr.DeviceBounds.X > scr.WorkingArea.Width))
{
proiettabile = false;
}
return(proiettabile);
}
/// <summary>
/// Data una Window, estraggo i dati del suo posizionamento.
/// </summary>
/// <param name="window">La finestra da analizzare</param>
/// <returns>La Geometria che rappresenta la sua posizione</returns>
public static GeometriaFinestra creaGeometriaDaWindow(Window window)
{
WpfScreen scr = WpfScreen.GetScreenFrom(window);
GeometriaFinestra geo = new GeometriaFinestra();
geo.Left = (int)window.Left;
geo.Top = (int)window.Top;
// In certi casi il valore è NaN
// http://stackoverflow.com/questions/11013316/get-the-height-width-of-window-wpf
if (Double.IsNaN(window.Width))
{
geo.Width = (int)window.ActualWidth;
}
else
{
geo.Width = (int)window.Width;
}
// In certi casi il valore è NaN
// http://stackoverflow.com/questions/11013316/get-the-height-width-of-window-wpf
if (Double.IsNaN(window.Height))
{
geo.Height = (int)window.ActualHeight;
}
else
{
geo.Height = (int)window.Height;
}
geo.Height = (int)window.Height;
geo.Width = (int)window.Width;
geo.fullScreen = window.WindowState == WindowState.Maximized;
geo.deviceEnum = scr.deviceEnum;
return(geo);
}
/// <summary>
/// Massimizzo la finestra indicata sul monitor secondario
/// </summary>
internal void massimizzareFinestraSlideShowSulMonitor2()
{
// Adesso calcolo la posizione del monitor 2
WpfScreen scrn = WpfScreen.AllScreens().Where(s => s.IsPrimary == false).FirstOrDefault();
if (scrn != null)
{
// Per prima cosa apro la finestra se questa è chiusa
aprireFinestraSlideShow();
// Creo una geometria dalle dimensioni del monitor.
GeometriaFinestra geo = creaGeometriaDaScreen(scrn);
posizionaFinestra(_slideShowWindow, geo);
massimizzareFinestraSlideShow();
}
else
{
_giornale.Warn("E' stato chiesto di usare il monitor secondario ma questo non è presente");
}
}
