public override void Update(ConfigurationSection rootNode, API api)
{
FollowedDriver = (int)api.GetData("CamCarIdx");
CurrentCamera = (int)api.GetData("CamGroupNumber");
List <Dictionary <string, object> > groups = rootNode.GetMapList("CameraInfo.Groups");
if (groups.Count == Cameras.Count)
{
return;
}
foreach (Dictionary <string, object> dict in groups)
{
int id = int.Parse(dict.GetDictValue("GroupNum"));
if (Cameras.FindIndex(c => c.Id == id) >= 0)
{
continue;
}
Camera cam = new Camera();
cam.Id = id;
cam.Name = dict.GetDictValue("GroupName");
Cameras.Add(cam);
}
}
public MainWindowViewModel(WrapPanel panelImages, ClientViewModel loggedClient)
{
_loggedClient = loggedClient;
getClientCameras();
for (int i = 0; i < _maxCameras; i++)
{
if (_clientCameras != null)
{
if (!String.IsNullOrEmpty(_clientCameras[i].IpAddress))
{
Cameras.Add(new Camera(_clientCameras[i].IpAddress));
}
else
{
Cameras.Add(new Camera());
}
}
else
{
Cameras.Add(new Camera());
}
}
EnterIPCommand = MyCommand;
StartRecordingCommand = new RelayCommand(startAllRecordings);
StopRecordingCommand = new RelayCommand(stopAllRecordings);
StopCameraCommand = new RelayCommand(stopAllCameras);
_panelImages = panelImages;
prepButtons(_viewType);
}
public Camera2D CriarCamera(int width, int heigth, PixelFormat pixelFormat)
{
Camera2D camera = new Camera2D(this, width, heigth, pixelFormat);
camera.Id = _id_camera++;
Camera2D ambiguo = Cameras.Where(x => x.Nome.StartsWith(camera.Nome)).LastOrDefault();
int number = 0;
if (ambiguo != null)
{
int length = camera.Nome.Length;
int.TryParse(ambiguo.Nome.Substring(length), out number);
}
camera.Nome += (++number).ToString("D2");
Cameras.Add(camera);
// Define a primeira camera adicionada como camera padrão
if (Cameras.Count == 1)
{
Camera = camera;
}
return(camera);
}
public static void AddCamera(Camera2D camera)
{
if (!Cameras.Contains(camera))
{
Cameras.Add(camera);
}
}
private void RefreshVideoCaptureDevices(IList <MediaDevice> videoCaptureDevices)
{
RunOnUiThread(() => {
Collection <MediaDevice> videoCaptureDevicesToRemove = new Collection <MediaDevice>();
foreach (MediaDevice videoCaptureDevice in Cameras)
{
if (videoCaptureDevices.FirstOrDefault(x => x.Id == videoCaptureDevice.Id) == null)
{
videoCaptureDevicesToRemove.Add(videoCaptureDevice);
}
}
foreach (MediaDevice removedVideoCaptureDevices in videoCaptureDevicesToRemove)
{
if (SelectedCamera != null && SelectedCamera.Id == removedVideoCaptureDevices.Id)
{
SelectedCamera = null;
}
Cameras.Remove(removedVideoCaptureDevices);
}
foreach (MediaDevice videoCaptureDevice in videoCaptureDevices)
{
if (Cameras.FirstOrDefault(x => x.Id == videoCaptureDevice.Id) == null)
{
Cameras.Add(videoCaptureDevice);
}
}
if ((SelectedCamera == null) && Cameras.Count > 0)
{
Debug.WriteLine("SelectedCamera RefreshVideoCaptureDevices() Update");
SelectedCamera = Cameras.FirstOrDefault();
}
});
}
public void AddCamera()
{
Camera camera = new Camera();
CameraViewModel vm = new CameraViewModel(camera);
Cameras.Add(vm);
_manager.cameras.Add(camera);
}
/// <summary>
/// Refresh video capture devices list.
/// </summary>
private async Task RefreshVideoCaptureDevices()
{
var videoCaptureDevices = (await _mediaSettings.GetVideoCaptureDevicesAsync()).Devices;
var removedDevicesInfo = "";
var videoCaptureDevicesToRemove = new Collection <MediaDevice>();
Cameras = Cameras ?? new ObservableCollection <MediaDevice>();
foreach (
var videoCaptureDevice in
Cameras.Where(
videoCaptureDevice =>
videoCaptureDevices.FirstOrDefault(x => x.Id == videoCaptureDevice.Id) == null))
{
videoCaptureDevicesToRemove.Add(videoCaptureDevice);
if (EtwStatsEnabled)
{
removedDevicesInfo += "id = " + videoCaptureDevice.Id + " name = " +
videoCaptureDevice.Name + "\n";
}
}
foreach (var removedVideoCaptureDevices in videoCaptureDevicesToRemove)
{
if (SelectedCamera != null && SelectedCamera.Id == removedVideoCaptureDevices.Id)
{
SelectedCamera = null;
}
Cameras.Remove(removedVideoCaptureDevices);
}
if (removedDevicesInfo != "")
{
ETWEventLogger.Instance.LogEvent("Video Device(s) Removed", removedDevicesInfo,
DateTimeOffset.Now.ToUnixTimeMilliseconds().ToString());
}
var addedDevicesInfo = "";
foreach (var videoCaptureDevice in videoCaptureDevices)
{
if (Cameras.FirstOrDefault(x => x.Id == videoCaptureDevice.Id) == null)
{
Cameras.Add(videoCaptureDevice);
if (EtwStatsEnabled)
{
addedDevicesInfo += "id = " + videoCaptureDevice.Id + " name = " +
videoCaptureDevice.Name + "\n";
}
}
}
if (addedDevicesInfo != "")
{
ETWEventLogger.Instance.LogEvent("Video Device(s) Added", addedDevicesInfo,
DateTimeOffset.Now.ToUnixTimeMilliseconds().ToString());
}
if (SelectedCamera == null)
{
SelectedCamera = Cameras.FirstOrDefault();
}
}
public Scene(PictureBox canvas)
{
this.canvas = canvas;
Camera = new Camera();
ResetCamera();
Cameras.Add(Camera);
Lights.Add(new Vector3D(0, 150, -150));
Light = Lights[0];
}
public Camera AddCamera(Camera camera)
{
if (!Cameras.Contains(camera))
{
Cameras.Add(camera);
}
return(camera);
}
private void RefreshCamera()
{
CloseSession();
Cameras.Clear();
foreach (var camera in CameraHandler.GetCameraList())
{
Cameras.Add(camera);
}
SelectedCamera = Cameras.FirstOrDefault();
}
/// <summary>
/// Adds a camera at the specified position.
/// </summary>
void AddCamera(double x, double y, double z)
{
CameraBox camera = new CameraBox();
camera.PropertyChanged += CameraPropertyChanged;
camera.NearPlaneDistance = 0.1;
camera.FarPlaneDistance = 1000;
camera.Position = new Point3D(x, y, z);
camera.LookAtOrigin();
Cameras.Add(camera);
}
public async Task <bool> Authenticate()
{
try
{
_httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.ASCII.GetBytes(GetCredentials())));
var response = await _httpClient.GetAsync(string.Format("/Initialize?Latitude=0&Longitude=0&DeviceId={0}", Guid.NewGuid()));
response.EnsureSuccessStatusCode(); // Throw if not a success code.
var stream = await response.Content.ReadAsStreamAsync();
var serializer = new XmlSerializer(typeof(WebResponse));
var webResponse = serializer.Deserialize(stream) as WebResponse;
if (webResponse != null)
{
if (webResponse.Header.Error == ErrorType.None)
{
_httpClient.DefaultRequestHeaders.Authorization = null; // Need to clear so following commands won't be treated as Initialize requests
SessionId = webResponse.Header.SessionId;
Cameras.Clear();
foreach (var camera in webResponse.Body.Cameras)
{
Utils.Trace(camera.Name + " " + camera.Id);
Cameras.Add(camera);
}
// We must periodically refresh the camera list, otherwise our session will timeout after 5*SRI if AutoLogoff set in AC
_camerasRefreshTimer.Interval = TimeSpan.FromSeconds(webResponse.Body.ClientConfiguration.StatusRefreshInterval).TotalMilliseconds;
_camerasRefreshTimer.Start();
return(true); // Authenticated successfully
}
Utils.Trace("UnitedVmsProvider Authenticate Error: " + webResponse.Header.Error);
var errorReason = webResponse.Header.Error == ErrorType.AuthorizationFailed
? "Credenciales inválidas o licencia vencida."
: default(string);
throw new DvtelVmsException($"Dvtel Vms Authenticate Error: {webResponse.Header.Error}. {errorReason}", webResponse.Header.Error);
}
}
catch (Exception ex)
{
if (ex is DvtelVmsException)
{
throw;
}
Utils.Trace("UnitedVmsProvider Authenticate Error: " + ex.Message, ex);
throw new DvtelVmsException("Dvtel Vms Authenticate Error: " + ErrorType.Unknown, ex);
}
throw new DvtelVmsException("Dvtel Vms Authenticate Error: Unserializable response.");
}
public override void Initialize()
{
base.Initialize();
// Cameras
var camera = new Camera("Camera 1", Game, World, new Vector2(2015, 2673));
camera.DefaultZoom();
Cameras.Add(0, camera);
SelectCamera(0);
}
public void SaveContext()
{
if (SettingsContext.Update != null)
{
SettingsContext.Update.SetConfig(SettingsContext);
}
else
{
Cameras.Add(new CameraViewModel(SettingsContext));
SettingsContext = null;
}
Save();
}
/// <summary>
/// Updates the cameras list with the cameras found in <paramref name="ctx"/>.
/// </summary>
/// <param name="ctx">The context to query the cameras from.</param>
public void UpdateCameras(Context ctx)
{
foreach (var device in ctx.QueryDevices())
{
var serial = device.Info.GetInfo(CameraInfo.SerialNumber);
if (Cameras.Exists(c => c.Serial == serial))
{
continue;
}
Cameras.Add(new Camera(serial));
}
}
/// <summary>
/// Gets all data sources (cameras) from the VideoXpert system and stores them in the <see cref="Cameras"/> list.
/// </summary>
/// <returns>The GetCameras Task.</returns>
public static async Task GetCameras()
{
if (system == null)
{
return;
}
Cameras.Clear();
var cameras = await Task.Run(() => system.DataSources);
foreach (var camera in cameras)
{
Cameras.Add(camera);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ZipatoOthers"/> class.
/// The list of UUIDs from the SettingsData is used to create the device instances.
/// </summary>
/// <param name="zipato"></param>
public ZipatoOthers(IZipato zipato)
{
_zipato = zipato;
foreach (var uuid in zipato.OthersInfo.Cameras)
{
Cameras.Add(new Camera(zipato, uuid));
}
foreach (var uuid in zipato.OthersInfo.Scenes)
{
Scenes.Add(new Scene(zipato, uuid));
}
Status = zipato?.Data.Status ?? Uncertain;
}
/// <summary>
/// Set the active camera to the camera with the specified index.
/// </summary>
/// <param name="cameraIndex">Index of the camera</param>
/// <param name="createCamera">Creates a new camera if true</param>
private void SelectCamera(int cameraIndex, bool createCamera = false)
{
if (createCamera && !Cameras.ContainsKey(cameraIndex))
{
var camera = new Camera("Camera " + (cameraIndex + 1), Game, World, Vector2.Zero);
camera.DefaultZoom();
Cameras.Add(cameraIndex, camera);
Log.Debug("\"{0}\" was created", camera.Name);
}
if (Cameras.ContainsKey(cameraIndex))
{
ActiveCameraIndex = cameraIndex;
}
}
internal Room(RoomIdentifier identifier)
{
Identifier = identifier;
if (Identifier == null)
{
Logger.Get.Warn("NULL Room");
}
RoomType = Identifier.Name;
RoomShape = Identifier.Shape;
GameObject = identifier.gameObject;
ID = Identifier.UniqueId;
LightController = GameObject.GetComponentInChildren <FlickerableLightController>();
foreach (var cam in GameObject.GetComponentsInChildren <Camera079>())
{
Cameras.Add(new Camera(cam, this));
}
}
public async Task GetCameras()
{
try
{
if (SessionId != Guid.Empty)
{
var response = await _httpClient.GetAsync("/GetCameras?SessionId=" + SessionId);
response.EnsureSuccessStatusCode(); // Throw if not a success code.
var stream = await response.Content.ReadAsStreamAsync();
var serializer = new XmlSerializer(typeof(WebResponse));
var webResponse = serializer.Deserialize(stream) as WebResponse;
if (webResponse != null)
{
if (webResponse.Header.Error == ErrorType.None)
{
Cameras.Clear();
foreach (var camera in webResponse.Body.Cameras)
{
Utils.Trace(camera.Name + " " + camera.Id);
Cameras.Add(camera);
}
// Report to registered listeners the updated list of cameras
if (_cameraListUpdated != null)
{
_cameraListUpdated.Invoke(this, Cameras);
}
}
else
{
Utils.Trace("UnitedVmsProvider GetCameras Error: " + webResponse.Header.Error);
}
}
}
}
catch (Exception ex)
{
Utils.Trace("UnitedVmsProvider GetCameras Error", ex);
}
}
internal static Camera TryGet(IntPtr handle)
{
if (handle == IntPtr.Zero)
{
return(null);
}
var camera = Cameras.FirstOrDefault(x => x.Handle == handle);
if (camera != null)
{
return(camera);
}
camera = new Camera();
camera.Handle = handle;
Cameras.Add(camera);
return(camera);
}
/// <summary>
/// Initialize Globales & Default Values
/// </summary>
/// <param name="game"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="zoom"></param>
internal static void Initialize(FlxGame game, int width, int height, float zoom)
{
Game = game;
Width = width;
Height = height;
Camera = new FlxCamera();
Camera.SamplerState = SamplerState.PointClamp;
Camera.BlendState = BlendState.AlphaBlend;
//Cameras = new List<FlxCamera>();
Cameras.Add(Camera);
InputManager = new InputManager();
Random = new Random();
WorldBounds = new Rectangle(0, 0, Width, Height);
Plugins = new PluginFrontEnd();
}
private void ParseCamera(IEnumerable <XElement> cameraNode, IEnumerable <XElement> cameraInfos)
{
foreach (var camera in cameraNode.Descendants("camera"))
{
String id = camera.Attribute("id").Value;
String target = "";
float xfov = float.NaN, aspect;
if (camera.Element("optics").Element("technique_common").Element("perspective").Element("xfov") != null)
{
float.TryParse(camera.Element("optics").Element("technique_common").Element("perspective").Element("xfov").Value, out xfov);
}
if (camera.Element("optics").Element("technique_common").Element("perspective").Element("yfov") != null)
{
float.TryParse(camera.Element("optics").Element("technique_common").Element("perspective").Element("yfov").Value, out xfov);
}
float.TryParse(camera.Element("optics").Element("technique_common").Element("perspective").Element("aspect_ratio").Value, out aspect);
int height = (int)(width / aspect);
//float yfov = xfov / aspect;
Vector3 lookAt = Vector3.Zero;
Vector3 eye = Vector3.Zero;
Vector3 up = new Vector3(0, 1, 0);
foreach (var node in cameraInfos.Elements("node"))
{
foreach (var instanceCamera in node.Elements("instance_camera"))
{
if (instanceCamera.Attribute("url").Value.Replace("#", "").Equals(id))
{
if (instanceCamera.Parent.Element("matrix") != null)
{
Vector4 vec = new Vector4(0, 0, 0, 1);
Vector4 res = ParseMatrix(instanceCamera.Parent.Element("matrix").Value).Transform(vec);
eye = new Vector3(res.X, res.Y, res.Z);
}
else if (instanceCamera.Parent.Element("translate") != null)
{
eye = ParseVector(instanceCamera.Parent.Element("translate").Value);
}
}
foreach (var technique in instanceCamera.Parent.Element("extra").Elements("technique"))
{
target = technique.Value.Replace("#", "");
}
}
if (node.Attribute("name").Value.Equals(target))
{
if (node.Element("matrix") != null)
{
Vector4 vec = new Vector4(0, 0, 0, 1);
Vector4 res = ParseMatrix(node.Element("matrix").Value).Transform(vec);
lookAt = new Vector3(res.X, res.Y, res.Z);
}
else if (node.Element("translate") != null)
{
lookAt = ParseVector(node.Element("translate").Value);
}
}
}
Cameras.Add(id, new PinholeCamera()
{
Eye = eye, FieldOfView = xfov, LookAt = lookAt, AspectRation = aspect, ScreenHeight = height, ScreenWidth = width, Up = up
});
}
}
public static void AddCamera(string cameraLabel, JadeCamera camera)
{
Cameras.Add(cameraLabel, camera);
}
protected internal override void Creation()
{
//this.ClearColor = new Color256(0.11D, 0.11D, 0.11D, 1.0D);
Cameras.Add(this);
}
public Camera() : base()
{
Cameras.Add(this);
}
internal void OnLoad()
{
#if ANDROID
Graphics = new OpenGLESApi();
#elif !USE_DX
Graphics = new OpenGLApi(window);
#else
Graphics = new Direct3D9Api(window);
#endif
Graphics.MakeApiInfo();
ErrorHandler.ExtraInfo = Graphics.ApiInfo;
#if ANDROID
Drawer2D = new CanvasDrawer2D(Graphics);
#else
Drawer2D = new GdiPlusDrawer2D(Graphics);
#endif
UpdateClientSize();
Entities = new EntityList(this);
TextureCache.Init();
#if SURVIVAL_TEST
if (Options.GetBool(OptionsKey.SurvivalMode, false))
{
Mode = new SurvivalGameMode();
}
else
{
Mode = new CreativeGameMode();
}
#endif
Input = new InputHandler(this);
ParticleManager = new ParticleManager(); Components.Add(ParticleManager);
TabList = new TabList(); Components.Add(TabList);
LoadOptions();
LoadGuiOptions();
Chat = new Chat(); Components.Add(Chat);
Events.OnNewMap += OnNewMapCore;
Events.OnNewMapLoaded += OnNewMapLoadedCore;
Events.TextureChanged += TextureChangedCore;
Events.LowVRAMDetected += OnLowVRAMDetected;
BlockInfo.Allocate(256);
BlockInfo.Init();
ModelCache = new ModelCache(this);
ModelCache.InitCache();
Downloader = new AsyncDownloader(Drawer2D); Components.Add(Downloader);
Lighting = new BasicLighting(); Components.Add(Lighting);
Drawer2D.UseBitmappedChat = ClassicMode || !Options.GetBool(OptionsKey.UseChatFont, false);
Drawer2D.BlackTextShadows = Options.GetBool(OptionsKey.BlackText, false);
Graphics.Mipmaps = Options.GetBool(OptionsKey.Mipmaps, false);
Atlas1D.game = this;
Atlas2D.game = this;
Animations = new Animations(); Components.Add(Animations);
Inventory = new Inventory(); Components.Add(Inventory);
Inventory.Map = new BlockID[BlockInfo.Count];
BlockInfo.SetDefaultPerms();
World = new World(this);
LocalPlayer = new LocalPlayer(this); Components.Add(LocalPlayer);
Entities.List[EntityList.SelfID] = LocalPlayer;
MapRenderer = new MapRenderer(this);
ChunkUpdater = new ChunkUpdater(this);
EnvRenderer = new EnvRenderer(); Components.Add(EnvRenderer);
MapBordersRenderer = new MapBordersRenderer(); Components.Add(MapBordersRenderer);
string renType = Options.Get(OptionsKey.RenderType, "normal");
int flags = CalcRenderType(renType);
if (flags == -1)
{
flags = 0;
}
MapBordersRenderer.legacy = (flags & 1) != 0;
EnvRenderer.legacy = (flags & 1) != 0;
EnvRenderer.minimal = (flags & 2) != 0;
if (IPAddress == null)
{
Server = new Singleplayer.SinglePlayerServer(this);
}
else
{
Server = new Network.NetworkProcessor(this);
}
Components.Add(Server);
Graphics.LostContextFunction = Server.Tick;
Cameras.Add(new FirstPersonCamera(this));
Cameras.Add(new ThirdPersonCamera(this, false));
Cameras.Add(new ThirdPersonCamera(this, true));
Camera = Cameras[0];
UpdateProjection();
Gui = new GuiInterface(this); Components.Add(Gui);
CommandList = new CommandList(); Components.Add(CommandList);
SelectionManager = new SelectionManager(); Components.Add(SelectionManager);
WeatherRenderer = new WeatherRenderer(); Components.Add(WeatherRenderer);
HeldBlockRenderer = new HeldBlockRenderer(); Components.Add(HeldBlockRenderer);
Graphics.DepthTest = true;
Graphics.DepthTestFunc(CompareFunc.LessEqual);
//Graphics.DepthWrite = true;
Graphics.AlphaBlendFunc(BlendFunc.SourceAlpha, BlendFunc.InvSourceAlpha);
Graphics.AlphaTestFunc(CompareFunc.Greater, 0.5f);
Culling = new FrustumCulling();
Picking = new PickedPosRenderer(); Components.Add(Picking);
AudioPlayer = new AudioPlayer(); Components.Add(AudioPlayer);
AxisLinesRenderer = new AxisLinesRenderer(); Components.Add(AxisLinesRenderer);
SkyboxRenderer = new SkyboxRenderer(); Components.Add(SkyboxRenderer);
List <string> nonLoaded = PluginLoader.LoadAll(this);
for (int i = 0; i < Components.Count; i++)
{
Components[i].Init(this);
}
ExtractInitialTexturePack();
for (int i = 0; i < Components.Count; i++)
{
Components[i].Ready(this);
}
InitScheduledTasks();
if (nonLoaded != null)
{
for (int i = 0; i < nonLoaded.Count; i++)
{
Overlay warning = new PluginOverlay(this, nonLoaded[i]);
Gui.ShowOverlay(warning, false);
}
}
LoadIcon();
string connectString = "Connecting to " + IPAddress + ":" + Port + "..";
if (Graphics.WarnIfNecessary(Chat))
{
MapBordersRenderer.UseLegacyMode(true);
EnvRenderer.UseLegacyMode(true);
}
Gui.SetNewScreen(new LoadingScreen(this, connectString, ""));
Server.BeginConnect();
}
/*
public static void initVLC()
{
if (Environment.Is64BitOperatingSystem)
{
// Set libvlc.dll and libvlccore.dll directory path
VlcContext.LibVlcDllsPath = @"VLC\";
// Set the vlc plugins directory path
VlcContext.LibVlcPluginsPath = @"VLC\plugins";
}
else
{
// Set libvlc.dll and libvlccore.dll directory path
VlcContext.LibVlcDllsPath = @"VLC\";
// Set the vlc plugins directory path
VlcContext.LibVlcPluginsPath = @"VLC\plugins";
}
// Ignore the VLC configuration file
VlcContext.StartupOptions.IgnoreConfig = true;
#if DEBUG
// Enable file based logging
VlcContext.StartupOptions.LogOptions.LogInFile = true;
// Shows the VLC log console (in addition to the applications window)
VlcContext.StartupOptions.LogOptions.ShowLoggerConsole = true;
#else
VlcContext.StartupOptions.LogOptions.ShowLoggerConsole = false;
VlcContext.StartupOptions.LogOptions.LogInFile = false;
#endif
// Set the log level for the VLC instance
VlcContext.StartupOptions.LogOptions.Verbosity = VlcLogVerbosities.Debug;
VlcContext.StartupOptions.AddOption("--ffmpeg-hw");
// Disable showing the movie file name as an overlay
VlcContext.StartupOptions.AddOption("--no-video-title-show");
VlcContext.StartupOptions.AddOption("--rtsp-tcp");
VlcContext.StartupOptions.AddOption("--rtsp-mcast");
// VlcContext.StartupOptions.AddOption("--rtsp-host=192.168.10.35");
// VlcContext.StartupOptions.AddOption("--sap-addr=192.168.10.35");
VlcContext.StartupOptions.AddOption("--rtsp-port=8554");
VlcContext.StartupOptions.AddOption("--rtp-client-port=8554");
VlcContext.StartupOptions.AddOption("--sout-rtp-rtcp-mux");
VlcContext.StartupOptions.AddOption("--rtsp-wmserver");
VlcContext.StartupOptions.AddOption("--file-caching=18000");
VlcContext.StartupOptions.AddOption("--sout-rtp-caching=18000");
VlcContext.StartupOptions.AddOption("--sout-rtp-port=8554");
VlcContext.StartupOptions.AddOption("--sout-rtp-proto=tcp");
VlcContext.StartupOptions.AddOption("--network-caching=1000");
VlcContext.StartupOptions.AddOption("--vout-filter=wall");
VlcContext.StartupOptions.AddOption("--wall-cols=2");
VlcContext.StartupOptions.AddOption("--wall-rows=2");
// Pauses the playback of a movie on the last frame
VlcContext.StartupOptions.AddOption("--play-and-pause");
VlcContext.CloseAll();
// Initialize the VlcContext
VlcContext.Initialize();
}
*/
private void Application_Startup(object sender, StartupEventArgs e)
{
bool login = true;
Rows = new List<CsvRow>();
RowsSend = new List<CsvRow>();
Fonts = ExCss.ReadFile(@"Asset\Fonts\font-awesome.min.css");
Timethread = new Thread(CheckTimeFunctionThread);
Timethread.IsBackground = true;
listSerialPort = new List<SerialPort>();
QueueCMD = new Queue<string>();
m_bInitSDK = CHCNetSDK.NET_DVR_Init();
if (m_bInitSDK == false)
{
MessageBox.Show("NET_DVR_Init error!");
return;
}
if (!File.Exists(_FILE_CSV_COMMAND))
{
File.Create(_FILE_CSV_COMMAND);
}
if (!File.Exists(_FILE_Send_COMMAND))
{
File.Create(_FILE_Send_COMMAND);
}
// initVLC();
DefineCommand = CommandDefine.Read(_FILE_DEFINE_COMMAND);
setting = Config.Read(_FILE_Config);
if (!Directory.Exists("Data"))
{
DirectoryInfo di = Directory.CreateDirectory("Data");
di.Attributes = FileAttributes.Directory | FileAttributes.Hidden;
}
if (!Directory.Exists(setting.Folder))
{
Directory.CreateDirectory(setting.Folder);
}
curDate = DateTime.Now;
Timethread.Start();
curFolder = System.IO.Path.Combine(setting.Folder, this.curDate.ToString("dd-MM-yyyy"));
if (!Directory.Exists(curFolder))
{
Directory.CreateDirectory(curFolder);
}
DataUser = Users.read(@"Data\User.mtc");
if (DataUser == null)
{
DataUser = new Users();
User root = new User("root", 1);
root.Pass = "******".toMD5();
root.type = 0;
root.FullName = "Root";
DataUser.Add(root);
Users.write(_FILE_User_Data, DataUser);
}
DataCamera = Cameras.Read(_FILE_Camera_Data);
DataPreset = Presets.Read(_FILE_PRESET_DATA);
DataAlarm = Alarms.Read(_FILE_Alarm_Data);
this.checkFile = new Thread(checkFileFunctionThread);
checkFile.IsBackground = true;
this.checkFile.Start();
#if DEBUG
if (DataCamera.Count == 0)
{
Camera camera = new Camera("192.168.10.199");
camera.name = "Camera Demo";
camera.channel = 1;
camera.port = 8000;
camera.admin = "admin";
camera.pass = "******";
camera.icon = "fa-video-camera";
DataCamera.Add(camera);
}
if (DataUser.Datas.Count < 2)
{
User root = new User("admin", 2);
root.Pass = "******".toMD5();
root.type = 1;
root.FullName = "Admin";
DataUser.Add(root);
User root2 = new User("htdm",3);
root2.Pass = "******".toMD5();
root2.type = 2;
root2.FullName = "Camera";
DataUser.Add(root2);
Users.write(_FILE_User_Data, DataUser);
}
#endif
var listCom = getListCOM();
if (listCom.Length > 0)
{
foreach (string i in listCom)
{
try
{
SerialPort serialPort = new SerialPort();
serialPort = new SerialPort();
serialPort.openCOM(i, BAUDRATE, DATABITS, StopBits.One);
serialPort.DataReceived += serialPort_DataReceived;
serialPort.sendCommand("#0$");
listSerialPort.Add(serialPort);
}
catch (Exception)
{
}
}
}
Map = Map.Read(_FILE_Map_Data);
for (int i = 0; i != e.Args.Length; i += 2)
{
if (e.Args[i] == "-u")
{
string hash = e.Args[i + 1];
User u = App.DataUser.Login(hash);
if (u != null)
{
login = false;
App.User = u;
}
}
else if (e.Args[i] == "-mode")
{
Mode = (Camera_Final.Mode)int.Parse(e.Args[i + 1]);
}
}
if (login)
{
this.MainWindow = new Login();
}
else
{
this.MainWindow = new MainWindow();
}
this.MainWindow.Show();
}
/// <summary>
/// A method which allows to add a camera to the list while setting up the floor.
/// </summary>
/// <param name="camera">A dummy camera, put on a floor image in the floor planning window</param>
public void AddCamera(Camera camera)
{
Cameras.Add(camera);
}
public Task CreateCameraAsync(Camera camera)
{
Cameras.Add(camera);
return(EmptyTask);
}
internal static void LoadContent(GraphicsDevice gd)
{
JadeCamera defaultCamera = new JadeCamera(gd.Viewport);
Cameras.Add("JadeEngine.JadeCameras.Default", defaultCamera);
SetActiveCamera("JadeEngine.JadeCameras.Default");
}
