/// <summary>
/// 编辑
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void StackPanel_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
CarPortTimeExtension carPortTimeExtension = new CarPortTimeExtension(_carPortAppService, _mainWindowViewModel, _userManagerViewModel, _carPortListDto);
var result = carPortTimeExtension.ShowDialog();
if (result.HasValue && result.Value)
{
RoutedEventHandler?.Invoke(sender, e);
}
}
private void SavePosition(object sender, RoutedEventArgs e)
{
using (SqlConnection conn = new SqlConnection(connection))
{
conn.Open();
int posId = GetPositionID(positionTB.Text);
if (posId == -1)
{
//Добавить новую
string command = $"exec [dbo].[insertPosition] \'{positionTB.Text}\'";
SqlDataAdapter sda = new SqlDataAdapter(command, conn);
DataSet ds = new();
sda.Fill(ds);
posId = int.Parse(ds.Tables[0].Rows[0].ItemArray[0].ToString());
command = $"insert into [dbo].[workers_position] values({workerId}, {posId})";
SqlCommand com = new SqlCommand(command, conn);
com.ExecuteNonQuery();
}
else
{
//Добавить имеющуюся
string command = $"insert into [dbo].[workers_position] values({workerId}, {posId})";
SqlCommand com = new SqlCommand(command, conn);
com.ExecuteNonQuery();
}
conn.Close();
}
addPositionDialog.IsOpen = false;
workerSelectedDelegate?.Invoke(workerSelectedSender, workerSelectedArgs);
}
/// <summary>
/// NOTE: IsCheckable seems to bugged. The inverted value counts!
/// </summary>
public static void AddMenueItem(this ContextMenu contextMenu, string header, RoutedEventHandler eventHandler = null, bool isChecked = false, bool isCheckable = true)
{
var menuItem = new MenuItem()
{
Header = header,
IsChecked = isChecked,
// NOTE: IsCheckable seems to bugged. The inverted value counts!
IsCheckable = isCheckable,
};
menuItem.Click += (sender, e) =>
{
if (menuItem.IsCheckable)
{
// Toggle checked-status
menuItem.IsChecked = !menuItem.IsChecked;
}
if (eventHandler != null)
{
eventHandler.Invoke(sender, e);
}
};
contextMenu.Items.Add(menuItem);
}
private async void BtnSave2_Click(object sender, RoutedEventArgs e)
{
SaveCheck();
SaveInsertClicked?.Invoke(sender, e);
var main = (MainWindow)Application.Current.MainWindow;
await main.HideMetroDialogAsync(this);
}
private void viewDeed_OnClick(object sender, RoutedEventArgs e)
{
if (eHandler == null)
{
return;
}
eHandler.Invoke(this, null);
}
/// <summary>
/// Fires the Cancel event.
/// </summary>
/// <param name="sender">The source object.</param>
/// <param name="e">The event data.</param>
private void OnCancel(object sender, RoutedEventArgs e)
{
RoutedEventHandler handler = Cancel;
handler?.Invoke(sender, e);
AfterAdapterAction();
}
/// <summary>
/// Called when the Closed event occurs.
/// </summary>
/// <param name="e">Event arguments.</param>
protected virtual void OnClosed(RoutedEventArgs e)
{
RoutedEventHandler handler = Closed;
if (null != handler)
{
handler.Invoke(this, e);
}
}
public static void RegisterClickEvent(this Button button, RoutedEventHandler handler, bool handled = false)
{
button.Click += (object sender, RoutedEventArgs e) => {
handler.Invoke(sender, e);
if (handled)
{
e.Handled = true;
}
};
}
/// <summary>
/// Called when the Closed event occurs.
/// </summary>
/// <param name="e">Event arguments.</param>
protected virtual void OnClosed(RoutedEventArgs e)
{
#if WINDOWS_PHONE
GoToVisualState(ClosedVisibilityStateName, true);
#endif
RoutedEventHandler handler = Closed;
if (null != handler)
{
handler.Invoke(this, e);
}
}
private void Start_Click(object sender, RoutedEventArgs e)
{
try
{
EXELauncher.Start(ac);
AppStarted?.Invoke(this, e);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, FindResource("MessageBoxTitle_Error") as string);
}
}
private void TextBox_OnLostFocus(object sender, RoutedEventArgs e)
{
RoutedEventHandler textBoxLostFocus = this.ViewModel.ParentViewModel.OnTextBoxLostFocus;
if (textBoxLostFocus == null)
{
return;
}
object obj = sender;
RoutedEventArgs routedEventArgs = e;
textBoxLostFocus.Invoke(obj, routedEventArgs);
}
private void OnFEEvent(object sender, RoutedEventArgs e)
{
RoutedEventHandler handler = (RoutedEventHandler)eventDestination.Target;
if (handler != null)
{
handler.Invoke(sender, e);
}
else
{
Deregister();
}
}
private void ContactSellerButton_OnClick(object sender, RoutedEventArgs e)
{
// ISSUE: reference to a compiler-generated field
RoutedEventHandler sellerButtonClicked = this.ContactSellerButtonClicked;
if (sellerButtonClicked == null)
{
return;
}
object obj = sender;
RoutedEventArgs routedEventArgs = e;
sellerButtonClicked.Invoke(obj, routedEventArgs);
}
private void Timer_Tick(object sender, object e)
{
counter--;
if (counter < 5 && counter > 0 && precountToggle.IsOn)
{
onPreCount?.Invoke(this);
}
if (counter == 0)
{
onAutoAdvance?.Invoke(this);
nextButtonClick?.Invoke(this, null);
ResetCounter();
}
}
public void RegisterNewCommand(string name, RoutedEventHandler action)
{
Commands.Add(new PatternCommand(name, () =>
{
try
{
action.Invoke(this, new RoutedEventArgs());
}
catch (Exception ex)
{
ExceptionNotification.Show(ex.Message, 3000);
}
}));
}
public void RegisterNewCommand(string name, RoutedEventHandler action)
{
Commands.Add(new SampleCommand(name, () =>
{
try
{
action.Invoke(this, new RoutedEventArgs());
}
catch (Exception ex)
{
ShowExceptionNotification(ex);
}
}));
}
public ModuleButton(string name, bool isFirst = false)
{
InitializeComponent();
Name.Content = name;
baseBrush = CenterPart.Fill;
if (isFirst)
{
Shadow.Visibility = Visibility.Hidden;
}
Name.Click += (sender, args) => Click?.Invoke(sender, args);
}
private void ContentBox_OnLostFocus(object sender, RoutedEventArgs e)
{
this.BackgroundBorder.BorderBrush = ((Brush)Application.Current.Resources["PhoneTextBoxDefaultBorderBrush"]);
// ISSUE: reference to a compiler-generated field
RoutedEventHandler lostFocus = this.LostFocus;
if (lostFocus == null)
{
return;
}
object obj = sender;
RoutedEventArgs routedEventArgs = e;
lostFocus.Invoke(obj, routedEventArgs);
}
private void CloseBtn_Click(object sender, RoutedEventArgs e)
{
Window parentWindow = Window.GetWindow((Button)sender);
parentWindow.IsEnabled = false;
if (mCloseEventHandler != null)
{
mCloseEventHandler.Invoke(this, new RoutedEventArgs());
}
else
{
this.Close();
}
parentWindow.IsEnabled = true;
}
//public void SetMenus(List<ViewModel.Menu> menus)
//{
// _menus = menus;
// lbx_Menus.ItemsSource = _menus;
//}
private void StackPanel_MouseDown(object sender, MouseButtonEventArgs e)
{
var control = sender as StackPanel;
var menu = control.DataContext as Park.ViewModel.Menu;
ItemClickEventHandler?.Invoke(menu, e);
if (menu.Parent != null)
{
foreach (var item in menu.Parent.Menus)
{
item.IsOpen = false;
}
}
else
{
foreach (var item in _mainWindowViewModel.Menus)
{
item.IsOpen = false;
}
}
menu.IsOpen = !menu.IsOpen;
}
private void MouseUp(object sender, RoutedEventArgs e)
{
if (_mouseMoved)
{
_mouseMoved = false;
_clickedOnce = true;
_dt = SetNewTimer();
return;
}
if (!_clickedOnce)
{
_clickedOnce = true;
_dt = SetNewTimer();
}
else
{
_dt.Dispose();
_handler?.Invoke(sender, e);
_clickedOnce = false;
}
}
private void SearchImage(GrayImage grayImage, Jocr.Ocr.RunOcrHandler runOcrHandler = null)
{
if (!JocrWrapper.IsOcrParametersInit)
{
progressRing.StartAnimation();
}
Task.Run(() =>
{
if (!JocrWrapper.IsOcrParametersInit)
{
JocrWrapper.InitOcrParameters();
}
currentDispatcher.Invoke(() =>
{
var textBlocks = JocrWrapper.RunOcr(grayImage, runOcrHandler);
SearchJOcrResults(textBlocks);
progressRing.StopAnimation();
OcrFinishedEvent?.Invoke(null, null);
});
});
}
public static void AddMenueItemSetting(this ContextMenu contextMenu, string header, string settingsKey, RoutedEventHandler eventHandler = null)
{
var menuItem = new MenuItem()
{
Header = header,
IsChecked = (bool)Properties.Settings.Default[settingsKey],
// NOTE: IsCheckable seems to bugged. The inverted value counts!
IsCheckable = false,
};
menuItem.Click += (sender, e) =>
{
// Toggle checked-status
menuItem.IsChecked = !menuItem.IsChecked;
//logger.Info($"Toggle setting '{settingsKey}' and save.");
Properties.Settings.Default[settingsKey] = !(bool)Properties.Settings.Default[settingsKey];
Properties.Settings.Default.Save();
eventHandler?.Invoke(sender, e);
};
contextMenu.Items.Add(menuItem);
}
private void RegisterButtonClick(object sender, RoutedEventArgs e)
{
registerEvent.Invoke(sender, e);
}
public static void OnLaunchMedia()
{
LaunchMedia?.Invoke(null, null);
}
public static void OnPauseMedia()
{
PauseMedia?.Invoke(null, null);
}
private void comm_left_button_down(object sender, MouseButtonEventArgs e)
{
click_event_handler_?.Invoke(this, e);
}
private void OnButtonClick(object sender, RoutedEventArgs e)
{
routedEvent.Invoke(this, e);
}
public static void OnStopMedia()
{
StopMedia?.Invoke(null, null);
}
/// <summary>
/// Sets <b>Owner</b> and calls <b>ShowDialog</b> without disabling thread windows.
/// </summary>
/// <returns>True if clicked OK (<b>DialogResult</b> true).</returns>
/// <param name="owner"></param>
/// <param name="hideOwner">Temporarily hide owner.</param>
/// <param name="disableOwner">Temporarily disable owner.</param>
public bool ShowAndWait(Window owner, bool hideOwner = false, bool disableOwner = false)
{
Owner = owner;
wnd ow = hideOwner || disableOwner?owner.Hwnd() : default;
if (hideOwner)
{
ow.ShowL(false); //not owner.Hide(), it closes owner if it is modal
}
if (disableOwner)
{
ow.Enable(false);
Closing += (_, e) => { if (!e.Cancel)
{
ow.Enable(true);
}
}; //the best time to enable. Later would activate wrong window.
}
//To prevent disabling thread windows, temporarily disable all visible enabled thread windows.
// See WPF code in Window.cs functions EnableThreadWindows, ThreadWindowsCallback, ShowDialog.
// Disabling/enabing a window is fast and does not send messages to it, even wm_stylechanging/ed.
// Another way: Show and Dispatcher.PushFrame. Problem: does not set DialogResult. How to know how the dialog was closed?
bool reenable = false;
var tw = wnd.getwnd.threadWindows(process.thisThreadId, onlyVisible: true);
for (int i = 0; i < tw.Length; i++)
{
if (tw[i].IsEnabled())
{
reenable = true; tw[i].Enable(false);
}
else
{
tw[i] = default;
}
}
RoutedEventHandler eh = null; //would be less code with Dispatcher.InvokeAsync or timer, but unreliable, eg can be too soon or interfere with another dialog
if (reenable)
{
Loaded += eh = (_, _) => {
eh = null;
foreach (var v in tw)
{
if (!v.Is0)
{
v.Enable(true);
}
}
}
}
;
try { return(ShowDialog() == true); }
finally {
eh?.Invoke(null, null); //if failed to load
if (hideOwner)
{
ow.ShowL(true); ow.ActivateL();
}
}
}
}
