NICOLA CARMINATI
1703 lines
62 KiB
C#
1703 lines
62 KiB
C#
using Active_Client.Properties;
|
|
using Chromium.Remote;
|
|
using Client.Config;
|
|
using Client.Utils;
|
|
using System;
|
|
using System.Diagnostics;
|
|
using System.Drawing;
|
|
using System.Drawing.Imaging;
|
|
using System.IO;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using static Client.Utils.Constants;
|
|
|
|
namespace Active_Client.View
|
|
{
|
|
static class NcWindow
|
|
{
|
|
//Const value used for open the Process/Application
|
|
const String FanucPath = @"\CNCScreenE\CNCScrnE.exe";
|
|
const String OsaiPath = @"\OSAI\WinNBI\ProVideo.exe";
|
|
const String SiemensPath = @"\Siemens\MotionControl\siemens\sinumerik\hmi\autostart\run_hmi.exe";
|
|
const String DemoPath = @"\Nc_Demo_Application.exe";
|
|
|
|
const String FanucName = "CNCScrnE";
|
|
const String OsaiName = "provideo";
|
|
const String SiemensName = "slsmhmihost";
|
|
const String DemoName = "Nc_Demo_Application";
|
|
|
|
const String Win7TaskBar = "Shell_TrayWnd";
|
|
const String Win7StartBtnCL = "Button";
|
|
const String Win7StartBtnTxt = "Start";
|
|
const String SiemensTool1Name = "RUN_HMI";
|
|
const String SiemensTool2Name = "SLSMSYSTEMMANAGER";
|
|
const int WaitingMs = 500;
|
|
const int TimesToTryKill = 10;
|
|
const int TimesToTryOpen = 240; // 240 * 500ms = 120000ms => 2min
|
|
|
|
//Public variables
|
|
public static bool isFollowing { get { return FollowingFocus; } }
|
|
private static bool FollowingFocus;
|
|
public static bool WindowStarted { get { return windowstarted; } }
|
|
private static bool windowstarted = false;
|
|
public static bool ProdWindowStarted { get { return prodwindowstarted; } }
|
|
private static bool prodwindowstarted = false;
|
|
public static String ProcessName { get { return processname; } }
|
|
private static String processname = "";
|
|
public static String ProcessPath { get { return processpath; } }
|
|
private static String processpath = "";
|
|
public static Process NcProcess { get { return ncprocess; } }
|
|
private static Process ncprocess;
|
|
public static Process prodProcess { get { return prodprocess; } }
|
|
private static Process prodprocess;
|
|
public static String NcCapture { get { return ncCapture; } }
|
|
private static String ncCapture;
|
|
|
|
private static int LastX, LastY;
|
|
private static int LastWidth = 1024, LastHeight = 768;
|
|
private static IntPtr hhook;
|
|
private static IntPtr hhookWindow;
|
|
private static IntPtr keybhook;
|
|
private static IntPtr MainViewHandle;
|
|
private static IntPtr TaskBarHandle;
|
|
private static IntPtr StartBtnHandle;
|
|
private static uint MainProcessPID;
|
|
private static uint NcProcessPID;
|
|
private static uint ProdProcessPID;
|
|
private static uint ActualPID;
|
|
private static WinEventDelegate procDelegate;
|
|
private static WinEventDelegate procDelegateWindow;
|
|
private static keyboardHookProc keybDelegate;
|
|
private static uint LastdwmsEventTime;
|
|
private static uint LastHookedPID;
|
|
private static uint KeyboardPID;
|
|
private static int TriedTimes;
|
|
private static bool ProcKilled;
|
|
private static bool KeyboardVisible;
|
|
private static IntPtr KeyboardHandle;
|
|
private static CfrRect LastKeybPoint;
|
|
private static Point LastKeybPosition;
|
|
private static Point LastKeybPositionReopen;
|
|
|
|
private static IntPtr ActualHND;
|
|
private static IntPtr LastHookedHND;
|
|
private static IntPtr NcHND;
|
|
private static Thread CaptureThread;
|
|
private static Thread FollowNCThread;
|
|
private static int ncWindowWidth;
|
|
private static int ncWindowHeight;
|
|
private static int ncWindowX;
|
|
private static int ncWindowY;
|
|
private static bool altPressed;
|
|
private static bool ctrlPressed;
|
|
private static bool shiftPressed;
|
|
private static uint KeybPID;
|
|
private static uint ActualWindowPID;
|
|
private static int ActiveNCWindowStyle;
|
|
private static int ActiveNCWindowBorder;
|
|
private static int ActiveWindowNCWindowStyle;
|
|
private static int ActiveWindowNCWindowBorder;
|
|
private static uint ActiveWindowNCPopUp;
|
|
private static uint ActiveNCWindowNCPopUp;
|
|
|
|
|
|
public static MainForm mainFrm;
|
|
private static string prodEXEname;
|
|
|
|
|
|
public static NcState State { get { return state; } }
|
|
private static NcState state;
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#region PUBLIC_CUSTOM_METHODS
|
|
|
|
// Start/Open the NC Window
|
|
public static int StartNcWindow()
|
|
{
|
|
Process[] processes;
|
|
|
|
//Setup the variables
|
|
ProcKilled = false;
|
|
|
|
//Set Window Started = false
|
|
windowstarted = false;
|
|
|
|
//Setup the Path/Name of the process
|
|
SetupNcProcess();
|
|
|
|
//Read if exists a Process with correct name
|
|
processes = Process.GetProcessesByName(processname);
|
|
|
|
//Save the Taskbar Windows Handle
|
|
TaskBarHandle = FindWindow(Win7TaskBar, "");
|
|
StartBtnHandle = FindWindow(Win7StartBtnCL, Win7StartBtnTxt);
|
|
|
|
//Kill Window Keyboard
|
|
closeVirtualKeyboard();
|
|
|
|
//Kill tool processes if they had been started whitout HMI (Only Siemens)
|
|
if (Config.VendorHmiConfig.Type == 2 && processes.Length <= 0)
|
|
{
|
|
//Kill All Windows
|
|
KillAllProcessWithName(SiemensTool2Name);
|
|
}
|
|
|
|
//If exists the Process
|
|
if (processes.Length > 0)
|
|
{
|
|
//Set the first founded process
|
|
ncprocess = processes[0];
|
|
ncprocess.WaitForInputIdle();
|
|
|
|
//Wait until the process is started
|
|
if (Config.VendorHmiConfig.Type != 2)
|
|
{
|
|
//If is not Siemens try to wait the HMI for a period of tyme. After that re-open the window
|
|
TriedTimes = 1;
|
|
while ((processes[0].MainWindowHandle == IntPtr.Zero || !isWindowReady(processes[0].MainWindowTitle)) && TriedTimes < TimesToTryKill)
|
|
{
|
|
processes = Process.GetProcessesByName(processname);
|
|
if (processes[0].MainWindowHandle == IntPtr.Zero)
|
|
{
|
|
Thread.Sleep(WaitingMs);
|
|
TriedTimes++;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//If is Siemens wait the HMI for an infinite time
|
|
while (processes[0].MainWindowHandle == IntPtr.Zero || !isWindowReady(processes[0].MainWindowTitle))
|
|
{
|
|
processes = Process.GetProcessesByName(processname);
|
|
if (processes[0].MainWindowHandle == IntPtr.Zero)
|
|
{
|
|
Thread.Sleep(WaitingMs);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Kill the process if needed
|
|
if ((TriedTimes == TimesToTryKill) && (Config.VendorHmiConfig.Type != 2))
|
|
{
|
|
//Kill the Process
|
|
CloseNcWindow(true);
|
|
|
|
//Setup the Variable
|
|
ProcKilled = true;
|
|
}
|
|
}
|
|
|
|
if ((processes.Length <= 0 || ProcKilled) && (Config.VendorHmiConfig.Type != 2))
|
|
{
|
|
ncprocess = new Process();
|
|
|
|
// Check if exists the Nc Path
|
|
if (!File.Exists(processpath))
|
|
return 1;
|
|
|
|
//Setup the Process path
|
|
ncprocess.StartInfo.FileName = processpath;
|
|
|
|
//Add arguments if is Fanuc NC
|
|
if (Config.VendorHmiConfig.Type == 1)
|
|
ncprocess.StartInfo.Arguments = "/H=" + Config.VendorHmiConfig.IpAddress + ":" + Config.VendorHmiConfig.Port + "/T=30";
|
|
|
|
//Start the Process
|
|
ncprocess.Start();
|
|
ncprocess.WaitForInputIdle(1000);
|
|
|
|
//Wait until the process is started
|
|
TriedTimes = 1;
|
|
while ((processes.Length <= 0 || (processes[0].MainWindowHandle == IntPtr.Zero) || !isWindowReady(processes[0].MainWindowTitle)) && TriedTimes < TimesToTryOpen)
|
|
{
|
|
processes = Process.GetProcessesByName(processname);
|
|
if (processes.Length <= 0 || (processes[0].MainWindowHandle == IntPtr.Zero) || !isWindowReady(processes[0].MainWindowTitle))
|
|
{
|
|
Thread.Sleep(WaitingMs);
|
|
TriedTimes++;
|
|
}
|
|
}
|
|
if (TriedTimes == TimesToTryOpen)
|
|
return 2;
|
|
|
|
//Set the first founded process
|
|
ncprocess = processes[0];
|
|
|
|
Thread.Sleep(1000);
|
|
}
|
|
|
|
//Set the kill method
|
|
ncprocess.Exited += OnprocessExit;
|
|
|
|
//Set Window Started => true
|
|
windowstarted = true;
|
|
|
|
//Show the Main Window & Hide the Others (Only Siemens)
|
|
ShowWindow(ncprocess.MainWindowHandle, WS_SHOW);
|
|
if (Config.VendorHmiConfig.Type == 2)
|
|
{
|
|
//Wait 500 ms of Siemens software
|
|
Thread.Sleep(500);
|
|
|
|
//Hide Second Window
|
|
hideAllProcWindows(SiemensTool1Name);
|
|
|
|
//Hide first Window
|
|
hideAllProcWindows(SiemensTool2Name);
|
|
|
|
SetNcIcon(Resources.SinumerikHmi);
|
|
}
|
|
|
|
//Wait until window title become correct
|
|
|
|
//Remove the Frame Border
|
|
RemoveFrameBorder(ncprocess.MainWindowHandle);
|
|
|
|
|
|
//Maximize Window if is Osai
|
|
if (Config.VendorHmiConfig.Type == 3)
|
|
ShowWindow(ncprocess.MainWindowHandle, SW_SHOWMAXIMIZED);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
// Start/Open the PROD Window
|
|
public static int StartProdWindow(string EXEpath, string EXEname)
|
|
{
|
|
Process[] processes;
|
|
|
|
ProcKilled = false;
|
|
prodEXEname = EXEname;
|
|
|
|
//Set Window Started = false
|
|
prodwindowstarted = false;
|
|
|
|
//Read if exists a Process with correct name
|
|
processes = Process.GetProcessesByName(EXEname);
|
|
|
|
//If exists the Process
|
|
if (processes.Length > 0)
|
|
{
|
|
//Set the first founded process
|
|
prodprocess = processes[0];
|
|
prodprocess.WaitForInputIdle(1000);
|
|
|
|
//Wait until the process is started
|
|
TriedTimes = 1;
|
|
while (processes[0].MainWindowHandle == IntPtr.Zero && TriedTimes < TimesToTryKill)
|
|
{
|
|
processes = Process.GetProcessesByName(EXEname);
|
|
if (processes[0].MainWindowHandle == IntPtr.Zero)
|
|
{
|
|
Thread.Sleep(WaitingMs);
|
|
TriedTimes++;
|
|
}
|
|
}
|
|
|
|
//Kill the process if needed
|
|
if ((TriedTimes == TimesToTryKill))
|
|
{
|
|
//Kill the Process
|
|
CloseProdWindow(true);
|
|
|
|
//Setup the Variable
|
|
ProcKilled = true;
|
|
}
|
|
}
|
|
|
|
if (processes.Length <= 0 || ProcKilled)
|
|
{
|
|
prodprocess = new Process();
|
|
|
|
// Check if exists the Nc Path
|
|
if (!File.Exists(EXEpath))
|
|
return 1;
|
|
|
|
//Setup the Process path
|
|
prodprocess.StartInfo.FileName = EXEpath;
|
|
|
|
//Start the Process
|
|
prodprocess.Start();
|
|
prodprocess.WaitForInputIdle();
|
|
|
|
//Wait until the process is started
|
|
TriedTimes = 1;
|
|
while ((processes.Length <= 0 || (processes[0].MainWindowHandle == IntPtr.Zero)) && TriedTimes < TimesToTryOpen)
|
|
{
|
|
processes = Process.GetProcessesByName(EXEname);
|
|
if (processes.Length <= 0 || (processes[0].MainWindowHandle == IntPtr.Zero))
|
|
{
|
|
Thread.Sleep(WaitingMs);
|
|
TriedTimes++;
|
|
}
|
|
}
|
|
if (TriedTimes == TimesToTryOpen)
|
|
return 2;
|
|
|
|
//Set the first founded process
|
|
prodprocess = processes[0];
|
|
|
|
Thread.Sleep(1000);
|
|
}
|
|
|
|
|
|
//Set Window Started => true
|
|
prodwindowstarted = true;
|
|
|
|
//Show the Main Window & Hide the Others (Only Siemens)
|
|
ShowWindow(prodprocess.MainWindowHandle, WS_SHOW);
|
|
|
|
//Remove the Frame Border
|
|
RemoveFrameBorder(prodprocess.MainWindowHandle);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
//Kill/Close the NC Window
|
|
public static void CloseNcWindow(bool forced)
|
|
{
|
|
Process[] processes;
|
|
int style;
|
|
|
|
//Stop Following Nc
|
|
StopNcFollowing();
|
|
|
|
//If the NC is Siemens Exit from Function and lets the HMI to continue his life
|
|
if (!forced && Config.VendorHmiConfig.Type == 2)
|
|
{
|
|
MinimizeNcWindow();
|
|
return;
|
|
}
|
|
//If FollowNcWindow is OFF, set the Border and lets the HMI to continue his life
|
|
else if (!forced && !Config.VendorHmiConfig.FollowNcWindow)
|
|
{
|
|
ShowNcWindow();
|
|
style = GetWindowLong(ncprocess.MainWindowHandle, GWL_STYLE);
|
|
SetWindowLong(ncprocess.MainWindowHandle, GWL_STYLE, (style | WS_CAPTION | WS_THICKFRAME));
|
|
return;
|
|
}
|
|
|
|
//Kill the Process
|
|
if (ncprocess != null && !ncprocess.HasExited)
|
|
ncprocess.Kill();
|
|
|
|
//Read if exists a Process with correct name
|
|
processes = Process.GetProcessesByName(processname);
|
|
|
|
//Wait until the process is killed
|
|
TriedTimes = 1;
|
|
while (processes.Length > 0 && TriedTimes < TimesToTryKill)
|
|
{
|
|
processes = Process.GetProcessesByName(processname);
|
|
if (processes.Length > 0)
|
|
{
|
|
Thread.Sleep(WaitingMs);
|
|
TriedTimes++;
|
|
}
|
|
}
|
|
|
|
//Kill Tool Process
|
|
if (Config.VendorHmiConfig.Type == 2)
|
|
KillAllProcessWithName(SiemensTool2Name);
|
|
|
|
}
|
|
|
|
|
|
//Kill/Close the PROD Window
|
|
public static void CloseProdWindow(bool forced)
|
|
{
|
|
Process[] processes;
|
|
|
|
if (prodEXEname == null)
|
|
return;
|
|
|
|
//Kill the Process
|
|
if (prodprocess != null && !prodprocess.HasExited)
|
|
prodprocess.Kill();
|
|
|
|
//Read if exists a Process with correct name
|
|
processes = Process.GetProcessesByName(prodEXEname);
|
|
|
|
//Wait until the process is killed
|
|
TriedTimes = 1;
|
|
while (processes.Length > 0 && TriedTimes < TimesToTryKill)
|
|
{
|
|
processes = Process.GetProcessesByName(prodEXEname);
|
|
if (processes.Length > 0)
|
|
{
|
|
Thread.Sleep(WaitingMs);
|
|
TriedTimes++;
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
//Show Nc Window
|
|
public static void ShowNcWindow()
|
|
{
|
|
if (windowstarted)
|
|
{
|
|
ShowWindow(ncprocess.MainWindowHandle, SW_SHOWNOACTIVATE);
|
|
ResizeAndMoveNcWindow(ncWindowX, ncWindowY, ncWindowWidth, ncWindowHeight);
|
|
}
|
|
}
|
|
|
|
//Show Prod Window
|
|
public static void ShowProdWindow()
|
|
{
|
|
if (prodwindowstarted)
|
|
{
|
|
ShowWindow(prodprocess.MainWindowHandle, SW_SHOWNOACTIVATE);
|
|
ResizeAndMoveProdWindow(HMI_WINDOW_POS_X_DEMO, HMI_WINDOW_POS_Y_DEMO, HMI_WINDOW_WIDTH_DEMO, HMI_WINDOW_HEIGHT_DEMO);
|
|
}
|
|
}
|
|
|
|
|
|
//Minimize Nc Window
|
|
public static void MinimizeNcWindow()
|
|
{
|
|
if (windowstarted)
|
|
ShowWindow(ncprocess.MainWindowHandle, WS_MINIMIZE);
|
|
}
|
|
|
|
//Show Prod Window
|
|
public static void MinimizeProdWindow()
|
|
{
|
|
if (prodwindowstarted)
|
|
ShowWindow(prodprocess.MainWindowHandle, WS_MINIMIZE);
|
|
}
|
|
|
|
|
|
//Hide Nc Window
|
|
public static void HideNcWindow()
|
|
{
|
|
if (windowstarted)
|
|
ShowWindow(ncprocess.MainWindowHandle, WS_HIDE);
|
|
}
|
|
|
|
//Hide Prod Window
|
|
public static void HideProdWindow()
|
|
{
|
|
if (prodwindowstarted)
|
|
ShowWindow(prodprocess.MainWindowHandle, WS_HIDE);
|
|
}
|
|
|
|
|
|
//Set State
|
|
public static void SetState(NcState St)
|
|
{
|
|
state = St;
|
|
}
|
|
|
|
|
|
|
|
//Show Windows Taskbar
|
|
public static void ShowTaskBar()
|
|
{
|
|
if (!Config.ClientConfig.RunningOnSecondaryScreen)
|
|
{
|
|
ShowWindow(TaskBarHandle, SW_SHOWNOACTIVATE);
|
|
ShowWindow(StartBtnHandle, SW_SHOWNOACTIVATE);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//Hide Windows Taskbar
|
|
public static void HideTaskBar()
|
|
{
|
|
if (windowstarted && !Config.ClientConfig.RunningOnSecondaryScreen)
|
|
{
|
|
ShowWindow(TaskBarHandle, WS_HIDE);
|
|
ShowWindow(StartBtnHandle, WS_HIDE);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//Set NC Icon
|
|
public static void SetNcIcon(Icon icon)
|
|
{
|
|
if (windowstarted)
|
|
SendMessage(ncprocess.MainWindowHandle, WM_SETICON, ICON_BIG, icon.Handle);
|
|
}
|
|
|
|
|
|
|
|
//Force NC Focus
|
|
public static void ForceNcFocus()
|
|
{
|
|
if (windowstarted)
|
|
ForceFocus(ncprocess.MainWindowHandle);
|
|
}
|
|
|
|
//Force Prod Focus
|
|
public static void ForceProdFocus()
|
|
{
|
|
if (windowstarted)
|
|
ForceFocus(prodprocess.MainWindowHandle);
|
|
}
|
|
|
|
|
|
//Force NC Redraw
|
|
public static void ForceNcRedraw()
|
|
{
|
|
if (windowstarted)
|
|
{
|
|
HideNcWindow();
|
|
ShowNcWindow();
|
|
}
|
|
}
|
|
|
|
|
|
//Force STEP Focus
|
|
public static void ForceStepFocus()
|
|
{
|
|
if (MainViewHandle != IntPtr.Zero)
|
|
ForceFocus(MainViewHandle);
|
|
|
|
}
|
|
|
|
|
|
|
|
//Force Focus External app
|
|
public static void ForceExtFocus(IntPtr Handle, int X, int Y, int width, int height)
|
|
{
|
|
if (Handle != IntPtr.Zero)
|
|
ForceFocus(Handle);
|
|
|
|
if (width > 0 && height > 0)
|
|
MoveWindow(Handle, X, Y, width, height, true);
|
|
}
|
|
|
|
|
|
//Start Step Managing
|
|
public static void StartStepFollowing(IntPtr Handle)
|
|
{
|
|
//Setup the Handle-variable
|
|
MainViewHandle = Handle;
|
|
|
|
|
|
//Start Keyboard Hook
|
|
GetWindowThreadProcessId(MainViewHandle, out MainProcessPID);
|
|
|
|
if (keybhook != IntPtr.Zero)
|
|
UnhookWindowsHookEx(keybhook);
|
|
keybDelegate = new keyboardHookProc(KeybEventProc);
|
|
keybhook = SetWindowsHookEx(WH_KEYBOARD_LL, keybDelegate, IntPtr.Zero, 0);
|
|
|
|
}
|
|
|
|
|
|
//Start following Nc Window (bring-to-font the main window)
|
|
public static void StartNcFollowing(IntPtr Handle, IntPtr NcHandle, IntPtr ProdHandle, int Width, int Height)
|
|
{
|
|
//Setup the Handle-variable
|
|
MainViewHandle = Handle;
|
|
NcHND = NcHandle;
|
|
|
|
//Set the parent of the window
|
|
if (windowstarted)
|
|
SetParent(ncprocess.MainWindowHandle, NcHandle);
|
|
|
|
//Set the parent of the window
|
|
if (prodwindowstarted)
|
|
SetParent(prodprocess.MainWindowHandle, ProdHandle);
|
|
|
|
//Get the Process-Id
|
|
GetWindowThreadProcessId(MainViewHandle, out MainProcessPID);
|
|
if (windowstarted)
|
|
GetWindowThreadProcessId(ncprocess.MainWindowHandle, out NcProcessPID);
|
|
if (prodwindowstarted)
|
|
GetWindowThreadProcessId(prodProcess.MainWindowHandle, out ProdProcessPID);
|
|
|
|
//Resize the Window
|
|
if (windowstarted)
|
|
ResizeAndMoveNcWindow(ncWindowX, ncWindowY, ncWindowWidth, ncWindowHeight);
|
|
if (prodwindowstarted)
|
|
ResizeAndMoveProdWindow(HMI_WINDOW_POS_X_DEMO, HMI_WINDOW_POS_Y_DEMO, HMI_WINDOW_WIDTH_DEMO, HMI_WINDOW_HEIGHT_DEMO);
|
|
|
|
//Start Keyboard Hook
|
|
if (keybhook != IntPtr.Zero)
|
|
UnhookWindowsHookEx(keybhook);
|
|
keybDelegate = new keyboardHookProc(KeybEventProc);
|
|
keybhook = SetWindowsHookEx(WH_KEYBOARD_LL, keybDelegate, IntPtr.Zero, 0);
|
|
|
|
//Start the Hook
|
|
if (MainViewHandle != IntPtr.Zero && MainProcessPID != 0 && ((windowstarted && NcProcessPID != 0) || (prodwindowstarted && ProdProcessPID != 0)))
|
|
{
|
|
//Detach the hook
|
|
if (hhook != IntPtr.Zero)
|
|
UnhookWinEvent(hhook);
|
|
|
|
//Attach the new hook
|
|
procDelegate = new WinEventDelegate(WinEventProc);
|
|
hhook = SetWinEventHook(EVENT_SYSTEM_FOREGROUND, EVENT_SYSTEM_FOREGROUND, IntPtr.Zero, procDelegate, 0, 0, WINEVENT_OUTOFCONTEXT);
|
|
|
|
//Detach the hook
|
|
if (hhookWindow != IntPtr.Zero)
|
|
UnhookWinEvent(hhookWindow);
|
|
|
|
//Attach the OSAI hook
|
|
if (windowstarted && (Config.VendorHmiConfig.Type == 2))// || Config.VendorHmiConfig.Type == 3))
|
|
{
|
|
procDelegateWindow = new WinEventDelegate(WinEventProcWindow);
|
|
hhookWindow = SetWinEventHook(EVENT_OBJECT_CREATE, EVENT_OBJECT_DESTROY, IntPtr.Zero, procDelegateWindow, 0, 0, WINEVENT_OUTOFCONTEXT);
|
|
}
|
|
|
|
FollowingFocus = true;
|
|
|
|
//Start the new Thread of Image Captutre - in Standby (NICOLA CARMINATI 25/01/2018)
|
|
//if (CaptureThread != null)
|
|
// CaptureThread.Abort();
|
|
//CaptureThread = new Thread(new ThreadStart(CaptureCycle));
|
|
//CaptureThread.Start();
|
|
|
|
//Start the new Thread of Follow-NC-Window
|
|
if (windowstarted && Config.VendorHmiConfig.FollowNcWindow)
|
|
{
|
|
|
|
if (FollowNCThread != null)
|
|
FollowNCThread.Abort();
|
|
FollowNCThread = new Thread(new ThreadStart(FollowNcBehaviour));
|
|
FollowNCThread.Start();
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//Stop following Nc Window (bring-to-font the main window) -> ONLY FOR OSAI System!
|
|
public static void StopNcFollowing()
|
|
{
|
|
//Detach the hook
|
|
if (hhook != IntPtr.Zero)
|
|
UnhookWinEvent(hhook);
|
|
|
|
if (hhookWindow != IntPtr.Zero)
|
|
UnhookWinEvent(hhookWindow);
|
|
|
|
if (keybhook != IntPtr.Zero)
|
|
UnhookWindowsHookEx(keybhook);
|
|
|
|
if (FollowNCThread != null)
|
|
FollowNCThread.Abort();
|
|
|
|
//Un-parent the window
|
|
if ((Config.VendorHmiConfig.Type == 2) && ncprocess.MainWindowHandle != IntPtr.Zero)
|
|
SetParent(ncprocess.MainWindowHandle, IntPtr.Zero);
|
|
|
|
FollowingFocus = false;
|
|
|
|
//Stop the Image-Capture Thread
|
|
if (CaptureThread != null)
|
|
CaptureThread.Abort();
|
|
|
|
|
|
//Stop the Follow-Nc Thread
|
|
if (Config.VendorHmiConfig.FollowNcWindow && FollowNCThread != null)
|
|
FollowNCThread.Abort();
|
|
|
|
}
|
|
|
|
|
|
//Take screenshot of the Nc Window
|
|
public static void CaptureHMI()
|
|
{
|
|
RECT rc = new RECT();
|
|
Graphics gr;
|
|
bool success = false;
|
|
Bitmap bmp;
|
|
MemoryStream m = new MemoryStream();
|
|
|
|
Thread.BeginThreadAffinity();
|
|
m = new MemoryStream();
|
|
String Base64Capture;
|
|
if (ncprocess != null && ncprocess.MainWindowHandle != IntPtr.Zero)
|
|
{
|
|
GetWindowRect(ncprocess.MainWindowHandle, out rc);
|
|
bmp = new Bitmap(rc.Right - rc.Left, rc.Bottom - rc.Top);
|
|
gr = Graphics.FromImage(bmp);
|
|
success = PrintWindow(ncprocess.MainWindowHandle, gr.GetHdc(), 0);
|
|
gr.ReleaseHdc();
|
|
if (success && bmp != null)
|
|
{
|
|
bmp.Save(m, ImageFormat.Png);
|
|
Base64Capture = Convert.ToBase64String(m.ToArray());
|
|
ncCapture = "data:image/png;base64," + Base64Capture;
|
|
}
|
|
m.Dispose();
|
|
bmp.Dispose();
|
|
gr.Dispose();
|
|
}
|
|
else
|
|
ncCapture = "data:image/png;base64,";
|
|
|
|
}
|
|
|
|
public static void ActivateNcWindow()
|
|
{
|
|
SetForegroundWindow(ncprocess.MainWindowHandle);
|
|
}
|
|
|
|
#endregion
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#region PUBLIC_KEYBOARD_METHODS
|
|
|
|
//Show virtual Keyboard in last position
|
|
public static void reOpenVirtualKeyboard()
|
|
{
|
|
Task.Run(() =>
|
|
{
|
|
Thread.Sleep(100);
|
|
if (KeyboardVisible && LastKeybPoint != null && !IsWindowVisible(KeyboardHandle))
|
|
openVirtualKeyboard(LastKeybPoint, false, true);
|
|
});
|
|
}
|
|
|
|
|
|
|
|
//Open/Show virtual Keyboard
|
|
public static void openVirtualKeyboard(CfrRect LastPoint, Boolean forcedCenterPosition, Boolean forcedLastPosition)
|
|
{
|
|
//Save last Point
|
|
LastKeybPoint = LastPoint;
|
|
|
|
//Elaborate the Keyboard position
|
|
Point Position = ElaborateKeyboardPosition(LastPoint, forcedCenterPosition, forcedLastPosition);
|
|
|
|
//Run in a Task (Don't stop Browser UI)
|
|
Task.Run(() =>
|
|
{
|
|
|
|
//Open & Find Keyboard
|
|
Process[] processes = Process.GetProcessesByName(KEYB_PROC_NAME);
|
|
if (processes.Length == 0)
|
|
{
|
|
//If i don't find the Keyboard -> Start it!
|
|
launchProcessKeyboard();
|
|
|
|
//Delete Menu buttons
|
|
deleteMenuKeyboard(KeyboardHandle);
|
|
|
|
//Move Window
|
|
NcWindow.MoveWindow(KeyboardHandle, Position.X, Position.Y, Constants.KEYB_WIDTH, Constants.KEYB_HEIGHT, true);
|
|
}
|
|
else
|
|
{
|
|
|
|
//Try to show window
|
|
if (KeyboardHandle != IntPtr.Zero)
|
|
{
|
|
//Move Window
|
|
NcWindow.MoveWindow(KeyboardHandle, Position.X, Position.Y, Constants.KEYB_WIDTH, Constants.KEYB_HEIGHT, true);
|
|
|
|
//Delete Menu buttons
|
|
deleteMenuKeyboard(KeyboardHandle);
|
|
|
|
//Try to show window
|
|
ShowWindow(KeyboardHandle, SW_SHOWNOACTIVATE);
|
|
}
|
|
|
|
//Check if window is visible
|
|
if (KeyboardHandle == IntPtr.Zero || !IsWindowVisible(KeyboardHandle))
|
|
{
|
|
//Kill actual process
|
|
closeVirtualKeyboard();
|
|
|
|
//Start a new one!
|
|
launchProcessKeyboard();
|
|
|
|
//Delete Menu buttons
|
|
deleteMenuKeyboard(KeyboardHandle);
|
|
|
|
//Move Window
|
|
NcWindow.MoveWindow(KeyboardHandle, Position.X, Position.Y, Constants.KEYB_WIDTH, Constants.KEYB_HEIGHT, true);
|
|
}
|
|
}
|
|
|
|
// Save PID
|
|
GetWindowThreadProcessId(KeyboardHandle, out KeyboardPID);
|
|
|
|
//Setup variable "Keyboard visible"
|
|
KeyboardVisible = true;
|
|
|
|
});
|
|
}
|
|
|
|
|
|
|
|
//Close virtual Keyboard
|
|
public static void closeVirtualKeyboard()
|
|
{
|
|
Process[] processes = Process.GetProcessesByName(KEYB_PROC_NAME);
|
|
RECT KeybRct = new RECT();
|
|
|
|
//Save last position
|
|
if (KeyboardHandle != IntPtr.Zero)
|
|
{
|
|
GetWindowRect(KeyboardHandle, out KeybRct);
|
|
LastKeybPositionReopen = new Point() { X = KeybRct.Left, Y = KeybRct.Top };
|
|
}
|
|
|
|
for (int i = 0; i < processes.Length; i++)
|
|
processes[i].Kill();
|
|
|
|
KeyboardPID = 0;
|
|
KeyboardHandle = IntPtr.Zero;
|
|
|
|
}
|
|
|
|
|
|
|
|
//Hide virtual keyboard
|
|
public static void hideVirtualKeyboard()
|
|
{
|
|
if (KeyboardHandle != IntPtr.Zero)
|
|
ShowWindow(KeyboardHandle, WS_HIDE);
|
|
|
|
//Setup variable "Keyboard visible"
|
|
KeyboardVisible = false;
|
|
LastKeybPosition.X = -1;
|
|
LastKeybPosition.Y = -1;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//Private Methods
|
|
|
|
//Elaborates Keyboard position
|
|
private static Point ElaborateKeyboardPosition(CfrRect ObjectPoint, Boolean forcedCenterPosition, Boolean forcedLastPosition)
|
|
{
|
|
int keybX = 0, keybY = 0;
|
|
RECT KeybRct = new RECT();
|
|
|
|
//Find the window position
|
|
if (KeyboardHandle != IntPtr.Zero)
|
|
GetWindowRect(KeyboardHandle, out KeybRct);
|
|
|
|
//If i moved manually the Keyboard -> let where it is, until becomes hide
|
|
if (!forcedLastPosition && (KeyboardHandle != IntPtr.Zero && (LastKeybPosition.X != -1 && LastKeybPosition.Y != -1) && (KeybRct.Left != LastKeybPosition.X || KeybRct.Top != LastKeybPosition.Y)))
|
|
return new Point() { X = KeybRct.Left, Y = KeybRct.Top };
|
|
|
|
//If have to re-open, move at the point where was before close
|
|
else if (forcedLastPosition && LastKeybPositionReopen.X != -1 && LastKeybPositionReopen.Y != -1)
|
|
return new Point() { X = LastKeybPositionReopen.X, Y = LastKeybPositionReopen.Y };
|
|
|
|
//If flag forcedCenterPosition is true -> put in center-bottom position
|
|
else if (forcedCenterPosition)
|
|
{
|
|
LastKeybPosition = new Point()
|
|
{
|
|
X = (Screen.PrimaryScreen.Bounds.Width / 2) - (Constants.KEYB_WIDTH / 2),
|
|
Y = Screen.PrimaryScreen.Bounds.Height - Constants.KEYB_HEIGHT
|
|
};
|
|
return LastKeybPosition;
|
|
}
|
|
//In all others calc the position from HTML Node changed
|
|
else
|
|
{
|
|
//
|
|
|
|
//Setup position Y
|
|
/*
|
|
* 1) try to put the keyboard below the html object. If there's not enough space (2)
|
|
* 2) try to put above the html object. If there's not enough space yet (3)
|
|
* 3) put close to the bottom edge of the screen
|
|
*/
|
|
keybY = ObjectPoint.Y + ObjectPoint.Height + Constants.KEYB_Y_OFFSET;
|
|
if ((keybY + Constants.KEYB_HEIGHT) > Screen.PrimaryScreen.Bounds.Height)
|
|
keybY = ObjectPoint.Y - Constants.KEYB_Y_OFFSET - Constants.KEYB_HEIGHT;
|
|
if (keybY < 0)
|
|
keybY = Screen.PrimaryScreen.Bounds.Height - Constants.KEYB_HEIGHT;
|
|
|
|
|
|
//Setup position X
|
|
/*
|
|
* 1) try to put the keyboard in the middle the html object. If is out of the screen at Left Border (2), at Right Border (3)
|
|
* 2) put close to the left edge of the screen
|
|
* 3) put close to the right edge of the screen
|
|
*/
|
|
keybX = ObjectPoint.X + (ObjectPoint.Width / 2) - (Constants.KEYB_WIDTH / 2);
|
|
if (keybX < 0)
|
|
keybX = 0;
|
|
if (keybX + Constants.KEYB_WIDTH > Screen.PrimaryScreen.Bounds.Width)
|
|
keybX = Screen.PrimaryScreen.Bounds.Width - Constants.KEYB_WIDTH;
|
|
|
|
//Setup the Final Position
|
|
LastKeybPosition = new Point() { X = keybX, Y = keybY };
|
|
return LastKeybPosition;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//Delete Menu Action of a window
|
|
private static void deleteMenuKeyboard(IntPtr Handle)
|
|
{
|
|
// NO Control-Box + NO resize window
|
|
SetWindowLong(Handle, GWL_STYLE, (GetWindowLong(Handle, GWL_STYLE) & ~0x80000 & ~0x40000));
|
|
|
|
}
|
|
|
|
|
|
|
|
//Launch new Process OSK
|
|
private static void launchProcessKeyboard()
|
|
{
|
|
Process[] processes = Process.GetProcessesByName(KEYB_PROC_NAME);
|
|
Process process = new Process();
|
|
process.StartInfo.FileName = KEYB_EXE_NAME;
|
|
process.Start();
|
|
int times = 0;
|
|
|
|
//Find the New Window Handle
|
|
do { processes = Process.GetProcessesByName(KEYB_PROC_NAME); Thread.Sleep(10); times++; }
|
|
while ((processes.Length == 0 || processes[0].MainWindowHandle == IntPtr.Zero) && times < 20);
|
|
|
|
//Filter if i can't find the window
|
|
if (times == 20)
|
|
{
|
|
KeyboardHandle = IntPtr.Zero;
|
|
return;
|
|
}
|
|
|
|
//Set the window Handle Parameter
|
|
KeyboardHandle = processes[0].MainWindowHandle;
|
|
}
|
|
#endregion
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#region WINDOWS_EVENT_OVERRIDE
|
|
|
|
private static void WinEventProcWindow(IntPtr hWinEventHook, uint eventType, IntPtr hwnd, int idObject, int idChild, uint dwEventThread, uint dwmsEventTime)
|
|
{
|
|
|
|
//Read the actual ID of the Process
|
|
GetWindowThreadProcessId(hwnd, out ActualWindowPID);
|
|
if (ActualWindowPID == NcProcessPID && NcProcessPID != 0 && hWinEventHook != ncprocess.MainWindowHandle)
|
|
{
|
|
//Read the style of the window
|
|
ActiveWindowNCWindowStyle = GetWindowLong(hwnd, GWL_STYLE);
|
|
|
|
//Find if it has the border
|
|
ActiveWindowNCWindowBorder = (ActiveWindowNCWindowStyle & WS_BORDER);
|
|
ActiveWindowNCPopUp = ((uint)ActiveWindowNCWindowStyle & WS_POPUP);
|
|
|
|
//if it has the border and a title execute focus
|
|
if (ActiveWindowNCWindowStyle != 0 && (((ActiveWindowNCWindowBorder == WS_BORDER) && ReadWindowTitle(hwnd) != "") || (ActiveWindowNCPopUp == WS_POPUP)))
|
|
{
|
|
if (eventType == EVENT_OBJECT_CREATE)
|
|
{
|
|
SetForegroundWindow(ncprocess.MainWindowHandle);
|
|
}
|
|
else if (eventType == EVENT_OBJECT_DESTROY)
|
|
SetWindowPos(MainViewHandle, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_SHOWWINDOW);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//Following Nc Window Method
|
|
private static void WinEventProc(IntPtr hWinEventHook, uint eventType, IntPtr hwnd, int idObject, int idChild, uint dwEventThread, uint dwmsEventTime)
|
|
{
|
|
ActualHND = hwnd;
|
|
|
|
//Read the actual ID of the Process
|
|
GetWindowThreadProcessId(hwnd, out ActualPID);
|
|
|
|
//Delete the TOPMOST Style of the Window
|
|
if (NcProcessPID != 0 && ActualPID == NcProcessPID)
|
|
{
|
|
|
|
//Read the style of the window
|
|
ActiveNCWindowStyle = GetWindowLong(hwnd, GWL_STYLE);
|
|
//Find if it has the border
|
|
ActiveNCWindowBorder = (ActiveNCWindowStyle & WS_BORDER);
|
|
ActiveNCWindowNCPopUp = ((uint)ActiveWindowNCWindowStyle & WS_POPUP);
|
|
|
|
|
|
//if it has the border and a title execute focus
|
|
if (ActiveNCWindowStyle != 0 && ((ActiveNCWindowBorder == WS_BORDER && ReadWindowTitle(hwnd) != "") || (ActiveNCWindowNCPopUp == WS_POPUP)) && hwnd != ncprocess.MainWindowHandle)
|
|
{
|
|
Console.WriteLine("Handle: " + hwnd + " MainWindowHandle" + ncprocess.MainWindowHandle);
|
|
SetWindowPos(ncprocess.MainWindowHandle, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_SHOWWINDOW);
|
|
}
|
|
}
|
|
|
|
|
|
//If the PID is the STEP-HMI Process
|
|
if (ActualPID == MainProcessPID)
|
|
{
|
|
if (!IsIconic(MainViewHandle))
|
|
{
|
|
//Show Virtual keyboard
|
|
if (Config.ClientConfig.ShowVirtualKeyboard)
|
|
reOpenVirtualKeyboard();
|
|
}
|
|
}
|
|
//If the PID is the NC-HMI Process
|
|
else if ((ActualPID == NcProcessPID && NcProcessPID != 0) || (ActualPID == ProdProcessPID && ProdProcessPID != 0))
|
|
{
|
|
//Hide the TaskBar
|
|
if (Environment.OSVersion.Version.Major < 10)
|
|
HideTaskBar();
|
|
|
|
}
|
|
//If the PID is OTHER Process
|
|
else
|
|
{
|
|
//Show the TaskBar
|
|
if (Environment.OSVersion.Version.Major < 10)
|
|
ShowTaskBar();
|
|
|
|
//SetForegroundWindow(hwnd);
|
|
|
|
//Hide Virtual keyboard
|
|
if (Config.ClientConfig.ShowVirtualKeyboard && KeyboardPID != 0 && ActualPID != KeyboardPID)
|
|
closeVirtualKeyboard();
|
|
}
|
|
|
|
//Save the Last Hooked PID
|
|
LastHookedHND = ActualHND;
|
|
LastHookedPID = ActualPID;
|
|
|
|
//Save the Last TimeStamp
|
|
LastdwmsEventTime = dwmsEventTime;
|
|
|
|
|
|
}
|
|
|
|
|
|
//Hook Keyboard Handle
|
|
private static void KeybEventProc(int nCode, IntPtr wParam, IntPtr lParam)
|
|
{
|
|
int Key = Marshal.ReadInt32(lParam);
|
|
|
|
//Elaborate Hotkey
|
|
if (wParam == HWND_KEYDOWN || wParam == HWND_SYSKEYDOWN)
|
|
{
|
|
if (Key == 0xA4 || Key == 0xA5)
|
|
altPressed = true;
|
|
if (Key == 0xA2 || Key == 0xA3)
|
|
ctrlPressed = true;
|
|
if (Key == 0xA0 || Key == 0xA1)
|
|
shiftPressed = true;
|
|
}
|
|
if (wParam == HWND_KEYUP || wParam == HWND_SYSKEYUP)
|
|
{
|
|
if (Key == 0xA4 || Key == 0xA5)
|
|
altPressed = false;
|
|
if (Key == 0xA2 || Key == 0xA3)
|
|
ctrlPressed = false;
|
|
if (Key == 0xA0 || Key == 0xA1)
|
|
shiftPressed = false;
|
|
}
|
|
|
|
//Read the actual ID of the Process
|
|
GetWindowThreadProcessId(GetForegroundWindow(), out KeybPID);
|
|
|
|
//Filter the PID
|
|
if (KeybPID == MainProcessPID || KeybPID == NcProcessPID || KeybPID == ProdProcessPID)
|
|
{
|
|
//Filter if is keydown
|
|
if (wParam == HWND_SYSKEYDOWN || wParam == HWND_KEYDOWN)
|
|
mainFrm.keyPressedHandler(altPressed, ctrlPressed, shiftPressed, Key);
|
|
}
|
|
if ((wParam == HWND_SYSKEYDOWN || wParam == HWND_KEYDOWN) && !altPressed && (KeybPID == MainProcessPID || KeybPID == ProdProcessPID) && state == NcState.SHOW)
|
|
{
|
|
//IF Siemens
|
|
if (Config.VendorHmiConfig.Type == 2)
|
|
{
|
|
if (Key >= 0x70 && Key <= 0x87)
|
|
SetForegroundWindow(ncprocess.MainWindowHandle);
|
|
}
|
|
//IF Fanuc
|
|
else if (Config.VendorHmiConfig.Type == 1)
|
|
{
|
|
if ((Key >= 0x70 && Key <= 0x87) || Key == 0xA2 || Key == 0xA3)
|
|
SetForegroundWindow(ncprocess.MainWindowHandle);
|
|
}
|
|
}
|
|
|
|
//Call Newx System Hook
|
|
CallNextHookEx(keybhook, nCode, wParam, lParam);
|
|
}
|
|
#endregion
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#region PRIVATE_CUSTOM_METHODS
|
|
|
|
|
|
//Resize out of Bound window
|
|
private static void ResizeOutofBoundWindow(IntPtr ParentHandle, IntPtr WindowHandle)
|
|
{
|
|
RECT MainRct;
|
|
RECT ParentRct;
|
|
int width;
|
|
int height;
|
|
int width2;
|
|
int height2;
|
|
int newX;
|
|
int newY;
|
|
bool move = false;
|
|
bool resize = false;
|
|
|
|
if (GetWindowRect(WindowHandle, out MainRct) && GetWindowRect(ParentHandle, out ParentRct))
|
|
{
|
|
//Setup resize and move variables
|
|
width = (MainRct.Right - MainRct.Left + 1);
|
|
height = (MainRct.Bottom - MainRct.Top + 1);
|
|
width2 = (ParentRct.Right - ParentRct.Left + 1);
|
|
height2 = (ParentRct.Bottom - ParentRct.Top + 1);
|
|
newX = width2 / 2 - width / 2 + ParentRct.Left;
|
|
newY = height2 / 2 - height / 2 + ParentRct.Top;
|
|
|
|
//Check if i need to resize
|
|
if (width > width2 || height > height2)
|
|
resize = true;
|
|
|
|
//Check if i need to move
|
|
if (MainRct.Left < ParentRct.Left || MainRct.Top < ParentRct.Top || MainRct.Right > ParentRct.Right || MainRct.Bottom > ParentRct.Bottom)
|
|
move = true;
|
|
|
|
//Move or Resize the Window
|
|
if (move & !resize)
|
|
MoveWindow(WindowHandle, newX, newY, width, height, true);
|
|
else if (resize)
|
|
MoveWindow(WindowHandle, ParentRct.Left, ParentRct.Top, LastWidth, LastHeight, true);
|
|
}
|
|
}
|
|
|
|
|
|
//Read Window Title
|
|
private static string ReadWindowTitle(IntPtr hwnd)
|
|
{
|
|
int length = GetWindowTextLength(hwnd);
|
|
StringBuilder sb = new StringBuilder(length + 1);
|
|
GetWindowText(hwnd, sb, sb.Capacity);
|
|
return sb.ToString().Trim();
|
|
}
|
|
|
|
|
|
//Resize & Move NC Window
|
|
private static void ResizeAndMoveNcWindow(int X, int Y, int width, int height)
|
|
{
|
|
LastX = X;
|
|
LastY = Y;
|
|
LastWidth = width;
|
|
LastHeight = height;
|
|
|
|
//Win32 Method
|
|
if (ncprocess != null && windowstarted)
|
|
{
|
|
MoveWindow(ncprocess.MainWindowHandle, LastX, LastY, LastWidth, LastHeight, true);
|
|
}
|
|
}
|
|
|
|
|
|
//Resize & Move NC Window
|
|
private static void ResizeAndMoveProdWindow(int X, int Y, int width, int height)
|
|
{
|
|
//Win32 Method
|
|
if (prodProcess != null && prodwindowstarted)
|
|
{
|
|
MoveWindow(prodProcess.MainWindowHandle, X, Y, width, height, true);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
private static bool isWindowReady(string Title)
|
|
{
|
|
switch (Config.VendorHmiConfig.Type)
|
|
{
|
|
case 1: return (Title.Contains(HMI_WINDOW_TITLE_FANUC) && Title.Contains(Config.VendorHmiConfig.IpAddress));
|
|
case 2: return (Title.Contains(HMI_WINDOW_TITLE_SIEMENS) || Title.Contains(HMI_WINDOW_TITLE_SIEMENS_CMS_CONTROL));
|
|
case 3: return true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
//Setup the Path/Name of the process Method
|
|
private static void SetupNcProcess()
|
|
{
|
|
switch (Config.VendorHmiConfig.Type)
|
|
{
|
|
// 0: Demo
|
|
case 0:
|
|
{
|
|
processname = DemoName;
|
|
processpath = @"C:\CMS\ACTIVE\DEMO" + DemoPath;
|
|
ncWindowWidth = HMI_WINDOW_WIDTH_DEMO;
|
|
ncWindowHeight = HMI_WINDOW_HEIGHT_DEMO;
|
|
ncWindowX = HMI_WINDOW_POS_X_DEMO;
|
|
ncWindowY = HMI_WINDOW_POS_Y_DEMO;
|
|
}; break;
|
|
|
|
// 1: Fanuc
|
|
case 1:
|
|
{
|
|
processname = FanucName;
|
|
processpath = getProgramFilesx86Path() + FanucPath;
|
|
ncWindowWidth = HMI_WINDOW_WIDTH_FANUC;
|
|
ncWindowHeight = HMI_WINDOW_HEIGHT_FANUC;
|
|
ncWindowX = HMI_WINDOW_POS_X_FANUC;
|
|
ncWindowY = HMI_WINDOW_POS_Y_FANUC;
|
|
}; break;
|
|
|
|
// 2: Siemens
|
|
case 2:
|
|
{
|
|
processname = SiemensName;
|
|
processpath = getProgramFilesx86Path() + SiemensPath;
|
|
ncWindowWidth = HMI_WINDOW_WIDTH_SIEMENS;
|
|
ncWindowHeight = HMI_WINDOW_HEIGHT_SIEMENS;
|
|
ncWindowX = HMI_WINDOW_POS_X_SIEMENS;
|
|
ncWindowY = HMI_WINDOW_POS_Y_SIEMENS;
|
|
}; break;
|
|
|
|
// 3: Osai
|
|
case 3:
|
|
{
|
|
processname = OsaiName;
|
|
processpath = getProgramFilesx86Path() + OsaiPath;
|
|
ncWindowWidth = HMI_WINDOW_WIDTH_OSAI;
|
|
ncWindowHeight = HMI_WINDOW_HEIGHT_OSAI;
|
|
ncWindowX = HMI_WINDOW_POS_X_OSAI;
|
|
ncWindowY = HMI_WINDOW_POS_Y_OSAI;
|
|
}; break;
|
|
|
|
// 4: Siemens S7
|
|
case 4:
|
|
{
|
|
processname = DemoName;
|
|
processpath = @"C:\CMS\ACTIVE\DEMO" + DemoPath;
|
|
ncWindowWidth = 0;
|
|
ncWindowHeight = 0;
|
|
ncWindowX = 0;
|
|
ncWindowY = 0; ;
|
|
//ncWindowWidth = HMI_WINDOW_WIDTH_SIEMENS;
|
|
//ncWindowHeight = HMI_WINDOW_HEIGHT_SIEMENS;
|
|
//ncWindowX = HMI_WINDOW_POS_X_SIEMENS;
|
|
//ncWindowY = HMI_WINDOW_POS_Y_SIEMENS;
|
|
}; break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//Get X86 Program folder
|
|
private static string getProgramFilesx86Path()
|
|
{
|
|
if (8 == IntPtr.Size || (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("PROCESSOR_ARCHITEW6432"))))
|
|
{
|
|
return Environment.GetEnvironmentVariable("ProgramFiles(x86)");
|
|
}
|
|
return Environment.GetEnvironmentVariable("ProgramFiles");
|
|
}
|
|
|
|
|
|
|
|
// On Process Kill
|
|
private static void OnprocessExit(object sender, EventArgs e)
|
|
{
|
|
Application.Exit();
|
|
}
|
|
|
|
|
|
|
|
//Hide All windows Process
|
|
private static void hideAllProcWindows(String ProcessName)
|
|
{
|
|
Process[] processes = Process.GetProcessesByName(ProcessName);
|
|
foreach (Process proc in processes)
|
|
{
|
|
if (proc.MainWindowHandle != IntPtr.Zero)
|
|
ShowWindow(proc.MainWindowHandle, WS_HIDE);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//Kill All Process Name
|
|
private static void KillAllProcessWithName(String ProcessName)
|
|
{
|
|
Process[] procTool = Process.GetProcessesByName(ProcessName);
|
|
foreach (Process proc in procTool)
|
|
{
|
|
proc.Kill();
|
|
|
|
//Read if exists a Process with correct name
|
|
procTool = Process.GetProcessesByName(proc.ProcessName);
|
|
|
|
//Wait until the process is killed
|
|
TriedTimes = 1;
|
|
while (procTool.Length > 0 && TriedTimes < TimesToTryKill)
|
|
{
|
|
procTool = Process.GetProcessesByName(processname);
|
|
if (procTool.Length > 0)
|
|
{
|
|
Thread.Sleep(500);
|
|
TriedTimes++;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
private static void ForceFocus(IntPtr Handle)
|
|
{
|
|
//If is not already handled
|
|
if (GetForegroundWindow() != Handle)
|
|
{
|
|
//If is minimized -> Show it
|
|
if (IsIconic(Handle))
|
|
ShowWindow(Handle, SW_SHOWDEFAULT);
|
|
|
|
//Set as foreground
|
|
SetForegroundWindow(Handle);
|
|
}
|
|
}
|
|
|
|
|
|
private static void RemoveFrameBorder(IntPtr Handle)
|
|
{
|
|
int style = GetWindowLong(Handle, GWL_STYLE);
|
|
SetWindowLong(Handle, GWL_STYLE, (style & ~WS_CAPTION & ~WS_THICKFRAME));
|
|
}
|
|
|
|
#endregion
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#region THREAD_CYCLE_METHODS
|
|
|
|
|
|
//Image Capture Method
|
|
public static void CaptureCycle()
|
|
{
|
|
RECT rc = new RECT();
|
|
Graphics gr;
|
|
bool success = false;
|
|
Bitmap bmp;
|
|
MemoryStream m = new MemoryStream();
|
|
|
|
try
|
|
{
|
|
while (true)
|
|
{
|
|
if (state == NcState.SHOWPROD)
|
|
{
|
|
Thread.BeginThreadAffinity();
|
|
m = new MemoryStream();
|
|
String Base64Capture;
|
|
if (ncprocess != null && ncprocess.MainWindowHandle != IntPtr.Zero)
|
|
{
|
|
GetWindowRect(ncprocess.MainWindowHandle, out rc);
|
|
bmp = new Bitmap(rc.Right - rc.Left, rc.Bottom - rc.Top);
|
|
gr = Graphics.FromImage(bmp);
|
|
success = PrintWindow(ncprocess.MainWindowHandle, gr.GetHdc(), 0);
|
|
gr.ReleaseHdc();
|
|
if (success && bmp != null)
|
|
{
|
|
bmp.Save(m, ImageFormat.Png);
|
|
Base64Capture = Convert.ToBase64String(m.ToArray());
|
|
ncCapture = "data:image/png;base64," + Base64Capture;
|
|
}
|
|
m.Dispose();
|
|
bmp.Dispose();
|
|
gr.Dispose();
|
|
}
|
|
else
|
|
ncCapture = "data:image/png;base64,";
|
|
|
|
Thread.EndThreadAffinity();
|
|
}
|
|
Thread.Sleep(500);
|
|
}
|
|
}
|
|
catch (ThreadAbortException) { }
|
|
}
|
|
|
|
|
|
//NC Following Method
|
|
public static void FollowNcBehaviour()
|
|
{
|
|
uint process = 0;
|
|
try
|
|
{
|
|
while (true)
|
|
{
|
|
|
|
GetWindowThreadProcessId(GetForegroundWindow(), out process);
|
|
if (state != NcState.SHOW && state != NcState.SHOWPROD && (process == NcProcessPID || process == ProdProcessPID))
|
|
mainFrm.HideAUXWindow();
|
|
else if (state == NcState.SHOWPROD && process == NcProcessPID && prodwindowstarted)
|
|
mainFrm.ShowProdWindow();
|
|
else if (state == NcState.SHOW && process == ProdProcessPID && windowstarted)
|
|
mainFrm.ShowNCWindow();
|
|
|
|
if (Process.GetProcessesByName(processname).Length == 0)
|
|
{
|
|
//Un-parent the window
|
|
if (ncprocess.MainWindowHandle != IntPtr.Zero)
|
|
SetParent(ncprocess.MainWindowHandle, IntPtr.Zero);
|
|
|
|
//Detach the hook
|
|
if (hhook != IntPtr.Zero)
|
|
UnhookWinEvent(hhook);
|
|
|
|
//Stop the Image-Capture Thread
|
|
if (CaptureThread != null)
|
|
CaptureThread.Abort();
|
|
|
|
//Show Task Bar
|
|
ShowTaskBar();
|
|
|
|
//If the mainform is disposed do nothing
|
|
if (mainFrm.IsDisposed)
|
|
return;
|
|
|
|
//Exit from Application
|
|
if (mainFrm.InvokeRequired)
|
|
mainFrm.Invoke((MethodInvoker)delegate ()
|
|
{
|
|
mainFrm.sendClose();
|
|
});
|
|
else
|
|
{
|
|
mainFrm.sendClose();
|
|
}
|
|
}
|
|
|
|
Thread.Sleep(1000);
|
|
}
|
|
}
|
|
catch (ThreadAbortException) { }
|
|
}
|
|
|
|
#endregion
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#region WIN32_METHODS
|
|
|
|
private const int GWL_STYLE = -16;
|
|
private const int GWL_EXSTYLE = -20;
|
|
private const int LWA_ALPHA = 0x00000002;
|
|
private const int LWA_COLORKEY = 0x00000001;
|
|
private const int WS_EX_LAYERED = 0x00080000;
|
|
private const int WS_EX_TOOLWINDOW = 0x00000080;
|
|
private const int WS_CHILD = 0x40000000;
|
|
private const int WS_BORDER = 0x00800000;
|
|
private const int WS_DLGFRAME = 0x00400000;
|
|
private const int WS_CAPTION = WS_BORDER | WS_DLGFRAME;
|
|
private const int WS_THICKFRAME = 262144;
|
|
private const int WS_HIDE = 0;
|
|
private const int WS_SHOW = 5;
|
|
private const int WS_MINIMIZE = 6;
|
|
private const int WS_SHOWNORMAL = 1;
|
|
private const int SW_SHOWMAXIMIZED = 3;
|
|
private const int SW_SHOWDEFAULT = 10;
|
|
private const int SW_SHOWNOACTIVATE = 4;
|
|
private const int WM_SETICON = 0x80;
|
|
private const int ICON_SMALL = 0;
|
|
private const int ICON_BIG = 1;
|
|
private const uint EVENT_OBJECT_FOCUS = 0x8005;
|
|
private const uint EVENT_SYSTEM_FOREGROUND = 0x0003;
|
|
private const uint EVENT_OBJECT_CREATE = 0x8000;
|
|
private const uint EVENT_OBJECT_DESTROY = 0x8001;
|
|
private const uint WINEVENT_OUTOFCONTEXT = 0;
|
|
private const UInt32 SWP_NOSIZE = 0x0001;
|
|
private const UInt32 SWP_NOMOVE = 0x0002;
|
|
private const UInt32 SWP_NOACTIVATE = 0x0010;
|
|
private const UInt32 SWP_SHOWWINDOW = 0x0040;
|
|
private const UInt32 SWP_NOZORDER = 0x0004;
|
|
private const UInt32 SWP_NOREDRAW = 0x0008;
|
|
private const UInt32 SWP_HIDEWINDOW = 0x0080;
|
|
private const int MF_BYCOMMAND = 0x00000000;
|
|
private const int SC_CLOSE = 0xF060;
|
|
private const int SC_MINIMIZE = 0xF020;
|
|
private const int SC_MAXIMIZE = 0xF030;
|
|
private const int HIDE_CLOSE = 0x200;
|
|
private const int SC_SIZE = 0xF000;
|
|
private const int WS_SYSMENU = 0x00080000;
|
|
private const uint WS_POPUP = 0x80000000;
|
|
private const int WS_MAXIMIZE = 0x01000000;
|
|
private const int WH_KEYBOARD_LL = 13;
|
|
static readonly IntPtr HWND_BOTTOM = new IntPtr(1);
|
|
static readonly IntPtr HWND_TOP = new IntPtr(0);
|
|
static readonly IntPtr HWND_TOPMOST = new IntPtr(-1);
|
|
static readonly IntPtr HWND_NOTOPMOST = new IntPtr(-2);
|
|
static readonly IntPtr HWND_KEYDOWN = new IntPtr(0x100);
|
|
static readonly IntPtr HWND_SYSKEYDOWN = new IntPtr(0x104);
|
|
static readonly IntPtr HWND_KEYUP = new IntPtr(0x101);
|
|
static readonly IntPtr HWND_SYSKEYUP = new IntPtr(0x105);
|
|
|
|
[DllImport("user32.dll")]
|
|
public static extern int DeleteMenu(IntPtr hMenu, int nPosition, int wFlags);
|
|
|
|
[DllImport("user32.dll")]
|
|
private static extern IntPtr GetSystemMenu(IntPtr hWnd, bool bRevert);
|
|
|
|
[DllImport("user32.dll", SetLastError = true)]
|
|
static extern IntPtr SendMessage(IntPtr hWnd, UInt32 Msg, IntPtr wParam, IntPtr lParam);
|
|
|
|
[DllImport("user32.dll", SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
internal static extern bool MoveWindow(System.IntPtr hWnd, int X, int Y, int nWidth, int nHeight, bool bRepaint);
|
|
|
|
[DllImport("user32.dll", SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
private static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int x, int y, int cx, int cy, uint uFlags);
|
|
|
|
[DllImport("USER32.DLL")]
|
|
[return: MarshalAs(UnmanagedType.I4)]
|
|
public static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);
|
|
|
|
[DllImport("USER32.DLL")]
|
|
[return: MarshalAs(UnmanagedType.I4)]
|
|
public static extern int GetWindowLong(IntPtr hWnd, int nIndex);
|
|
|
|
[DllImport("user32.dll")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
static extern bool IsWindowVisible(IntPtr hWnd);
|
|
|
|
[DllImport("user32.dll")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
static extern bool IsIconic(IntPtr hWnd);
|
|
|
|
[DllImport("user32.dll")]
|
|
static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, int wParam, IntPtr lParam);
|
|
|
|
[DllImport("user32.dll")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
|
|
|
|
[DllImport("user32.dll", SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.I8)]
|
|
public static extern long SetParent(IntPtr hWndChild, IntPtr hWndNewParent);
|
|
|
|
[DllImport("user32.dll", SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.I4)]
|
|
private static extern int IsZoomed(IntPtr hWnd);
|
|
|
|
[DllImport("user32.dll", SetLastError = true)]
|
|
private static extern IntPtr GetForegroundWindow();
|
|
|
|
[DllImport("user32.dll")]
|
|
[return: MarshalAs(UnmanagedType.I4)]
|
|
static extern int GetWindowText(IntPtr hWnd, StringBuilder text, int count);
|
|
|
|
[DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)]
|
|
static extern int GetWindowTextLength(IntPtr hWnd);
|
|
|
|
[DllImport("user32.dll")]
|
|
static extern IntPtr SetWinEventHook(uint eventMin, uint eventMax, IntPtr hmodWinEventProc, WinEventDelegate lpfnWinEventProc, uint idProcess, uint idThread, uint dwFlags);
|
|
delegate void WinEventDelegate(IntPtr hWinEventHook, uint eventType, IntPtr hwnd, int idObject, int idChild, uint dwEventThread, uint dwmsEventTime);
|
|
|
|
[DllImport("user32.dll")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
static extern bool UnhookWinEvent(IntPtr hWinEventHook);
|
|
|
|
[DllImport("user32.dll")]
|
|
static extern IntPtr SetWindowsHookEx(int idHook, keyboardHookProc callback, IntPtr hInstance, uint threadId);
|
|
delegate void keyboardHookProc(int nCode, IntPtr wParam, IntPtr lParam);
|
|
|
|
[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
|
|
|
|
private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);
|
|
|
|
[DllImport("user32.dll")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
static extern bool UnhookWindowsHookEx(IntPtr idHook);
|
|
|
|
[DllImport("user32.dll", SetLastError = true)]
|
|
static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint processId);
|
|
|
|
[DllImport("user32.dll")]
|
|
private static extern IntPtr FindWindow(string className, string windowText);
|
|
|
|
[DllImport("user32.dll")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
static extern bool SetWindowText(IntPtr hWnd, string text);
|
|
|
|
[DllImport("user32.dll", SetLastError = true)]
|
|
static extern IntPtr SetFocus(IntPtr hWnd);
|
|
|
|
[DllImport("user32.dll")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
static extern bool SetForegroundWindow(IntPtr hWnd);
|
|
|
|
[DllImport("user32.dll")]
|
|
static extern IntPtr GetAncestor(IntPtr hWnd, uint uCmd);
|
|
|
|
[DllImport("user32.dll")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
static extern bool SetLayeredWindowAttributes(IntPtr hwnd, uint crKey, byte bAlpha, uint dwFlags);
|
|
|
|
[DllImport("user32.dll", SetLastError = true)]
|
|
static extern IntPtr FindWindowEx(IntPtr hwndParent, IntPtr hwndChildAfter, string lpszClass, string lpszWindow);
|
|
|
|
[DllImport("user32.dll")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
static extern bool IsWindow(IntPtr hWnd);
|
|
|
|
[DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)]
|
|
[return: MarshalAs(UnmanagedType.I4)]
|
|
static extern int GetClassName(IntPtr hWnd, StringBuilder lpClassName, int nMaxCount);
|
|
|
|
[DllImport("user32.dll")]
|
|
static extern IntPtr GetLastActivePopup(IntPtr hWnd);
|
|
|
|
[DllImport("user32.dll", SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
static extern bool GetWindowRect(IntPtr hwnd, out RECT lpRect);
|
|
|
|
[DllImport("User32.dll", SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
static extern bool PrintWindow(IntPtr hwnd, IntPtr hDC, uint nFlags);
|
|
|
|
[DllImport("user32.dll", SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
static extern bool ShowOwnedPopups(IntPtr hwnd, bool show);
|
|
|
|
[DllImport("dwmapi.dll")]
|
|
static extern int DwmRegisterThumbnail(IntPtr dest, IntPtr src, out IntPtr thumb);
|
|
|
|
|
|
[DllImport("user32", EntryPoint = "GetMenuItemCount", SetLastError = true,
|
|
CharSet = CharSet.Unicode, ExactSpelling = true,
|
|
CallingConvention = CallingConvention.Winapi)]
|
|
private static extern int GetMenuItemCount(IntPtr hMenu);
|
|
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct RECT
|
|
{
|
|
public int Left;
|
|
public int Top;
|
|
public int Right;
|
|
public int Bottom;
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
}
|