public NativeStructs.WINDOWPLACEMENT? Load(Window rpWindow)
{
var rPlacement = Preference.Instance.Windows.LoadPlacement(rpWindow.GetType().FullName);
if (rPlacement == null)
return null;
var rResult = new NativeStructs.WINDOWPLACEMENT()
{
rcNormalPosition = new NativeStructs.RECT(rPlacement.Left, rPlacement.Top, rPlacement.Left+rPlacement.Width,rPlacement.Top+rPlacement.Height),
};
switch (rPlacement.State)
{
case WindowState.Normal:
rResult.showCmd = NativeConstants.ShowCommand.SW_SHOWNORMAL;
break;
case WindowState.Minimized:
rResult.showCmd = NativeConstants.ShowCommand.SW_SHOWMINIMIZED;
break;
case WindowState.Maximized:
rResult.showCmd = NativeConstants.ShowCommand.SW_SHOWMAXIMIZED;
break;
}
return rResult;
}
private static void PickleWindow(Window window, Dictionary<string, object> data)
{
foreach (var propName in new[] { "Top", "Left", "Width", "Height", "WindowState" })
{
data[propName] = window.GetType().GetProperty(propName).GetGetMethod().Invoke(window, new object[] { });
}
}
public WindowSettings(Window window, bool isSavingPosition, bool isSavingSize, string keyExtensionValue)
{
_window = window;
_isSavingPosition = isSavingPosition;
_isSavingSize = isSavingSize;
// Use the class-name of the given Window, minus the namespace prefix, as the instance-key.
// This is so that we have a distinct setting for different windows.
string sWindowType = window.GetType().ToString();
int iPos = sWindowType.LastIndexOf('.');
string sKey;
if (iPos > 0)
{
sKey = sWindowType.Substring(iPos + 1);
}
else
{
sKey = sWindowType;
}
if (keyExtensionValue == null)
{
_sInstanceSettingsKey = sKey;
}
else
{
_sInstanceSettingsKey = sKey + keyExtensionValue;
}
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="mWindow"></param>
public Service(System.Windows.Window mWindow)
{
if (mWindow.GetType() == typeof(MainWindow))
{
WinMainWindow = (MainWindow)mWindow;
}
updatePbDelegate = new UpdateProgressBarDelegate(WinMainWindow.pb1.SetValue);
}
public MoveCommandBindingProxy(Window window)
{
this.window = window;
MoveCommand = new RoutedCommand("Move", window.GetType());
_CommandBinding = new CommandBinding(MoveCommand,
CommandExecuted,
CommandCanExecute);
}
public Service(System.Windows.Window mWindow)
{
modelDB = new Model1();
modelDB.Employee.Load();
modelDB.Department.Load();
if (mWindow.GetType() == typeof(MainWindow))
{
WinMainWindow = (MainWindow)mWindow;
}
}
private static void InitWindow(Window window, Dictionary<string, object> data)
{
foreach (var property in data)
{
window.GetType().GetProperty(property.Key).GetSetMethod().Invoke(window, new[] { property.Value });
}
if (!Double.IsNaN(window.Top))
window.WindowStartupLocation = WindowStartupLocation.Manual;
}
/// <summary>
///
/// </summary>
/// <param name="mWindow"></param>
/// <param name="adapterEmp"></param>
/// <param name="dtEmp"></param>
/// <param name="adapterDep"></param>
/// <param name="dtDep"></param>
public Service(System.Windows.Window mWindow, SqlDataAdapter adapterEmp, DataTable dtEmp, SqlDataAdapter adapterDep, DataTable dtDep)
{
if (mWindow.GetType() == typeof(MainWindow))
{
WinMainWindow = (MainWindow)mWindow;
}
dtE = dtEmp;
dtD = dtDep;
adapterE = adapterEmp;
adapterD = adapterDep;
}
public WindowTreeManager(Window window, WindowTreeManager parent, bool autoClosing = true)
{
Parent = parent;
_window = window;
_autoClosing = autoClosing;
var windowName = window.GetType().Name;
_windowBoundsPersistor = new Settings.WindowBoundsPersistor(window, windowName);
_windowBoundsPersistor.Load();
window.Closing += SelfClosing;
}
public void Save(Window rpWindow, NativeStructs.WINDOWPLACEMENT rpData)
{
var rPreference = new WindowPreference()
{
Name = rpWindow.GetType().FullName,
Left = rpData.rcNormalPosition.Left,
Top = rpData.rcNormalPosition.Top,
Width = rpData.rcNormalPosition.Right - rpData.rcNormalPosition.Left,
Height = rpData.rcNormalPosition.Bottom - rpData.rcNormalPosition.Top,
State = rpWindow.WindowState,
};
Preference.Current.Windows.Landscape[rPreference.Name] = rPreference;
}
public static void OuvrirEcran(Window parent,string nom,bool modal,bool fermeParent)
{
Type type = parent.GetType();
Assembly assembly = type.Assembly;
Window win = (Window)assembly.CreateInstance(type.Namespace + "." + nom);
if (fermeParent)
parent.Close();
if (modal)
win.ShowDialog();
else
win.Show();
}
/// <summary>
/// Opens a window and returns without waiting for the newly opened window to close.
/// </summary>
/// <param name="window">The window.</param>
/// <param name="owner">The owner.</param>
/// <param name="singleton">if set to <c>true</c> only once instance of the window will be shown.</param>
public static void Show(this Window window, IntPtr owner, bool singleton)
{
if (singleton)
{
if (!Windows.ContainsKey(window.GetType().Name))
{
window.Show(owner);
window.Closed += (sender, args) =>
{
Windows.Remove(window.GetType().Name);
};
Windows.Add(window.GetType().Name, window);
}
else
{
Windows[window.GetType().Name].Show(owner);
}
}
else
{
window.Show(owner);
}
}
public void Save(Window rpWindow, NativeStructs.WINDOWPLACEMENT rpData)
{
var rPreference = new WindowPreference()
{
Name = rpWindow.GetType().FullName,
Left = rpData.rcNormalPosition.Left,
Top = rpData.rcNormalPosition.Top,
Width = rpData.rcNormalPosition.Right - rpData.rcNormalPosition.Left,
Height = rpData.rcNormalPosition.Bottom - rpData.rcNormalPosition.Top,
State = rpWindow.WindowState,
};
Preference.Instance.Windows.SavePlacement(rPreference);
}
public void ManageWindowSettings(Window window)
{
string typeName = window.GetType().Name;
window.Initialized += (sender, e) =>
{
WindowSettings settings = this.Settings.WindowsSettings.Where(w => w.Name == typeName).FirstOrDefault();
if (settings != null)
{
window.Left = settings.X;
window.Top = settings.Y;
window.Width = settings.Width;
window.Height = settings.Height;
window.WindowState = settings.State;
window.WindowStartupLocation = WindowStartupLocation.Manual;
}
};
window.Closing += WindowClosing;
}
public static void SavePreferences(Window win)
{
WindowPreference wp = new WindowPreference();
wp.Width = win.Width;
wp.Height = win.Height;
wp.Top = win.Top;
wp.Left = win.Left;
preferences[win.GetType().Name] = wp;
}
/// <summary>
/// Sets the owner window of a specific window. It will first try to set the owner via
/// the <paramref name="ownerWindow"/>. If the <paramref name="ownerWindow"/> is not available,
/// this method will use the <paramref name="ownerHandle"/> to set the parent.
/// </summary>
/// <param name="window">Reference to the current window.</param>
/// <param name="ownerWindow">New owner window.</param>
/// <param name="ownerHandle">The owner handle.</param>
/// <param name="forceNewOwner">If true, the new owner will be forced. Otherwise, if the
/// window currently has an owner, that owner will be respected (and thus not changed).</param>
/// <param name="focusFirstControl">If true, the first control will automatically be focused.</param>
private static void SetOwnerWindow(SystemWindow window, SystemWindow ownerWindow, IntPtr ownerHandle, bool forceNewOwner, bool focusFirstControl)
{
if (focusFirstControl)
{
window.FocusFirstControl();
}
if (!forceNewOwner && HasOwner(window))
{
return;
}
try
{
if (ownerWindow != null)
{
if (ReferenceEquals(ownerWindow, window))
{
Log.Warning("Cannot set owner window to itself, no owner window set");
return;
}
if (window.Dispatcher.GetThreadId() != ownerWindow.Dispatcher.GetThreadId())
{
Log.Warning("The owner window '{0}' is not created on the same thread as the current window '{1}', cannot set owner window",
ownerWindow.GetType().GetSafeFullName(false), window.GetType().GetSafeFullName(false));
return;
}
window.Owner = ownerWindow;
}
else
{
// Set owner via interop helper
var interopHelper = new WindowInteropHelper(window);
interopHelper.Owner = ownerHandle;
// Get handler (so we can nicely unsubscribe)
RoutedEventHandler onWindowLoaded = null;
onWindowLoaded = delegate(object sender, RoutedEventArgs e)
{
// Since this owner type doesn't support WindowStartupLocation.CenterOwner, do
// it manually
if (window.WindowStartupLocation == WindowStartupLocation.CenterOwner)
{
// Get the parent window rect
RECT ownerRect;
if (GetWindowRect(ownerHandle, out ownerRect))
{
// Get some additional information
int ownerWidth = ownerRect.Right - ownerRect.Left;
int ownerHeight = ownerRect.Bottom - ownerRect.Top;
int ownerHorizontalCenter = (ownerWidth / 2) + ownerRect.Left;
int ownerVerticalCenter = (ownerHeight / 2) + ownerRect.Top;
// Set the location to manual
window.WindowStartupLocation = WindowStartupLocation.Manual;
// Now we know the location of the parent, center the window
window.Left = ownerHorizontalCenter - (window.ActualWidth / 2);
window.Top = ownerVerticalCenter - (window.ActualHeight / 2);
}
}
((SystemWindow)sender).Loaded -= onWindowLoaded;
};
window.Loaded += onWindowLoaded;
}
}
catch (Exception ex)
{
Log.Error(ex, "Failed to set the owner window");
}
}
private bool WindowIsNotWorkbench(Window w)
{
return !w.GetType().Equals(typeof(WorkbenchWindow));
}
// Various dialogs perform a bulk edit, after which the current file's data needs to be refreshed.
private async Task ShowBulkFileEditDialogAsync(Window dialog)
{
Debug.Assert((dialog.GetType() == typeof(PopulateFieldWithMetadata)) ||
(dialog.GetType() == typeof(DateTimeFixedCorrection)) ||
(dialog.GetType() == typeof(DateTimeLinearCorrection)) ||
(dialog.GetType() == typeof(DateDaylightSavingsTimeCorrection)) ||
(dialog.GetType() == typeof(DateCorrectAmbiguous)) ||
(dialog.GetType() == typeof(DateTimeSetTimeZone)) ||
(dialog.GetType() == typeof(DateTimeRereadFromFiles)),
String.Format("Unexpected dialog {0}.", dialog.GetType()));
bool? result = dialog.ShowDialog();
if (result == true)
{
// load the changes made through the current dialog
long currentFileID = this.dataHandler.ImageCache.Current.ID;
this.dataHandler.FileDatabase.SelectFiles(this.dataHandler.FileDatabase.ImageSet.FileSelection);
// show updated data for file
// Delete isn't considered a bulk edit so none of the bulk edit dialogs can result in a change in the image which needs to be displayed.
// Hence the image cache doesn't need to be invalidated. However, SelectFiles() may mean the currently displayed file is no longer selected.
await this.ShowFileAsync(this.dataHandler.FileDatabase.GetFileOrNextFileIndex(currentFileID));
}
}
public static void LoadPreferences(Window win)
{
string name = win.GetType().Name;
WindowPreference wp = preferences[name];
win.Width = wp.Width;
win.Height = wp.Height;
win.Top = wp.Top;
win.Left = wp.Left;
}
internal int RunInternal(Window window)
{
VerifyAccess();
#if DEBUG_CLR_MEM
if (CLRProfilerControl.ProcessIsUnderCLRProfiler &&
(CLRProfilerControl.CLRLoggingLevel >= CLRProfilerControl.CLRLogState.Performance))
{
CLRProfilerControl.CLRLogWriteLine("Application_Run");
}
#endif // DEBUG_CLR_MEM
EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordGeneral | EventTrace.Keyword.KeywordPerf, EventTrace.Event.WClientAppRun);
//
// NOTE: hamidm 08/06/04
// PS Windows OS Bug # 901085 (Can't create app and do run/shutdown followed
// by run/shutdown)
//
// Devs could write the following code
//
// Application app = new Application();
// app.Run();
// app.Run();
//
// In this case, we should throw an exception when Run is called for the second time.
// When app is shutdown, _appIsShutdown is set to true. If it is true here, then we
// throw an exception
if (_appIsShutdown == true)
{
throw new InvalidOperationException(SR.Get(SRID.CannotCallRunMultipleTimes, this.GetType().FullName));
}
if (window != null)
{
if (window.CheckAccess() == false)
{
throw new ArgumentException(SR.Get(SRID.WindowPassedShouldBeOnApplicationThread, window.GetType().FullName, this.GetType().FullName));
}
if (WindowsInternal.HasItem(window) == false)
{
WindowsInternal.Add(window);
}
if (MainWindow == null)
{
MainWindow = window;
}
if (window.Visibility != Visibility.Visible)
{
Dispatcher.BeginInvoke(
DispatcherPriority.Send,
(DispatcherOperationCallback) delegate(object obj)
{
Window win = obj as Window;
win.Show();
return null;
},
window);
}
}
EnsureHwndSource();
//Even if the subclass app cancels the event we still want to create and run the dispatcher
//so that when the app explicitly calls Shutdown, we have a dispatcher to service the posted
//Shutdown DispatcherOperationCallback
// Invoke the Dispatcher synchronously if we are not in the browser
if (!BrowserInteropHelper.IsBrowserHosted)
{
RunDispatcher(null);
}
return _exitCode;
}
/// <summary>
/// Sets/gets the active window for the tray manager.
/// This will be expanded to multiple windows in the future
/// </summary>
public void addActiveWindow(Window value)
{
if (!TrayFlags.containsType(value.GetType())) return;
activeWindow.Add(value);
}
public WindowApplicationSettings(Window window)
: base(window.GetType().FullName)
{
}
public WindowSettings(Window window)
: base(window.GetType().FullName)
{
}
public void ShowWindow(Window window)
{
var containsLayoutStores = window as IContainsLayoutStores;
IList<ILayoutDataStore> layoutDataStores = new List<ILayoutDataStore>();
if (containsLayoutStores != null)
layoutDataStores = containsLayoutStores.GetLayoutStores();
if (string.IsNullOrEmpty(window.Name))
{
var type = window.GetType();
//???? ??????? ???????????, ? Name ?? ????? - ?? ??????????? ??? ????
window.Name = type.Namespace.StartsWith("System.") ? null : type.Name;
}
if (string.IsNullOrEmpty(window.Name))
throw new ArgumentException(Resources.ControlNameCanNotBeEmpty);
var worker = new LayoutStoreWorker(layoutDataStorePathFactory, window.Name, layoutDataStores);
LayoutStoreSupportUtils.Load(worker);
window.Closing += (s, e) => LayoutStoreSupportUtils.Close(worker);
window.Show();
}
// ----------------------------------------------------------------------
public WindowSettings(Window window) :
this(window, window.GetType().Name)
{
} // WindowSettings
private Point ConfigureNewHostSizeAndGetDragStartWindowOffset(Window currentWindow, INewTabHost<Window> newTabHost, DragablzItem dragablzItem)
{
var layout = this.VisualTreeAncestory().OfType<Layout>().FirstOrDefault();
Point dragStartWindowOffset;
if (layout != null)
{
newTabHost.Container.Width = ActualWidth + Math.Max(0, currentWindow.RestoreBounds.Width - layout.ActualWidth);
newTabHost.Container.Height = ActualHeight + Math.Max(0, currentWindow.RestoreBounds.Height - layout.ActualHeight);
dragStartWindowOffset = dragablzItem.TranslatePoint(new Point(), this);
//dragStartWindowOffset.Offset(currentWindow.RestoreBounds.Width - layout.ActualWidth, currentWindow.RestoreBounds.Height - layout.ActualHeight);
}
else
{
if (newTabHost.Container.GetType() == currentWindow.GetType())
{
newTabHost.Container.Width = currentWindow.RestoreBounds.Width;
newTabHost.Container.Height = currentWindow.RestoreBounds.Height;
dragStartWindowOffset = dragablzItem.TranslatePoint(new Point(), currentWindow);
}
else
{
newTabHost.Container.Width = ActualWidth;
newTabHost.Container.Height = ActualHeight;
dragStartWindowOffset = dragablzItem.TranslatePoint(new Point(), this);
dragStartWindowOffset.Offset(dragablzItem.MouseAtDragStart.X, dragablzItem.MouseAtDragStart.Y);
return dragStartWindowOffset;
}
}
dragStartWindowOffset.Offset(dragablzItem.MouseAtDragStart.X, dragablzItem.MouseAtDragStart.Y);
var borderVector = currentWindow.WindowState == WindowState.Maximized
? currentWindow.PointToScreen(new Point()).ToWpf() - new Point()
: currentWindow.PointToScreen(new Point()).ToWpf() - new Point(currentWindow.Left, currentWindow.Top);
dragStartWindowOffset.Offset(borderVector.X, borderVector.Y);
return dragStartWindowOffset;
}
/// <summary>
/// Sets the owner window of a specific window. It will first try to set the owner via
/// the <paramref name="ownerWindow"/>. If the <paramref name="ownerWindow"/> is not available,
/// this method will use the <paramref name="ownerHandle"/> to set the parent.
/// </summary>
/// <param name="window">Reference to the current window.</param>
/// <param name="ownerWindow">New owner window.</param>
/// <param name="ownerHandle">The owner handle.</param>
/// <param name="forceNewOwner">If true, the new owner will be forced. Otherwise, if the
/// window currently has an owner, that owner will be respected (and thus not changed).</param>
/// <param name="focusFirstControl">If true, the first control will automatically be focused.</param>
private static void SetOwnerWindow(SystemWindow window, SystemWindow ownerWindow, IntPtr ownerHandle, bool forceNewOwner, bool focusFirstControl)
{
if (focusFirstControl)
{
window.FocusFirstControl();
}
if (!forceNewOwner && HasOwner(window))
{
return;
}
try
{
if (ownerWindow != null)
{
if (ReferenceEquals(ownerWindow, window))
{
Log.Warning("Cannot set owner window to itself, no owner window set");
return;
}
if (window.Dispatcher.GetThreadId() != ownerWindow.Dispatcher.GetThreadId())
{
Log.Warning("The owner window '{0}' is not created on the same thread as the current window '{1}', cannot set owner window",
ownerWindow.GetType().GetSafeFullName(false), window.GetType().GetSafeFullName(false));
return;
}
window.Owner = ownerWindow;
}
else
{
// Set owner via interop helper
var interopHelper = new WindowInteropHelper(window);
interopHelper.Owner = ownerHandle;
// Get handler (so we can nicely unsubscribe)
RoutedEventHandler onWindowLoaded = null;
onWindowLoaded = delegate(object sender, RoutedEventArgs e)
{
// Since this owner type doesn't support WindowStartupLocation.CenterOwner, do
// it manually
if (window.WindowStartupLocation == WindowStartupLocation.CenterOwner)
{
// Get the parent window rect
RECT ownerRect;
if (GetWindowRect(ownerHandle, out ownerRect))
{
// Get some additional information
int ownerWidth = ownerRect.Right - ownerRect.Left;
int ownerHeight = ownerRect.Bottom - ownerRect.Top;
int ownerHorizontalCenter = (ownerWidth / 2) + ownerRect.Left;
int ownerVerticalCenter = (ownerHeight / 2) + ownerRect.Top;
// Set the location to manual
window.WindowStartupLocation = WindowStartupLocation.Manual;
// Now we know the location of the parent, center the window
window.Left = ownerHorizontalCenter - (window.ActualWidth / 2);
window.Top = ownerVerticalCenter - (window.ActualHeight / 2);
}
}
((SystemWindow)sender).Loaded -= onWindowLoaded;
};
window.Loaded += onWindowLoaded;
}
}
catch (Exception ex)
{
Log.Error(ex, "Failed to set the owner window");
}
}
