public IMonitorWatcher AppeadMonitorWatcher(IMonitorConfig config)
{
IMonitorWatcher mw = CreateMonitorWatcher(config);
AppeadMonitorWatcher(mw);
return(mw);
}
private void toolStripButton_clear_Click(object sender, EventArgs e)
{
if (ActiveBox != null)
{
CFuncNode node = ActiveBox.LinkObj as CFuncNode;
if (node != null)
{
IMonitorConfig config = node.ExtConfigObj as IMonitorConfig;
if (config != null)
{
ActiveBox.ClearAlarms();
RefreshInfo();
}
else
{
IConfigManager <IMonitorType> monitorType = node.ExtConfigObj as IConfigManager <IMonitorType>;
if (monitorType != null)
{
ActiveBox.ClearAlarms();
RefreshInfo();
}
}
}
}
}
private void DoMonitorStateChanged(IMonitorSystemContext context, string name, MonitorState state)
{
CFuncNode node = mLinkObj as CFuncNode;
if (node != null)
{
IMonitorConfig config = node.ExtConfigObj as IMonitorConfig;
if (config != null)
{
if (config.SystemContext == context && config.Name.Equals(name))
{
if (state != MonitorState.None)
{
IMonitor monitor = config.SystemContext.MonitorManager.GetMonitor(name);
if (monitor != null)
{
this.AlarmManager = monitor.AlarmManager;
}
}
else
{
this.AlarmManager = null;
}
if (OnMonitorStateChanged != null)
{
OnMonitorStateChanged(context, name, state);
}
}
}
}
}
public void SetEditConfig(IConfig config)
{
IsChanged = false;
if (config != null)
{
mType = null;
mConfig = config as IMonitorConfig;
mSystemContext = config.SystemContext;
if (config.Verify(ACOpts.Manager_Modify, false))
{
SetTabPageShowState(mConfig.SystemContext.MonitorTypeManager.GetConfig(mConfig.Type));
InitMonitorTypeList(mSystemContext);
InitVSTypeList(mSystemContext);
InitVSList(mSystemContext);
TabPage curPage = tabControl_monitor.SelectedTab;
tabControl_monitor.SelectedTab = tabPage_alertarea;
tabControl_monitor.SelectedTab = curPage;
InitDialog();
}
}
}
private void DoMonitorStopBefore(IMonitorConfig config)
{
if (config.Name.Equals(mMonitorName))
{
mActiveState = false;
}
}
private void DoMonitorStopAfter(IMonitorConfig config)
{
if (config.Name.Equals(mMonitorName))
{
mMonitor = null;
//StopVideo();
}
}
public void QueryMonitorRecord(IMonitorConfig config)
{
if (config != null)
{
comboBox_monitor.SelectedItem = config;
button_find_Click(null, null);
}
}
public void StartTransactAction()
{
IMonitorConfig config = mMonitor.Config;
if (config != null && (config.Watcher.ActiveActionParamConfig.LocalTransactAction || !SystemContext.IsClient))
{
ProcessMonitorAction(config.Watcher.ActiveActionParamConfig.GetTransactActionList());
}
}
public IMonitor CreateMonitor(IMonitorConfig config, IMonitorType type)
{
if (config == null || !config.Enabled)
{
return(null);
}
lock (mMonitors.SyncRoot)
{
CMonitor monitor = mMonitors[config.Name] as CMonitor;
if (monitor == null)
{
if (type == null)
{
type = mSystemContext.MonitorTypeManager.GetConfig(config.Type);
}
if (type != null && type.Enabled && !type.MonitorClass.Equals(""))
{
if (!type.FileName.Equals(""))
{
monitor = Utils.CommonUtil.CreateInstance(SystemContext, type.FileName, type.MonitorClass) as CMonitor;
}
else
{
monitor = Utils.CommonUtil.CreateInstance(type.MonitorClass) as CMonitor;
}
}
if (monitor != null)
{
if (monitor.Init(this, config, type))
{
monitor.OnAlarmPrepProcess += new MonitorAlarmPrepProcess(DoAlarmPrepProcess);
monitor.OnMonitorAlarm += new MonitorAlarmEvent(DoMonitorAlarm);
monitor.OnTransactAlarm += new TransactAlarm(DoTransactAlarm);
monitor.OnMonitorStateChanged += new MonitorStateChanged(DoMonitorStateChanged);
mMonitors.Add(monitor.Name, monitor);
monitor.RefreshState();
}
else
{
return(null);
}
}
}
else
{
monitor.Config = config;
}
return(monitor);
}
}
public CMonitorWatcher(IMonitorConfig config)
{
mMonitorConfig = config;
mMonitorConfig.OnConfigChanged += new ConfigEventHandler(DoConfigChanged);
mRunConfigList = mMonitorConfig.RunParamConfig.GetRunConfigList();
mTimer = new System.Threading.Timer(new TimerCallback(OnTimerTick));
mTimer.Change(Timeout.Infinite, Timeout.Infinite);
}
public bool ConfigMonitor(string name, IMonitorConfig config)
{
IMonitor monitor = GetMonitor(name);
if (monitor != null)
{
monitor.Config = config;
return(true);
}
return(false);
}
private void DoMonitorStartBefore(IMonitorConfig config)
{
if (config.Name.Equals(mMonitorName))
{
mActiveState = true;
Cleanup();
PlayVideo(config as IVisionMonitorConfig);
}
}
private void CleanupWatcherEvent(string name)
{
IMonitorConfig config = SystemContext.MonitorConfigManager.GetConfig(name);
if (config != null)
{
config.Watcher.OnMonitorStartBefore -= new MonitorWatcherEvent(DoMonitorStartBefore);
config.Watcher.OnMonitorStartAfter -= new MonitorWatcherEvent(DoMonitorStartAfter);
config.Watcher.OnMonitorStopBefore -= new MonitorWatcherEvent(DoMonitorStopBefore);
config.Watcher.OnMonitorStopAfter -= new MonitorWatcherEvent(DoMonitorStopAfter);
}
}
public IMonitor CreateMonitor(IMonitorConfig config)
{
if (config != null)
{
IMonitorType type = mSystemContext.MonitorTypeManager.GetConfig(config.Type);
return(CreateMonitor(config, type));
}
else
{
return(null);
}
}
public IMonitor CreateMonitor(string name)
{
IMonitorConfig config = mSystemContext.MonitorConfigManager.GetConfig(name) as IMonitorConfig;
if (config != null)
{
return(CreateMonitor(config));
}
else
{
return(null);
}
}
public bool Init(IMonitorManager manager, IMonitorConfig config, IMonitorType type)
{
mConfig = config;
mManager = manager;
mType = type;
if (!IsInit && Verify(ACOpts.Exec_Init))
{
mAlarmManager = new CMonitorAlarmManager(this);
mAlarmManager.AlarmQueueLength = mManager.SystemContext.AlarmQueueLength;
mAlarmManager.AlarmCheckInterval = mManager.SystemContext.AlarmCheckInterval;
mAlarmManager.AutoTransactDelay = mManager.SystemContext.AlarmAutoTransactDelay;
mAlarmManager.IsAutoTransact = false;
return(InternaInit(true));
}
return(false);
}
public void CheckAutoRun()
{
IMonitorConfig config = null;
foreach (MonitorBoxCtrl box in BoxList)
{
if ((box.IsLocal || box.Visible) && box.IsEnabled)
{
box.PlayVideo();
}
config = box.Config;
if (config != null)
{
config.StartWatch();
}
}
}
public bool CleanupMonitor(IMonitorConfig config)
{
StringBuilder sb = new StringBuilder(config.SystemContext.RequestHeadInfo);
sb.Append(config.Name + "<Monitor>");
sb.Append("Cleanup<Command>");
IRemoteSystem rs = config.SystemContext.MonitorSystem as IRemoteSystem;
if (rs != null)
{
return(WaitReliableSend(rs.Config.IP, rs.Config.Port, sb.ToString()));
}
else
{
return(WaitReliableSend(config.Host, config.Port, sb.ToString()));
}
}
public bool SyncMonitorState(IMonitorConfig config)
{
StringBuilder sb = new StringBuilder(config.SystemContext.RequestHeadInfo);
sb.Append(config.Name + "<Monitor>");
sb.Append("QueryState<Command>");
IRemoteSystem rs = config.SystemContext.MonitorSystem as IRemoteSystem;
if (rs != null)
{
return(Send(rs.Config.IP, rs.Config.Port, sb.ToString()));
}
else
{
return(Send(config.Host, config.Port, sb.ToString()));
}
}
public bool PreviewMonitorAlarmImage(IMonitorConfig config, string id, IntPtr hWnd)
{
StringBuilder sb = new StringBuilder(config.SystemContext.RequestHeadInfo);
sb.Append(config.Name + "<Monitor>");
sb.Append("GetMonitorAlarmImage<Command>");
sb.Append(id + "<ID>");
IRemoteSystem rs = config.SystemContext.MonitorSystem as IRemoteSystem;
if (rs != null)
{
return(Send(rs.Config.IP, rs.Config.Port, sb.ToString()));
}
else
{
return(Send(config.Host, config.Port, sb.ToString()));
}
}
public bool StopAlarmRecord(IMonitorConfig config, string alarmID)
{
StringBuilder sb = new StringBuilder(config.SystemContext.RequestHeadInfo);
sb.Append(config.Name + "<Monitor>");
sb.Append("StopSaveAlarmRecord<Command>");
sb.Append(alarmID + "<AlarmID>");
IRemoteSystem rs = config.SystemContext.MonitorSystem as IRemoteSystem;
if (rs != null)
{
return(Send(rs.Config.IP, rs.Config.Port, sb.ToString()));
}
else
{
return(Send(config.Host, config.Port, sb.ToString()));
}
}
private bool IsVisionAnalyze(IMonitorType type)
{
if (mSystemContext != null)
{
bool value = type.ACEnabled;
try
{
type.ACEnabled = false;
IMonitorConfig config = mSystemContext.MonitorConfigManager.CreateConfigInstance(type);
IVisionUserConfig visionConfig = config as IVisionUserConfig;
return(visionConfig != null);
}
finally
{
type.ACEnabled = value;
}
}
return(false);
}
public bool GetNextVisionAlarmRecord(IMonitorConfig config, string id, int hPlay)
{
StringBuilder sb = new StringBuilder(config.SystemContext.RequestHeadInfo);
sb.Append(config.Name + "<Monitor>");
sb.Append("GetNextVisionAlarmRecord<Command>");
sb.Append(id + "<ID>");
sb.Append(hPlay + "<PlayID>");
IRemoteSystem rs = config.SystemContext.MonitorSystem as IRemoteSystem;
if (rs != null)
{
return(Send(rs.Config.IP, rs.Config.Port, sb.ToString()));
}
else
{
return(Send(config.Host, config.Port, sb.ToString()));
}
}
public override void ShowEditDialog(IConfig config)
{
Text = "编辑监控应用 - [" + config.Name + "]";
mIsOk = false;
mManager = null;
mType = null;
mConfig = config as IMonitorConfig;
mSystemContext = config.SystemContext;
if (config.Verify(ACOpts.Manager_Modify, false))
{
SetTabPageShowState(mConfig.SystemContext.MonitorTypeManager.GetConfig(mConfig.Type));
InitTypeList(mSystemContext);
if (InitDialog())
{
ShowDialog();
}
}
}
public void ShowAddDialog(IMonitorType type)
{
Text = "新增监控应用";
mIsOk = false;
mManager = type.SystemContext.MonitorConfigManager;
mType = type;
mConfig = null;
mSystemContext = mManager.SystemContext;
if (type.Verify(ACOpts.Manager_Add, false))
{
SetTabPageShowState(mType);
InitTypeList(mSystemContext);
if (InitDialog())
{
ShowDialog();
}
}
}
private void DoMonitorStartAfter(IMonitorConfig config)
{
if (config.Name.Equals(mMonitorName))
{
mMonitor = config.SystemContext.MonitorManager.GetMonitor(mMonitorName);
if (mMonitor != null)
{
mMonitor.OnMonitorStateChanged -= new MonitorStateChanged(DoMonitorStateChanged);
mMonitor.OnMonitorStateChanged += new MonitorStateChanged(DoMonitorStateChanged);
mMonitor.OnMonitorAlarm -= new MonitorAlarmEvent(DoMonitorAlarm);
mMonitor.OnMonitorAlarm += new MonitorAlarmEvent(DoMonitorAlarm);
mMonitor.OnTransactAlarm -= new TransactAlarm(DoTransactAlarm);
mMonitor.OnTransactAlarm += new TransactAlarm(DoTransactAlarm);
mMonitor.RefreshState();
}
}
}
public bool CleanupVideoSource(IMonitorConfig config)
{
IVisionMonitorConfig vmConfig = config as IVisionMonitorConfig;
if (vmConfig != null)
{
StringBuilder sb = new StringBuilder(config.SystemContext.RequestHeadInfo);
sb.Append(vmConfig.VisionParamConfig.VSName + "<VideoSource>");
sb.Append("Cleanup<Command>");
IRemoteSystem rs = config.SystemContext.MonitorSystem as IRemoteSystem;
if (rs != null)
{
return(WaitReliableSend(rs.Config.IP, rs.Config.Port, sb.ToString()));
}
else
{
return(WaitReliableSend(config.Host, config.Port, sb.ToString()));
}
}
return(false);
}
private void RefreshInfo(AlarmPlayback playbox, int index, int count)
{
toolStripLabel_showInfo.Text = "";
toolStripLabel_alarmInfo.Text = "";
toolStripButton_init.Visible = false;
toolStripButton_start.Visible = false;
toolStripButton_stop.Visible = false;
toolStripButton_cleanup.Visible = false;
toolStripSeparator_fl_1.Visible = false;
toolStripSeparator_fl_2.Visible = false;
toolStripButton_realplay.Visible = false;
bool isVisionMonitor = false;
bool v = count > 0;
if (playbox != null)
{
CFuncNode node = playbox.LinkObj as CFuncNode;
if (node != null)
{
IMonitorConfig monitorConfig = node.ExtConfigObj as IMonitorConfig;
if (monitorConfig != null)
{
isVisionMonitor = ((node.ExtConfigObj as IVisionMonitorConfig) != null);
toolStripButton_realplay.Visible = isVisionMonitor;
toolStripLabel_showInfo.Text = "“" + node.OriginText + "”";
toolStripLabel_alarmInfo.Text = "报警信息(" + index + "/" + count + ")：";
IMonitor monitor = node.ExtObj as IMonitor;
if (monitor != null)
{
toolStripButton_init.Visible = !monitor.IsInit;
toolStripButton_start.Visible = !monitor.IsActive;
toolStripButton_stop.Visible = monitor.IsActive;
toolStripButton_cleanup.Visible = monitor.IsInit;
}
else
{
toolStripButton_init.Visible = true;
}
toolStripSeparator_fl_1.Visible = true;
toolStripSeparator_fl_2.Visible = true;
}
else
{
IConfigManager <IMonitorType> monitorType = node.ExtConfigObj as IConfigManager <IMonitorType>;
if (monitorType != null)
{
isVisionMonitor = true;
toolStripLabel_showInfo.Text = "“" + monitorType.SystemContext.Desc + "”";
toolStripLabel_alarmInfo.Text = "报警信息(" + index + "/" + count + ")：";
toolStripSeparator_fl_2.Visible = v;
}
}
}
}
toolStripLabel_alarmInfo.Visible = v;
toolStripButton_first.Visible = v && index > 0;
toolStripButton_prior.Visible = v && index > 0;
toolStripButton_next.Visible = v && index <= count;
toolStripButton_last.Visible = v && index <= count;
toolStripButton_backplay.Visible = v && isVisionMonitor;
toolStripButton_transact.Visible = v;
toolStripButton_clear.Visible = v;
toolStripButton_fl.Visible = v && !toolStripLabel_alarmInfo.Text.Equals("");
toolStripSeparator_fl.Visible = v || isVisionMonitor;
}
public bool InitMonitor(IMonitorConfig config)
{
IVisionMonitorConfig vmConfig = config as IVisionMonitorConfig;
if (vmConfig != null)
{
IVideoSourceConfig vsConfig = config.SystemContext.GetVideoSourceConfig(vmConfig.Watcher.ActiveVisionParamConfig.VSName);
if (vsConfig != null)
{
IVideoSourceType vsType = config.SystemContext.GetVideoSourceType(vsConfig.Type);
StringBuilder sb = new StringBuilder(config.SystemContext.RequestHeadInfo);
sb.Append(vsConfig.Name + "<VideoSource>");
sb.Append("Open;Play;InitKernel<Command>");
sb.Append(vsType.ToXml() + "<Type>");
sb.Append(vsConfig.ToXml() + "<Config><CommandSegment>");
IActionConfig ac;
IActionParam[] apList;
if (!config.Watcher.ActiveActionParamConfig.LocalAlarmAction)
{
apList = config.Watcher.ActiveActionParamConfig.GetAlarmActionList();
if (apList != null)
{
foreach (IActionParam pc in apList)
{
ac = config.SystemContext.ActionConfigManager.GetConfig(pc.Name);
if (ac != null)
{
IActionType at = config.SystemContext.ActionTypeManager.GetConfig(ac.Type);
if (at != null)
{
sb.Append(ac.Name + "<Action>");
sb.Append("Init;Start<Command>");
sb.Append(at.ToXml() + "<Type>");
sb.Append(ac.ToXml() + "<Config><CommandSegment>");
}
}
}
}
}
if (!config.Watcher.ActiveActionParamConfig.LocalTransactAction)
{
apList = config.Watcher.ActiveActionParamConfig.GetTransactActionList();
if (apList != null)
{
foreach (IActionParam pc in apList)
{
ac = config.SystemContext.ActionConfigManager.GetConfig(pc.Name);
if (ac != null)
{
IActionType at = config.SystemContext.ActionTypeManager.GetConfig(ac.Type);
if (at != null)
{
sb.Append(ac.Name + "<Action>");
sb.Append("Init;Start<Command>");
sb.Append(at.ToXml() + "<Type>");
sb.Append(ac.ToXml() + "<Config><CommandSegment>");
}
}
}
}
}
IMonitorType vuType = config.SystemContext.GetMonitorType(config.Type);
sb.Append(config.Name + "<Monitor>");
sb.Append("Init<Command>");
sb.Append(vuType.ToXml() + "<Type>");
sb.Append(config.ToXml() + "<Config>");
IRemoteSystem rs = config.SystemContext.MonitorSystem as IRemoteSystem;
if (rs != null)
{
return(WaitReliableSend(rs.Config.IP, rs.Config.Port, sb.ToString()));
}
else
{
return(WaitReliableSend(config.Host, config.Port, sb.ToString()));
}
}
}
else
{
IMonitorType vuType = config.SystemContext.GetMonitorType(config.Type);
StringBuilder sb = new StringBuilder(config.SystemContext.RequestHeadInfo);
sb.Append(config.Name + "<Monitor>");
sb.Append("Init<Command>");
sb.Append(vuType.ToXml() + "<Type>");
sb.Append(config.ToXml() + "<Config>");
IRemoteSystem rs = config.SystemContext.MonitorSystem as IRemoteSystem;
if (rs != null)
{
return(WaitReliableSend(rs.Config.IP, rs.Config.Port, sb.ToString()));
}
else
{
return(WaitReliableSend(config.Host, config.Port, sb.ToString()));
}
}
return(false);
}
public IMonitorWatcher CreateMonitorWatcher(IMonitorConfig config)
{
return(new CMonitorWatcher(config));
}
