2997 lines
118 KiB
C#
2997 lines
118 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Data;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
using System.Threading;
|
|
using System.Resources;
|
|
using MapGoogle;
|
|
using Telerik.WinControls.UI;
|
|
using Telerik.WinControls;
|
|
using Telerik.WinControls.UI.Docking;
|
|
using SafeMobileLib;
|
|
using System.IO;
|
|
using Dispatcher.maptab.UIClasses;
|
|
using Dispatcher.maptab;
|
|
using System.Linq;
|
|
|
|
namespace Safedispatch_4_0
|
|
{
|
|
/// <summary>
|
|
/// This class implements the history tab.</summary>
|
|
/// <remarks>
|
|
/// The history tab contains two areas, left and right. On the left side
|
|
/// the vehicle selection and intervals are made, and on the right side information
|
|
/// is displayed according to the criteria from the left</remarks>
|
|
|
|
public partial class HistoryTab : UserControl
|
|
{
|
|
private bool mapIsDirty = false;
|
|
public bool KillTimerActive = false;
|
|
public String calcADDr, endtimegreate,onlyonecar;
|
|
public Boolean docLoad = false;
|
|
private Int32 loadcnt = 0;
|
|
private Int32 timestart = 0, timestop = 0;
|
|
private volatile Pushpinx pp = null;
|
|
//private volatile Int32 timeTemp = 0;
|
|
private volatile bool first = true;
|
|
private volatile Hashtable DataPos = new Hashtable();
|
|
private volatile Hashtable DataPosOutSide = new Hashtable();
|
|
private volatile Boolean hitLimit = false;
|
|
private String Nodata = "";
|
|
private String plsselcectcar = "";
|
|
private String youhave = "", googleWork = "", contorsmall = "", outsideBrowser ="", setdefault ="", selectinterval ="";
|
|
private Boolean AniStateExpande = false;
|
|
private volatile Boolean retrynew;
|
|
private volatile Boolean inwhile =false;
|
|
public static volatile Boolean StreetViewOpened = false;
|
|
public ArrayList Point_for_play = new ArrayList();
|
|
private Image theme24H_Image = Utils.ChangeColor(Dispatcher.Properties.Resources.h_24h, MainForm2.ButtonColor);
|
|
private Image themelFilter_Image = Utils.ChangeColor(Dispatcher.Properties.Resources.h_filter, MainForm2.ButtonColor);
|
|
private bool isLoaded = false;
|
|
|
|
private void setLanguage()
|
|
{
|
|
calcADDr = MainForm2.returnLNGString("retrevAddr");
|
|
endtimegreate = MainForm2.returnLNGString("endtimegreate");
|
|
toolWindow2.Text = MainForm2.returnLNGString("tabPage1");
|
|
|
|
onlyonecar = MainForm2.returnLNGString("onlyonecar");
|
|
plsselcectcar = MainForm2.returnLNGString("selval");
|
|
|
|
//rdpEndTime.Culture = MainForm2.culture;
|
|
//rdpStartTime.Culture = MainForm2.culture;
|
|
|
|
|
|
string startTimeCustomFormat = MainForm2.DayFirst ? "dd/MM/yyyy hh:mm tt" : "MM/dd/yyyy hh:mm tt";
|
|
|
|
if (MainForm2.is24hours)
|
|
startTimeCustomFormat = MainForm2.DayFirst ? "dd/MM/yyyy HH:mm" : "MM/dd/yyyy HH:mm";
|
|
|
|
rdpStartTime.CustomFormat = startTimeCustomFormat;
|
|
// copy format to the end date picker
|
|
rdpEndTime.CustomFormat = rdpStartTime.CustomFormat;
|
|
|
|
|
|
//MainForm2.HistSpeedLimit.ToString()
|
|
Nodata = MainForm2.returnLNGString("nodata");//nodata;
|
|
youhave = MainForm2.returnLNGString("youhave");
|
|
googleWork = MainForm2.returnLNGString("googleWork");
|
|
outsideBrowser = MainForm2.returnLNGString("outsideBrowser");
|
|
setdefault = MainForm2.returnLNGString("setdefault");
|
|
contorsmall = MainForm2.returnLNGString("contorsmall");
|
|
selectinterval = MainForm2.returnLNGString("selectSmall");
|
|
labelUnits.Text = MainForm2.returnLNGString("GrpUnits");
|
|
windowHistoryResult.Text = MainForm2.returnLNGString("historyResult");
|
|
toolWindow4.Text = MainForm2.returnLNGString("historySearchParameters");
|
|
rtbFilterUnits.NullText = MainForm2.returnLNGString("Typetosearchunit");
|
|
rlHistoryForSelectedUnits.Text = MainForm2.returnLNGString("historyForSelectedUnits");
|
|
radLabel6.Text = MainForm2.returnLNGString("historyFrom");
|
|
rlUntil.Text = MainForm2.returnLNGString("historyUntil");
|
|
rcbSpeedLower.Text = MainForm2.returnLNGString("lowerSpeed");
|
|
rcbSpeedLower.Text = (!MainForm2.isInMile) ? string.Format(rcbSpeedLower.Text, (MainForm2.returnLNGString("kmh"))) : string.Format(rcbSpeedLower.Text, (MainForm2.returnLNGString("milesh")));
|
|
rlPositionDisplayMs.Text = MainForm2.returnLNGString("posDisplay");
|
|
rbResetHistory.Text = MainForm2.returnLNGString("reset");
|
|
rbSearchHistory.Text = MainForm2.returnLNGString("searchHistory");
|
|
rcbShowGeofence.Text = MainForm2.returnLNGString("showGeofences");
|
|
rcbShowLabels.Text = MainForm2.returnLNGString("showPoints");
|
|
labelSlideshow.Text = MainForm2.returnLNGString("slideshowSearchResult");
|
|
rlAnimation.Text = MainForm2.returnLNGString("slideshowTimeline");
|
|
rcbSpeedUpper.Text = MainForm2.returnLNGString("upperSpeed");
|
|
rcbSpeedUpper.Text = (!MainForm2.isInMile) ? string.Format(rcbSpeedUpper.Text, (MainForm2.returnLNGString("kmh"))) : string.Format(rcbSpeedUpper.Text, (MainForm2.returnLNGString("milesh")));
|
|
rcbComputeAddress.Text = MainForm2.returnLNGString("compAddr");
|
|
btStopCalc.Text = MainForm2.returnLNGString("stop");
|
|
|
|
}
|
|
|
|
|
|
public HistoryTab(MainForm2 parentParam, String tabNameParam)
|
|
{
|
|
tabName = tabNameParam;
|
|
parent = parentParam;
|
|
|
|
smdbObj = new SMdb_access();
|
|
|
|
InitializeComponent();
|
|
|
|
|
|
#region STYLE THEMING
|
|
labelUnits.ForeColor = labelSlideshow.ForeColor = MainForm2.LabelColor;
|
|
rbSearchHistory.ButtonElement.ButtonFillElement.BackColor = MainForm2.ButtonColor;
|
|
rbResetHistory.ButtonElement.ButtonFillElement.BackColor = MainForm2.ButtonColor;
|
|
|
|
// play buttons
|
|
rbPrev.ButtonElement.ButtonFillElement.BackColor = MainForm2.ButtonColor;
|
|
rbPause.ButtonElement.ButtonFillElement.BackColor = MainForm2.ButtonColor;
|
|
rbNext.ButtonElement.ButtonFillElement.BackColor = MainForm2.ButtonColor;
|
|
rbPlay.ButtonElement.ButtonFillElement.BackColor = MainForm2.ButtonColor;
|
|
rbStop.ButtonElement.ButtonFillElement.BackColor = MainForm2.ButtonColor;
|
|
|
|
pb24H.Image = Utils.ChangeColor(Dispatcher.Properties.Resources.h_24h, MainForm2.ButtonColor);
|
|
theme24H_Image = pb24H.Image;
|
|
pbFilter.Image = Utils.ChangeColor(Dispatcher.Properties.Resources.i_search, MainForm2.ButtonColor);
|
|
#endregion
|
|
|
|
|
|
// set theme for the Message Box
|
|
RadMessageBox.SetThemeName("TelerikMetroBlue");
|
|
|
|
// add filter rule/predicate to the units tree
|
|
treeViewUnits.TreeViewElement.FilterPredicate = FilterNode;
|
|
|
|
|
|
// create the custom column which will display the positions in
|
|
// the new way
|
|
HistoryGridColumn ctc = new HistoryGridColumn("history");
|
|
ctc.AllowResize = true;
|
|
ctc.Name = "history";
|
|
ctc.FieldName = "history";
|
|
ctc.HeaderText = "history";
|
|
ctc.AutoSizeMode = BestFitColumnMode.AllCells;
|
|
ctc.HeaderTextAlignment = ContentAlignment.MiddleLeft;
|
|
ctc.SortOrder = RadSortOrder.Ascending;
|
|
|
|
|
|
this.gridHistoryPoints.TableElement.RowHeight = 55;
|
|
this.gridHistoryPoints.Columns.Add(ctc);
|
|
this.gridHistoryPoints.Columns.Move(ctc.Index, 0);
|
|
|
|
|
|
|
|
// create the toolTip that will be displayed when the user sets a pattern
|
|
// over the pictureBox
|
|
toolTipHelp = new ToolTip();
|
|
toolTipHelp.ToolTipTitle = "";
|
|
toolTipHelp.AutoPopDelay = 0;
|
|
toolTipHelp.InitialDelay = 0;
|
|
toolTipHelp.ReshowDelay = 0;
|
|
toolTipHelp.IsBalloon = false;
|
|
toolTipHelp.ShowAlways = true;
|
|
|
|
|
|
// add the groups and the units to the tree view
|
|
populateListBoxGroup();
|
|
populateListBoxUnits();
|
|
|
|
// set the values for start and end time
|
|
rdpStartTime.Value = DateTime.Now.AddDays(-1);
|
|
rdpEndTime.Value = DateTime.Now;
|
|
|
|
// disable the history result window
|
|
foreach (Control ctr in windowHistoryResult.Controls)
|
|
ctr.Enabled = false;
|
|
|
|
|
|
if(mapGoogles!=null && HistMapPanel.Controls.Contains(mapGoogles))
|
|
HistMapPanel.Controls.Remove(mapGoogles);
|
|
|
|
HistMapPanel.Controls.Add(GetMapController());
|
|
|
|
setLanguage();
|
|
|
|
//this.HistoryPanel.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(191)))), ((int)(((byte)(219)))), ((int)(((byte)(255)))));
|
|
|
|
MainForm2.RestartMEM += 40000000;
|
|
minTime = Int32.MaxValue;
|
|
maxTime = 0;
|
|
|
|
this.DrawMap();
|
|
|
|
|
|
busSymb = new BusSymbols(mapControl);
|
|
placeSymb = new PlaceSymbols(mapControl);
|
|
|
|
if (MainForm2.Connfailed)
|
|
{
|
|
this.mapControl.ActiveMap.Saved = true;
|
|
return;
|
|
}
|
|
|
|
|
|
TraceStyle = 2;
|
|
|
|
GetPositionForStart = false;
|
|
txProgStatus.Visible = false;
|
|
HistroyProgBar.Visible = false;
|
|
HistoryPanel.Visible = false;
|
|
//rsePositionDisplay.Value = MainForm2.PauseTime;
|
|
|
|
|
|
toolWindow2.ToolCaptionButtons = Telerik.WinControls.UI.Docking.ToolStripCaptionButtons.AutoHide | Telerik.WinControls.UI.Docking.ToolStripCaptionButtons.SystemMenu;
|
|
toolWindow2.DocumentButtons &= ~Telerik.WinControls.UI.Docking.DocumentStripButtons.Close;
|
|
ContextMenuService menuService = this.radDock1.GetService<ContextMenuService>();
|
|
menuService.ContextMenuDisplaying += menuService_ContextMenuDisplaying;
|
|
|
|
//this disables the context menu
|
|
menuService.AllowActiveWindowListContextMenu = false;
|
|
menuService.AllowDocumentContextMenu = false;
|
|
menuService.AllowToolContextMenu = false;
|
|
|
|
|
|
//if (MainForm2.InterCalcAddr)
|
|
// rcbComputeAddress.Checked = true;
|
|
//else rcbComputeAddress.Checked = false;
|
|
|
|
string startTimeCustomFormat = MainForm2.DayFirst ? "dd/MM/yyyy hh:mm tt" : "MM/dd/yyyy hh:mm tt";
|
|
|
|
if (MainForm2.is24hours)
|
|
startTimeCustomFormat = MainForm2.DayFirst ? "dd/MM/yyyy HH:mm" : "MM/dd/yyyy HH:mm";
|
|
|
|
rdpStartTime.CustomFormat = startTimeCustomFormat;
|
|
rdpEndTime.CustomFormat = rdpStartTime.CustomFormat;
|
|
// set history time format
|
|
HistoryGridCellElement.timeFormat = rdpStartTime.CustomFormat;
|
|
}
|
|
|
|
|
|
|
|
private CefSharpChromiumWebBrowser GetMapController()
|
|
{
|
|
if (mapGoogles != null)
|
|
{
|
|
mapGoogles.Dispose();
|
|
mapGoogles = null;
|
|
docLoad = false;
|
|
}
|
|
|
|
|
|
String safemobileDirPath = System.Windows.Forms.Application.StartupPath.Replace('\\', '/').Replace(" ", "%20");
|
|
safemobileDirPath = safemobileDirPath.Replace("#", "%23");
|
|
|
|
mapGoogles = new CefSharpChromiumWebBrowser("file:///" + safemobileDirPath + "/resource/" + MainForm2.MapHtmlName);
|
|
|
|
mapGoogles.OnWebPageLoaded += delegate ()
|
|
{
|
|
bool isClassicIcons = (Safedispatch_4_0.MainForm2.iconThemeType == IconTheme.CLASSIC ? true : false);
|
|
|
|
docLoad = true;
|
|
|
|
mapGoogles.ExecuteScript(string.Format("window.GWTcallback('showconsole,{0}');", MainForm2.MapDebugConsole)); //FORKITT
|
|
mapGoogles.ExecuteScript("window.GWTcallback('setLegacyIcons," + (isClassicIcons ? "true" : "false") + "');");
|
|
mapGoogles.ExecuteScript("window.GWTcallback('centerzoom,"
|
|
+ MainForm2.FixDoubleLAT(Safedispatch_4_0.MainForm2.LatStart.ToString()) + ","
|
|
+ MainForm2.FixDoubleLNG(Safedispatch_4_0.MainForm2.LngStart.ToString()) + ","
|
|
+ Safedispatch_4_0.MainForm2.ZoomStart + "');");
|
|
mapGoogles.ExecuteScript("window.GWTcallback('" + "reset" + "');");
|
|
//chrome.ExecuteScript("window.GWTcallback('showconsole,true');");
|
|
};
|
|
|
|
mapGoogles.OnBrowserURLChanged += delegate (String currentURL)
|
|
{
|
|
//MessageBox.Show("Current URL is " + currentURL);
|
|
};
|
|
|
|
mapGoogles.OnURLResponseReceived += delegate (String urlResponse)
|
|
{
|
|
//MessageBox.Show("Received from map: " + urlResponse);
|
|
try
|
|
{
|
|
this.Invoke(new ProcessResponseFromMapInvokeCallBack(this.ProcessResponseFromMap), urlResponse);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Utils.WriteLine("Error on map received:" + ex.ToString(), ConsoleColor.Red);
|
|
}
|
|
};
|
|
|
|
return mapGoogles;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Add the Groups as Nodes inside the Tree View
|
|
/// </summary>
|
|
private void populateListBoxGroup()
|
|
{
|
|
// all units group
|
|
ColorUnitTreeNode groupNode = new ColorUnitTreeNode(MainForm2.returnLNGString("allunits"));
|
|
groupNode.Font = new Font(
|
|
new FontFamily("Segoe UI"),
|
|
12,
|
|
FontStyle.Bold,
|
|
GraphicsUnit.Pixel);
|
|
groupNode.Tag = -1;
|
|
groupNode.CheckState = Telerik.WinControls.Enumerations.ToggleState.Off;
|
|
groupNode.Expanded = true;
|
|
groupNode.Color = Color.Brown;
|
|
|
|
treeViewUnits.Nodes.Add(groupNode);
|
|
|
|
GroupClass g = new GroupClass();
|
|
// for each group add a tree node
|
|
foreach (int i in MainForm2.GroupHash.Keys)
|
|
{
|
|
g = (GroupClass)MainForm2.GroupHash[i];
|
|
|
|
try
|
|
{
|
|
AddTreeGroup(g.name, g.id);
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
Utils.WriteLine("Unable to create Group: " + ex.ToString(), ConsoleColor.Red);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Add a Group Node to the Tree View
|
|
/// </summary>
|
|
/// <param name="groupName">Group name which needs to be added to the Tree Node</param>
|
|
/// <param name="groupID">Group ID which will be set as a tag for this group node</param>
|
|
/// <returns>Returns the inserted Tree Node</returns>
|
|
private ColorUnitTreeNode AddTreeGroup(string groupName, Int32 groupID)
|
|
{
|
|
ColorUnitTreeNode groupNode = new ColorUnitTreeNode(groupName);
|
|
groupNode.Font = new Font(
|
|
new FontFamily("Segoe UI"),
|
|
12,
|
|
FontStyle.Bold,
|
|
GraphicsUnit.Pixel);
|
|
groupNode.Tag = groupID;
|
|
groupNode.CheckState = Telerik.WinControls.Enumerations.ToggleState.Off;
|
|
groupNode.Expanded = true;
|
|
groupNode.Color = Color.Red;
|
|
|
|
// add the node to the tree view
|
|
treeViewUnits.Nodes[0].Nodes.Add(groupNode);
|
|
|
|
return groupNode;
|
|
}
|
|
|
|
|
|
private bool DefaultGroupAdded = false;
|
|
|
|
/// <summary>
|
|
/// Add Units to the groups nodes in the Tree View
|
|
/// </summary>
|
|
private void populateListBoxUnits()
|
|
{
|
|
// for each Unit defined in the hash table
|
|
foreach (DictionaryEntry de in MainForm2.vehicleHT)
|
|
{
|
|
Vehicle veh = de.Value as Vehicle;
|
|
|
|
if (veh != null)
|
|
{
|
|
ColorUnitTreeNode unitNode = new ColorUnitTreeNode(veh.busName);
|
|
unitNode.Tag = veh.sc_id;
|
|
|
|
unitNode.Color = ((Vehicle)MainForm2.vehicleHT[veh.busName]).histcolor;
|
|
|
|
// check to see if the unit is assigned to a group
|
|
if (veh.group != null && veh.group.Id != 0)
|
|
{
|
|
// the group already exists
|
|
}
|
|
else
|
|
{
|
|
// create Unassigned group if not created until now
|
|
if (!DefaultGroupAdded)
|
|
{
|
|
AddTreeGroup(MainForm2.returnLNGString("otherunit"), 0);
|
|
DefaultGroupAdded = true;
|
|
}
|
|
}
|
|
|
|
// search the group in which the unit will be added
|
|
foreach (ColorUnitTreeNode groupNode in treeViewUnits.Nodes[0].Nodes)
|
|
{
|
|
Int32 groupID = (Int32)groupNode.Tag;
|
|
if (groupID == veh.group.Id)
|
|
groupNode.Nodes.Add(unitNode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
private void menuService_ContextMenuDisplaying(object sender, ContextMenuDisplayingEventArgs e)
|
|
{
|
|
if (e.MenuType == ContextMenuType.DockWindow &&
|
|
e.DockWindow.DockTabStrip is DocumentTabStrip)
|
|
{
|
|
for (int i = 0; i < e.MenuItems.Count; i++)
|
|
{
|
|
RadMenuItemBase menuItem = e.MenuItems[i];
|
|
if (menuItem.Name.Equals("CloseWindow") ||
|
|
menuItem.Name.Equals("CloseAllButThis") ||
|
|
menuItem.Name.Equals("CloseAll") ||
|
|
menuItem.Name.Equals("Floating") ||
|
|
menuItem.Name.Equals("Docked") ||
|
|
menuItem.Name.Equals("Hidden") ||
|
|
menuItem is RadMenuSeparatorItem)
|
|
{
|
|
menuItem.Visibility = Telerik.WinControls.ElementVisibility.Collapsed;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void GetPositionsAndAlarms(ArrayList listOfVehicles)
|
|
{
|
|
String toSendVehicles;
|
|
String toSendTimes;
|
|
toSendVehicles = "";
|
|
toSendTimes = "";
|
|
Int32 maxGooglePos = 2000;//400
|
|
Int32 cntLimPos = 0; //max 2000 for google
|
|
Int32 oldcntLimPos = 0;
|
|
selectedPositions.Clear();
|
|
DataPos.Clear();
|
|
DataPosOutSide.Clear();
|
|
ArrayList tmpPos = new ArrayList();
|
|
ArrayList tmpPosOut = new ArrayList();
|
|
try
|
|
{
|
|
// for each group I should check the units which are selected
|
|
foreach (RadTreeNode node in treeViewUnits.Nodes[0].Nodes)
|
|
foreach (RadTreeNode unit in node.Nodes)
|
|
if (unit.Checked)
|
|
{
|
|
SM.Debug("Adding vechicle :" + unit.Text);
|
|
toSendVehicles = toSendVehicles + unit.Text + ",";
|
|
tmpPosOut.Clear();
|
|
tmpPosOut = smdbObj.get_HistoryPositions2(unit.Text, timestart, timestop);
|
|
|
|
if (cntLimPos < maxGooglePos)
|
|
{
|
|
tmpPos.Clear();
|
|
foreach (SMposition objmove in tmpPosOut)
|
|
tmpPos.Add(objmove);
|
|
|
|
oldcntLimPos = cntLimPos;
|
|
cntLimPos += tmpPos.Count;
|
|
if (cntLimPos > maxGooglePos)
|
|
{
|
|
hitLimit = true;
|
|
for (int i = (maxGooglePos - oldcntLimPos); i < (cntLimPos - oldcntLimPos); i++)
|
|
tmpPos.RemoveAt(maxGooglePos - oldcntLimPos);
|
|
}
|
|
if (closeTabThread) return;
|
|
if (addrDecision)
|
|
{
|
|
String listADDR = "";
|
|
try
|
|
{
|
|
foreach (SMposition obj in tmpPos)
|
|
{
|
|
if ((obj.m_address == "") || (obj.m_address == " "))
|
|
{
|
|
MainForm2.cntaddr++;
|
|
IdReportHS[MainForm2.cntaddr.ToString()] = "no address";
|
|
AddrGISQueue.Enqueue(new AddrAndID(MainForm2.cntaddr, obj.m_lat, obj.m_lng));
|
|
obj.m_address = MainForm2.cntaddr.ToString();
|
|
}
|
|
}
|
|
GisAddressWorker.RunWorkerAsync();
|
|
//mapControl.ActiveMap.SetAddrCmdALL(listADDR);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Error on calculate address:" + ex.ToString());
|
|
}
|
|
}
|
|
}
|
|
else tmpPos = new ArrayList();
|
|
|
|
foreach (SMposition obj in tmpPosOut)
|
|
selectedPositions.Add(obj);
|
|
|
|
SimpleRoute tmpX = new SimpleRoute(tmpPos);
|
|
SimpleRoute tmpXOut = new SimpleRoute(tmpPosOut);
|
|
DataPos.Add(unit.Text, tmpX);
|
|
DataPosOutSide.Add(unit.Text, tmpXOut);
|
|
SM.Debug("Adding vechicle :" + unit.Text + "Number of position" + tmpPos.Count);
|
|
}
|
|
|
|
|
|
|
|
if (toSendVehicles.Length > 0)
|
|
{
|
|
selectedPositions.Sort(new VehicleComparer());
|
|
actualNOfPositions = selectedPositions.Count;
|
|
}
|
|
else
|
|
{
|
|
actualNOfPositions = 0;
|
|
selectedPositions.Clear();
|
|
}
|
|
SM.Debug("GetPositionsAndAlarms max no of positions : " + actualNOfPositions);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Error on database connection Mess: "+ex.ToString());
|
|
MainForm2.Connfailed = true;
|
|
throw new ArgumentException("Database connection failed");
|
|
}
|
|
}
|
|
|
|
volatile String volAddress = "";
|
|
volatile String volSpeedString = "";
|
|
volatile List<DataforGRID> ListforGrid = new List<DataforGRID>();
|
|
|
|
/// <summary>
|
|
///populates the list of vehicles from the Table tab </summary>
|
|
/// <param name="listOfVehicles">an array of strings containing the vehicles names</param>
|
|
private void populateTableVehiclesList()
|
|
{
|
|
ArrayList positions = new ArrayList();
|
|
if (selectedPositions.Count > 0)
|
|
{
|
|
try
|
|
{
|
|
// reset the datasource
|
|
gridHistoryPoints.DataSource = null;
|
|
gridHistoryPoints.DataSource = ListforGrid;
|
|
// select first row
|
|
gridHistoryPoints.CurrentRow = gridHistoryPoints.Rows[0];
|
|
|
|
// update tracklist
|
|
UpdateHistoryTrackList(0, ListforGrid.Count - 1);
|
|
|
|
// set the minimum and the maximum dates
|
|
minTime = (Int32)rdpStartTime.Value.DateTo70Format();
|
|
maxTime = (Int32)rdpEndTime.Value.DateTo70Format();
|
|
|
|
// activate the history result tab
|
|
radDock1.ActivateWindow(windowHistoryResult);
|
|
|
|
// flag that the map is dirty
|
|
mapIsDirty = true;
|
|
|
|
// enable the history result window
|
|
foreach (Control ctr in windowHistoryResult.Controls)
|
|
ctr.Enabled = true;
|
|
|
|
rlAnimation.Text = MainForm2.returnLNGString(selectedPositions.Count > 100 ? "histAnimationDisable" : "histAnimation");
|
|
panelAnimationButtons.Enabled = selectedPositions.Count > 100 ? false : true;
|
|
|
|
|
|
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Error on populate grid" + ex.ToString());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
gridHistoryPoints.Rows.Clear();
|
|
gridHistoryPoints.DataSource = null;
|
|
gridHistoryPoints.Refresh();
|
|
|
|
|
|
RadMessageBox.Show(Nodata, "Info", MessageBoxButtons.OK, RadMessageIcon.Info);
|
|
}
|
|
|
|
//tableVehiclesList.TableElement.ScrollToRow(0);
|
|
}
|
|
|
|
|
|
|
|
private void UpdateHistoryTrackList(int minVal, int maxVal)
|
|
{
|
|
// set the range values + start and end time
|
|
timeTrackBar.TrackBarMode = Telerik.WinControls.UI.TrackBarRangeMode.SingleThumb;
|
|
timeTrackBar.Minimum = minVal;
|
|
timeTrackBar.Maximum = maxVal;
|
|
|
|
timeTrackBar.LargeTickFrequency = (int)(maxVal / 5);
|
|
timeTrackBar.SmallTickFrequency = (int)(maxVal / 25);
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// Deletes all used resources
|
|
/// </summary>
|
|
public void Delete()
|
|
{
|
|
try
|
|
{
|
|
if (WorkerHead.IsBusy)
|
|
closeTabThread = true;
|
|
WorkerHead.Dispose();
|
|
this.Dispose();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Error on close TAB HISTORY:"+tabName+" Ex:"+ex.Message);
|
|
}
|
|
}
|
|
|
|
|
|
public delegate void UpdateCurrentTimeCallBack(string text);
|
|
|
|
private void UpdateStatusBar(string text)
|
|
{
|
|
txProgStatus.Text = text;
|
|
txProgStatus.Update();
|
|
}
|
|
|
|
private void UpdateChangeSize(string text)
|
|
{
|
|
txProgStatus.Size = new Size(205, 20);
|
|
txProgStatus.Update();
|
|
}
|
|
|
|
public delegate void UpdateStatusBarCallBack(string text);
|
|
|
|
private void UpdateProgressBar(Int32 max)
|
|
{
|
|
if (max == -1)
|
|
{
|
|
HistroyProgBar.ProgressBarElement.PerformStepValue1();
|
|
HistroyProgBar.Update();
|
|
}
|
|
else
|
|
{
|
|
HistroyProgBar.Maximum = max;
|
|
HistroyProgBar.Value1 = 0;
|
|
}
|
|
}
|
|
|
|
public delegate void UpdateProgressBarCallBack(Int32 max);
|
|
|
|
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
|
|
{
|
|
BackgroundWorker worker = sender as BackgroundWorker;
|
|
e.Result = Computation(worker, e);
|
|
try
|
|
{
|
|
if (this.mapControl == null)
|
|
return;
|
|
|
|
this.mapControl.ActiveMap.Saved = true;
|
|
parent.isCanceled[tabName] = false;
|
|
/*if (this.WorkerHead.IsBusy || this.WorkerHist.IsBusy)
|
|
Thread.Sleep(100); */
|
|
|
|
int countStop = 0;
|
|
while (this.WorkerHead.IsBusy)
|
|
{
|
|
Thread.Sleep(200);
|
|
countStop++;
|
|
if (countStop > 20) break;
|
|
}
|
|
Killtimer.Enabled = true;
|
|
Killtimer.Start();
|
|
this.mapControl.ActiveMap.Saved = true;
|
|
Killtimer.Stop();
|
|
|
|
this.mapControl = null;
|
|
GC.Collect();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Exception on close mappoint HistoryTab "+ex.Message);
|
|
}
|
|
if ((MainForm2.ClosingApp)&&(!KillTimerActive))
|
|
{
|
|
SM.Debug("Worker History : " + tabName + " FINISHED");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Validates the text from param; the text is valid if only contains numbers (from 0 to 9)
|
|
/// </summary>
|
|
/// <param name="param">The string to be validated</param>
|
|
/// <returns></returns>
|
|
public String ValidateText(String param)
|
|
{
|
|
string text, text2;
|
|
|
|
int i;
|
|
text = param; text2 = "";
|
|
for (i = 0; i < text.Length; i++)
|
|
{
|
|
if ((text[i] >= '0') && (text[i] <= '9'))
|
|
{
|
|
text2=text2+text[i];
|
|
}
|
|
}
|
|
return text2;
|
|
}
|
|
|
|
private Int32 CalcHead(Double lastLocX, Double lastLocY, Double prevLocX, Double prevLocY, Int32 heading)
|
|
{
|
|
Double dlng = lastLocX - prevLocX;
|
|
Double dlat = lastLocY - prevLocY;
|
|
Double mdelta_min = -0.00001;
|
|
Double delta_min = 0.00001;
|
|
Int32 headcalc = 0;
|
|
Double blat = 0;
|
|
Double blng = 0;
|
|
if ((dlat > mdelta_min) && (dlat < delta_min) && ((mdelta_min < dlng) && dlng < (delta_min))) headcalc = (Int32)heading;
|
|
else
|
|
{
|
|
if ((mdelta_min < dlat) && (dlat < delta_min))
|
|
{
|
|
blng = 1;
|
|
if (dlng < 0) headcalc = 180;
|
|
else headcalc = 0;
|
|
}
|
|
else
|
|
{
|
|
blat = 1;
|
|
if (dlat > 0) headcalc = 90;
|
|
else headcalc = 270;
|
|
}
|
|
}
|
|
if ((mdelta_min < dlng) && (dlng < delta_min))
|
|
{
|
|
if (blat == 0)
|
|
{
|
|
if (dlat > 0)
|
|
{
|
|
if (headcalc == 180) headcalc = 135;
|
|
if (headcalc == 0) headcalc = 45;
|
|
}
|
|
else
|
|
{
|
|
if (headcalc == 180) headcalc = 225;
|
|
if (headcalc == 0) headcalc = 315;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (blng == 0)
|
|
{
|
|
if (dlng < 0)
|
|
{
|
|
if (headcalc == 90) headcalc = 135;
|
|
if (headcalc == 270) headcalc = 225;
|
|
}
|
|
else
|
|
{
|
|
if (headcalc == 90) headcalc = 45;
|
|
if (headcalc == 270) headcalc = 315;
|
|
}
|
|
}
|
|
}
|
|
return headcalc;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Catches the click on the display history button
|
|
/// Checks each vehicle for defined routes and displays them on the MapPoint control
|
|
/// Computes the positions of the corners for all defined routes, for zooming purposes
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void btDisplayHeadingHisotry_Click(object sender, EventArgs e)
|
|
{
|
|
if (mapIsDirty)
|
|
{
|
|
if (mapGoogles != null && HistMapPanel.Controls.Contains(mapGoogles))
|
|
HistMapPanel.Controls.Remove(mapGoogles);
|
|
|
|
HistMapPanel.Controls.Add(GetMapController());
|
|
mapIsDirty = false;
|
|
}
|
|
|
|
//int lowerSpeed = (rcbSpeedLower.Checked ? (int)(MainForm2.isInMile ? (Int32)Math.Round((Int32)rseSpeedLower.Value * 1.60934) : (Int32)rseSpeedLower.Value) : 0);
|
|
//int upperSpeed = (rcbSpeedUpper.Checked ? (int)(MainForm2.isInMile ? (Int32)Math.Round((Int32)rseSpeedUpper.Value * 1.60934) : (Int32)rseSpeedUpper.Value) : 0);
|
|
|
|
// save upper and lower speed limits
|
|
MainForm2.HistSpeedLimit = (rcbSpeedLower.Checked ? (int)rseSpeedLower.Value : 0);
|
|
MainForm2.HistUpperSpeedLimit = (rcbSpeedUpper.Checked ? (int)rseSpeedUpper.Value : 0);
|
|
|
|
//MainForm2.HistSpeedLimit = lowerSpeed;
|
|
//MainForm2.HistUpperSpeedLimit = upperSpeed;
|
|
|
|
|
|
|
|
try
|
|
{
|
|
smdbObj.Update_Speed_Limit("hisMinSpeed", MainForm2.HistSpeedLimit);
|
|
smdbObj.Update_Speed_Limit("hisMaxSpeed", MainForm2.HistUpperSpeedLimit);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Add history speed limit in Database"+ex.ToString());
|
|
}
|
|
Boolean selOK = false;
|
|
if (rdpStartTime.Enabled)
|
|
{
|
|
if (rdpStartTime.Value.GetSecondsFromDT().ConvertLocalToGMT() > rdpEndTime.Value.GetSecondsFromDT().ConvertLocalToGMT())
|
|
{
|
|
if ((MainForm2.radioType==RADIOTYPE.HARRIS)||(MainForm2.radioType == RADIOTYPE.ATLAS)) ((RadLabel)RadMessageBox.Instance.Controls[1]).LabelElement.ForeColor = MainForm2.HarTextColor;
|
|
RadMessageBox.Show(endtimegreate, "", MessageBoxButtons.OK, RadMessageIcon.Error, MessageBoxDefaultButton.Button1);
|
|
}
|
|
else
|
|
{
|
|
selOK = true;
|
|
timestart = rdpStartTime.Value.GetSecondsFromDT().ConvertLocalToGMT();
|
|
timestop = rdpEndTime.Value.GetSecondsFromDT().ConvertLocalToGMT();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
selOK = true;
|
|
timestart = DateTime.Now.GetSecondsFromDT().ConvertLocalToGMT() - 86400;
|
|
timestop = DateTime.Now.GetSecondsFromDT().ConvertLocalToGMT();
|
|
}
|
|
|
|
//rcbShowGeofence.Checked = false;
|
|
|
|
if (selOK)
|
|
{
|
|
Boolean havecar = false;
|
|
MaxLAT = -90;
|
|
MaxLNG = -180;
|
|
MinLAT = 90;
|
|
MinLNG = 180;
|
|
FirstGoogle = true;
|
|
selectedPositions.Clear();
|
|
try
|
|
{
|
|
SliderPosition.Clear();
|
|
SliderCount = 0;
|
|
Point_for_play.Clear();
|
|
if (gridHistoryPoints.Rows.Count > 0)
|
|
{
|
|
gridHistoryPoints.Rows[0].IsSelected = true;
|
|
gridHistoryPoints.Rows[0].IsCurrent = true;
|
|
}
|
|
if (timeTrackBar.Maximum > 0)
|
|
{
|
|
changeTrackbarValueFromCode = true;
|
|
timeTrackBar.Value = 0;
|
|
timeTrackBar.Maximum = 0;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Utils.WriteLine("Exception put all elements on 0: "+ex.ToString(),ConsoleColor.Red);
|
|
}
|
|
// for each group I should check the units which are selected
|
|
foreach (RadTreeNode node in treeViewUnits.Nodes[0].Nodes)
|
|
foreach (RadTreeNode unit in node.Nodes)
|
|
if (unit.Checked)
|
|
{
|
|
havecar = true;
|
|
break;
|
|
}
|
|
|
|
if (havecar)
|
|
HeadStart();
|
|
else
|
|
{
|
|
if ((MainForm2.radioType == RADIOTYPE.HARRIS)||(MainForm2.radioType == RADIOTYPE.ATLAS)) ((RadLabel)RadMessageBox.Instance.Controls[1]).LabelElement.ForeColor = MainForm2.HarTextColor;
|
|
RadMessageBox.Show(plsselcectcar);
|
|
}
|
|
}
|
|
}
|
|
|
|
private volatile Boolean addrDecision = false;
|
|
|
|
private void HeadStart()
|
|
{
|
|
try
|
|
{
|
|
//splitPanel3.SizeInfo.AbsoluteSize = new Size(splitPanel1.Width, 1);
|
|
int count = 0;
|
|
|
|
// for each group I should check the units which are selected
|
|
foreach(RadTreeNode node in treeViewUnits.Nodes[0].Nodes)
|
|
foreach(RadTreeNode unit in node.Nodes)
|
|
if (unit.Checked)
|
|
count++;
|
|
|
|
|
|
/* if (count > 1)
|
|
MainForm2.HistContinu = true;
|
|
else MainForm2.HistContinu = false;*/
|
|
addrDecision = rcbComputeAddress.Checked;
|
|
rbSearchHistory.Enabled = false;
|
|
rcbComputeAddress.Enabled = false;
|
|
|
|
Cursor = Cursors.WaitCursor;
|
|
mapControl.MousePointer = GeoPointerx.geoPointerHourglass;
|
|
HistroyProgBar.Visible = true;
|
|
HistroyProgBar.Value1 = 0;
|
|
HistoryPanel.Visible = true;
|
|
txProgStatus.Visible = true;
|
|
txProgStatus.Clear();
|
|
|
|
if (docLoad)
|
|
{
|
|
mapGoogles.ExecuteScript("window.GWTcallback('" + "reset" + "');");
|
|
if (rcbShowGeofence.Checked) ForceShowZone();
|
|
}
|
|
|
|
mapControl.ListShapeCMD.Clear();
|
|
WorkerHead.RunWorkerAsync();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Error on start heading" + ex.Message);
|
|
}
|
|
}
|
|
|
|
|
|
private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (this.mapControl == null)
|
|
return;
|
|
|
|
parent.isCanceled[tabName] = false;
|
|
if (e.Cancelled)
|
|
SM.Debug("File: HistoryTab.cs Meth: backgroundWorker1_RunWorkerCompleted You cancelled!");
|
|
else if (e.Error != null)
|
|
SM.Debug("File: HistoryTab.cs Meth: backgroundWorker1_RunWorkerCompleted Worker exception: " + e.Error.ToString());
|
|
else
|
|
SM.Debug("File: HistoryTab.cs Meth: backgroundWorker1_RunWorkerCompleted Complete - " + e.Result); // from DoWork
|
|
|
|
while (this.WorkerHead.IsBusy)
|
|
{
|
|
Thread.Sleep(100);
|
|
}
|
|
this.mapControl.ActiveMap.Saved = true;
|
|
if (this.app != null)
|
|
{
|
|
app.Quit();
|
|
app = null;
|
|
}
|
|
|
|
Killtimer.Enabled = true;
|
|
Killtimer.Start();
|
|
this.mapControl.ActiveMap.Saved = true;
|
|
Killtimer.Stop();
|
|
|
|
this.mapControl = null;
|
|
GC.Collect();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Final RunCompleted Worker History Error" + ex.Message);
|
|
}
|
|
if ((MainForm2.ClosingApp)&&(!KillTimerActive))
|
|
{
|
|
SM.Debug("Worker History : " + tabName + " FINISHED");
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
/* ************************************************************************************ */
|
|
|
|
|
|
|
|
enum PS
|
|
{
|
|
BACK = 0,
|
|
PLAY,
|
|
PAUSE,
|
|
STOP,
|
|
FORWARD
|
|
}
|
|
PS ePlayStatus = PS.STOP;
|
|
PS ePrevPlayStatus = PS.STOP;
|
|
|
|
private void btBack_Click(object sender, EventArgs e)
|
|
{
|
|
rsePositionDisplay.Enabled = true;
|
|
rseSkipSeconds.Enabled = true;
|
|
|
|
//expando1.Enabled = false;
|
|
ePrevPlayStatus = ePlayStatus;
|
|
ePlayStatus = PS.BACK;
|
|
|
|
rbPrev.Enabled = true;
|
|
rbPlay.Enabled = true;
|
|
rbPause.Enabled = false;
|
|
rbStop.Enabled = true;
|
|
rbNext.Enabled = true;
|
|
|
|
Thread.Sleep(200);
|
|
}
|
|
|
|
private void btPlay_Click(object sender, EventArgs e)
|
|
{
|
|
rsePositionDisplay.Enabled = false;
|
|
rseSkipSeconds.Enabled = false;
|
|
|
|
|
|
if (ePrevPlayStatus == PS.STOP)
|
|
{
|
|
if (docLoad)
|
|
{
|
|
mapGoogles.ExecuteScript("window.GWTcallback('" + "removeDataset,heading_positions" + "');");
|
|
FirstGoogle = true;
|
|
}
|
|
}
|
|
|
|
ePrevPlayStatus = ePlayStatus;
|
|
ePlayStatus = PS.PLAY;
|
|
|
|
|
|
rbPrev.Enabled = false;
|
|
rbPlay.Enabled = false;
|
|
rbPause.Enabled = true;
|
|
rbStop.Enabled = true;
|
|
rbNext.Enabled = false;
|
|
|
|
|
|
rbSearchHistory.Enabled = false;
|
|
rcbComputeAddress.Enabled = false;
|
|
Thread.Sleep(200);
|
|
}
|
|
|
|
private void btPause_Click(object sender, EventArgs e)
|
|
{
|
|
|
|
rsePositionDisplay.Enabled = true;
|
|
rseSkipSeconds.Enabled = true;
|
|
|
|
ePrevPlayStatus = ePlayStatus;
|
|
ePlayStatus = PS.PAUSE;
|
|
|
|
|
|
rbPrev.Enabled = true;
|
|
rbPlay.Enabled = true;
|
|
rbPause.Enabled = false;
|
|
rbStop.Enabled = true;
|
|
rbNext.Enabled = true;
|
|
|
|
rbSearchHistory.Enabled = true;
|
|
rcbComputeAddress.Enabled = true;
|
|
Thread.Sleep(200);
|
|
}
|
|
|
|
private void btStopInvoke(string text)
|
|
{
|
|
rbStop.PerformClick();
|
|
}
|
|
|
|
public delegate void btStopInvokeCallBack(String text);
|
|
|
|
private void btStop_Click(object sender, EventArgs e)
|
|
{
|
|
|
|
rsePositionDisplay.Enabled = true;
|
|
rseSkipSeconds.Enabled = true;
|
|
ePrevPlayStatus = ePlayStatus;
|
|
ePlayStatus = PS.STOP;
|
|
|
|
rbPrev.Enabled = false;
|
|
rbPlay.Enabled = true;
|
|
rbPause.Enabled = false;
|
|
rbStop.Enabled = false;
|
|
rbNext.Enabled = false;
|
|
|
|
rbSearchHistory.Enabled = true;
|
|
rcbComputeAddress.Enabled = true;
|
|
Thread.Sleep(200);
|
|
}
|
|
|
|
private void btForward_Click(object sender, EventArgs e)
|
|
{
|
|
rsePositionDisplay.Enabled = true;
|
|
rseSkipSeconds.Enabled = true;
|
|
|
|
ePrevPlayStatus = ePlayStatus;
|
|
ePlayStatus = PS.FORWARD;
|
|
|
|
rbPrev.Enabled = true;
|
|
rbPlay.Enabled = true;
|
|
rbPause.Enabled = false;
|
|
rbStop.Enabled = true;
|
|
rbNext.Enabled = true;
|
|
|
|
Thread.Sleep(200);
|
|
}
|
|
|
|
public String GetSymbName(Int32 id)
|
|
{
|
|
String s = "";
|
|
if (id > 1)
|
|
{
|
|
foreach (Symbolx obj in mapControl.ActiveMap.Symbols)
|
|
if (obj.ID == id)
|
|
{
|
|
s = obj.Name;
|
|
s = s.ToLower();
|
|
s = s.Replace(".ico", ".png");
|
|
s = s.Replace(".bmp", ".png");
|
|
if ((s.Length > 3) && (s[2] == '_')) s = s.Remove(0, 3);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (id== 0) s = "STOP.png";
|
|
else if (id == 1) s = "PIN.png";
|
|
}
|
|
return s;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
private volatile String vehSelect = "";
|
|
private volatile Int32 Index_to_play = 0;
|
|
long Computation(BackgroundWorker worker, DoWorkEventArgs e)
|
|
{
|
|
pp = null;
|
|
Pushpinx pp1 = null;
|
|
SMposition tempPos;
|
|
//ConvertDT convDT = new ConvertDT();
|
|
//timeTemp = 0;
|
|
first = true;
|
|
|
|
while (MainForm2.isRunning)
|
|
{
|
|
if (FirstPlay)
|
|
{
|
|
FirstPlay = false;
|
|
Index_to_play = 0;
|
|
}
|
|
|
|
try
|
|
{
|
|
Thread.Sleep(10);
|
|
if ((parent.isCanceled[tabName] != null && (bool)parent.isCanceled[tabName])
|
|
|| MainForm2.ClosingApp)
|
|
{
|
|
SM.Debug("Hist: CancellationPending tabName: " + tabName);
|
|
e.Cancel = true;
|
|
return 1;
|
|
}
|
|
|
|
|
|
if (ePlayStatus == ePrevPlayStatus)
|
|
continue;
|
|
|
|
switch (ePlayStatus)
|
|
{
|
|
case PS.PLAY:
|
|
{
|
|
if (first)
|
|
{
|
|
Index_to_play = 0;
|
|
first = false;
|
|
}
|
|
|
|
if (ePrevPlayStatus == PS.STOP)
|
|
{
|
|
// for each group I should check the units which are selected
|
|
|
|
FirstGoogle = true;
|
|
SMposition tmpos = (SMposition)Point_for_play[0];
|
|
|
|
worker.ReportProgress(3);
|
|
updatecomand = FormatUpdateCommand(tmpos, FirstGoogle);
|
|
|
|
latitude = tmpos.m_lat;
|
|
longitude = tmpos.m_lng;
|
|
|
|
if (FirstGoogle)
|
|
{
|
|
Thread.Sleep(2000);
|
|
FirstGoogle = false;
|
|
}
|
|
|
|
worker.ReportProgress(1, tmpos.m_evnt_id);
|
|
Index_to_play++;
|
|
|
|
|
|
}// end if prev state is STOP
|
|
|
|
try
|
|
{
|
|
while ((Index_to_play < Point_for_play.Count) && (ePlayStatus == PS.PLAY))
|
|
{
|
|
tempPos = ((SMposition)Point_for_play[Index_to_play]);
|
|
|
|
// convert to km
|
|
volSpeedString = ConvertToKm(tempPos);
|
|
|
|
|
|
Index_to_play++;
|
|
|
|
if (ePlayStatus == PS.PLAY)
|
|
{
|
|
|
|
updatecomand = FormatUpdateCommand(tempPos, FirstGoogle);
|
|
FirstGoogle = false;
|
|
|
|
latitude = tempPos.m_lat;
|
|
longitude = tempPos.m_lng;
|
|
|
|
worker.ReportProgress(1,tempPos.m_evnt_id);
|
|
}
|
|
else
|
|
break;
|
|
|
|
Thread.Sleep(10);
|
|
|
|
if ((parent.isCanceled[tabName] != null && (bool)parent.isCanceled[tabName])
|
|
|| MainForm2.ClosingApp)
|
|
{
|
|
e.Cancel = true;
|
|
return 1;
|
|
}
|
|
|
|
if (rsePositionDisplay.Value > 200)
|
|
{
|
|
for (int mk = 0; mk < rsePositionDisplay.Value / 200; mk++)
|
|
{
|
|
if ((parent.isCanceled[tabName] != null && (bool)parent.isCanceled[tabName])
|
|
|| MainForm2.ClosingApp)
|
|
{
|
|
e.Cancel = true;
|
|
return 1;
|
|
}
|
|
Thread.Sleep(200);
|
|
}
|
|
}
|
|
else Thread.Sleep((Int32)rsePositionDisplay.Value);
|
|
|
|
Thread.Sleep(10);
|
|
}
|
|
if ((parent.isCanceled[tabName] != null && (bool)parent.isCanceled[tabName])
|
|
|| MainForm2.ClosingApp)
|
|
{
|
|
e.Cancel = true;
|
|
return 1;
|
|
}
|
|
if (Index_to_play >= Point_for_play.Count)
|
|
{
|
|
lock (this)
|
|
{
|
|
rbStop.Invoke(new btStopInvokeCallBack(this.btStopInvoke), new object[] { "test" });
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Exception in play: " + ex.ToString());
|
|
}
|
|
ePrevPlayStatus = PS.PLAY;
|
|
}
|
|
break;
|
|
|
|
// ---------------------------------------------------------
|
|
case PS.STOP:
|
|
{
|
|
StopProced();
|
|
}
|
|
ePrevPlayStatus = PS.STOP;
|
|
break;
|
|
// ---------------------------------------------------------
|
|
case PS.BACK:
|
|
{
|
|
if (Index_to_play > 0)
|
|
Index_to_play = Index_to_play - 1;// just to be undercurent time
|
|
else
|
|
Index_to_play = 0;
|
|
tempPos = (SMposition)Point_for_play[Index_to_play];
|
|
vehSelect = tempPos.m_vehName + "_" + tempPos.m_posID.ToString();
|
|
worker.ReportProgress(2, tempPos.m_evnt_id);
|
|
}
|
|
ePlayStatus = PS.PAUSE;
|
|
break;
|
|
// ---------------------------------------------------------
|
|
case PS.PAUSE:
|
|
break;
|
|
// ---------------------------------------------------------
|
|
case PS.FORWARD:
|
|
{
|
|
Boolean onthelimit = false;
|
|
if (Index_to_play < (Point_for_play.Count - 1))
|
|
Index_to_play = Index_to_play + 1;//just to over curent time
|
|
else
|
|
{
|
|
Index_to_play = (Point_for_play.Count - 1);
|
|
onthelimit = true;
|
|
}
|
|
|
|
tempPos = (SMposition)Point_for_play[Index_to_play];
|
|
|
|
if (onthelimit)
|
|
worker.ReportProgress(2, tempPos.m_evnt_id);
|
|
else
|
|
{
|
|
|
|
updatecomand = FormatUpdateCommand(tempPos, false);
|
|
worker.ReportProgress(1, tempPos.m_evnt_id);
|
|
}
|
|
}
|
|
ePlayStatus = PS.PAUSE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("File: HistoryTab.cs Meth: compuation Ex:"+ex.ToString());
|
|
StopProced();
|
|
|
|
}
|
|
} // end while (true)
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
private string FormatUpdateCommand(SMposition tempPos, bool firstGoogle)
|
|
{
|
|
|
|
// Convert To Km
|
|
string volSpeedString = ConvertToKm(tempPos);
|
|
string vehSelect = $"{tempPos.m_vehName}_{tempPos.m_posID}";
|
|
|
|
string command = firstGoogle ? "setDataset" : "updateDataset";
|
|
|
|
string updateComand = $"{command},heading_positions"
|
|
+ "," + MainForm2.FixDoubleLAT(tempPos.m_lat.ToString())
|
|
+ "," + MainForm2.FixDoubleLNG(tempPos.m_lng.ToString())
|
|
+ "," + (tempPos.m_time).ConvertGMTToLocal().GetDTFromSeconds().ToString("yyyy-MM-dd HH:mm:ss")
|
|
+ "," + tempPos.m_vehName + "_" + tempPos.m_posID
|
|
+ "," + volSpeedString + (MainForm2.isInMile ? "mph" : "kph")
|
|
+ "," + tempPos.m_alt
|
|
+ "," + MainForm2.FixComma(tempPos.m_address) + ","
|
|
+ "history/" + GetSymbName(busSymb.GetSymbolFromOrientation(tempPos.m_heading)) + ","
|
|
+ "false" + "," + "false" + "," + "false";
|
|
|
|
|
|
return updateComand;
|
|
}
|
|
|
|
|
|
private string ConvertToKm(SMposition obj)
|
|
{
|
|
|
|
if (MainForm2.isInMile)
|
|
return Convert.ToString((int)Math.Round(obj.m_speed * 0.621371192));
|
|
|
|
return Convert.ToString((int)(obj.m_speed));
|
|
}
|
|
|
|
// Mihai
|
|
private bool changeTrackbarValueFromCode = false;
|
|
/// <summary>
|
|
/// Changes the value of the timeTrackBar without invoking the associated event
|
|
/// </summary>
|
|
/// <param name="value">the new value</param>
|
|
private void ChangeTrackBarValue(int value)
|
|
{
|
|
if (timeTrackBar.InvokeRequired)
|
|
{
|
|
timeTrackBar.Invoke(new Action<int>(ChangeTrackBarValueOnThread), value);
|
|
}
|
|
else
|
|
ChangeTrackBarValueOnThread(value);
|
|
}
|
|
/// <summary>
|
|
/// Don't call this, call ChangeTrackBarValue instead
|
|
/// </summary>
|
|
/// <param name="value"></param>
|
|
private void ChangeTrackBarValueOnThread(int value)
|
|
{
|
|
changeTrackbarValueFromCode = true;
|
|
timeTrackBar.Value = value;
|
|
}
|
|
|
|
private void StopProced()
|
|
{
|
|
try
|
|
{
|
|
Index_to_play = 0;
|
|
first = true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Erorr on stop procedure:"+ex.ToString());
|
|
}
|
|
}
|
|
private volatile Int32 volTest = 0;
|
|
|
|
public ArrayList List_of_Name_for_History = new ArrayList();
|
|
public Double MaxLAT = -90;
|
|
public Double MaxLNG = -180;
|
|
public Double MinLAT = 90;
|
|
public Double MinLNG = 180;
|
|
public ArrayList SliderPosition = new ArrayList();
|
|
private Int32 SliderCount = 0;
|
|
|
|
long ComputHead(BackgroundWorker worker, DoWorkEventArgs e, AxMappointControlx mapControl)
|
|
{
|
|
try
|
|
{
|
|
hitLimit = false;
|
|
string proc1 = MainForm2.returnLNGString("Update"),
|
|
proc2 = MainForm2.returnLNGString("Retriev"),
|
|
proc3 = MainForm2.returnLNGString("Computing"),
|
|
proc4 = MainForm2.returnLNGString("DelOld");
|
|
|
|
txProgStatus.Invoke(new UpdateStatusBarCallBack(this.UpdateStatusBar),proc4);
|
|
|
|
Thread.Sleep(5000);
|
|
|
|
Pushpinx pp1 = null;
|
|
Locationx[] posTemp = null;
|
|
Shapex shp = null;
|
|
int i = 0;
|
|
headingMode = true;
|
|
waitResponse = false;
|
|
String SpeedData = "mile";
|
|
String AddressData = "";
|
|
IdReportHS.Clear();
|
|
|
|
if (closeTabThread)
|
|
{
|
|
e.Cancel = true;
|
|
return 1;
|
|
}
|
|
|
|
if (closeTabThread)
|
|
{
|
|
e.Cancel = true;
|
|
return 1;
|
|
}
|
|
|
|
//delete all shapes before drawing the new ones
|
|
List_of_Name_for_History.Clear();
|
|
shapes = mapControl.ActiveMap.Shapes;
|
|
foreach (Shapex s in shapes)
|
|
if (s.Name.Contains("History"))
|
|
s.Delete();
|
|
|
|
if (closeTabThread)
|
|
{
|
|
e.Cancel = true;
|
|
return 1;
|
|
}
|
|
corners[0] = corners[2] = 181.00;
|
|
corners[1] = corners[3] = -181.00;
|
|
|
|
txProgStatus.Invoke(new UpdateStatusBarCallBack(this.UpdateStatusBar), proc2);
|
|
|
|
if (closeTabThread)
|
|
{
|
|
e.Cancel = true;
|
|
return 1;
|
|
}
|
|
|
|
GetPositionsAndAlarms(vehicleListNames);
|
|
if (actualNOfPositions > 2000)
|
|
{
|
|
WorkerHead.ReportProgress(-2);
|
|
WorkerHead.ReportProgress(-1);
|
|
while (!waitResponse)
|
|
{
|
|
Thread.Sleep(10);
|
|
}
|
|
if (!respQuest)
|
|
{
|
|
if (GisAddressWorker.IsBusy) GisAddressWorker.CancelAsync();
|
|
e.Cancel = true;
|
|
return 1;
|
|
}
|
|
}
|
|
if (closeTabThread)
|
|
{
|
|
e.Cancel = true;
|
|
return 1;
|
|
}
|
|
|
|
txProgStatus.Invoke(new UpdateStatusBarCallBack(this.UpdateStatusBar), proc1);
|
|
|
|
HistroyProgBar.Invoke(new UpdateProgressBarCallBack(this.UpdateProgressBar), actualNOfPositions / 250);
|
|
|
|
//delete all shapes before drawing the new ones
|
|
//RadMessageBox.Show(mapControl.ActiveMap.Shapes.Count.ToString());
|
|
if (closeTabThread) return 1;
|
|
shapes = mapControl.ActiveMap.Shapes;
|
|
foreach (Shapex s in shapes)
|
|
if (s.Name.Contains("History"))
|
|
s.Delete();
|
|
|
|
//checks for each vehicle if there is any defined route
|
|
//there_are_routes is true if there are routes, and false otherwise
|
|
bool there_are_routes = false;
|
|
actualNOfPositions = 0;
|
|
minTime = Int32.MaxValue;
|
|
maxTime = 0;
|
|
|
|
txProgStatus.Invoke(new UpdateStatusBarCallBack(this.UpdateStatusBar), proc3);
|
|
|
|
int progStep = 0;
|
|
// for each group I should check the units which are selected
|
|
foreach (RadTreeNode node in treeViewUnits.Nodes[0].Nodes)
|
|
foreach (RadTreeNode unit in node.Nodes)
|
|
if(unit.Checked)
|
|
{
|
|
List_of_Name_for_History.Add(unit.Text);
|
|
int contRoute = -1;
|
|
Int32 number = 0;
|
|
|
|
ArrayList POSList = new ArrayList();
|
|
SM.Debug("value for name:" + unit.Text);
|
|
if (DataPos[unit.Text] != null)
|
|
{
|
|
POSList = ((SimpleRoute)DataPos[unit.Text]).PositionList;
|
|
number = POSList.Count;
|
|
}
|
|
if (number > 0) there_are_routes = true;
|
|
Locationx[] pos = new Locationx[number];
|
|
Locationx lastPos = null;
|
|
Int32 Headingtmp = 0;
|
|
//i = 0;
|
|
i = -1;
|
|
int cont = -1;
|
|
|
|
foreach (SMposition obj3 in POSList)
|
|
{
|
|
i++;
|
|
obj3.m_posID = i;
|
|
if ((Math.Round(obj3.m_lat) == 0) && (Math.Round(obj3.m_lng) == 0)) continue;
|
|
if ((progStep % 250) == 0)
|
|
HistroyProgBar.Invoke(new UpdateProgressBarCallBack(this.UpdateProgressBar), -1);
|
|
cont++;
|
|
if (lastPos != null)
|
|
//if (obj3.m_speed > 0)
|
|
Headingtmp = CalcHead(obj3.m_lng, obj3.m_lat, lastPos.Longitude, lastPos.Latitude, Headingtmp);
|
|
obj3.m_heading = Headingtmp;
|
|
|
|
if (closeTabThread)
|
|
{
|
|
e.Cancel = true;
|
|
return 1;
|
|
}
|
|
lastPos = mapControl.ActiveMap.GetLocation(obj3.m_lat, obj3.m_lng, 10);
|
|
pos[cont] = lastPos;
|
|
//name
|
|
string headtitle = unit.Text + " - " + i.ToString();
|
|
if (obj3.m_evnt_id != 0)
|
|
headtitle += " (ALARM)";
|
|
|
|
if (closeTabThread)
|
|
{
|
|
e.Cancel = true;
|
|
return 1;
|
|
}
|
|
pp1 = mapControl.ActiveMap.AddPushpin(lastPos, headtitle);
|
|
|
|
if (closeTabThread)
|
|
{
|
|
e.Cancel = true;
|
|
return 1;
|
|
}
|
|
|
|
pp1.Symbol = busSymb.GetSymbolFromOrientation(Headingtmp);
|
|
pp1.Location = lastPos;
|
|
//note
|
|
if (MainForm2.isInMile) SpeedData = " ;" + MainForm2.langSpeed + " " + Convert.ToString((int)Math.Round(obj3.m_speed * 0.621371192)) + MainForm2.milesh;
|
|
else SpeedData = " ;" + MainForm2.langSpeed + " " + Convert.ToString(obj3.m_speed) + MainForm2.kmh;
|
|
|
|
if ((obj3.m_address != "") && (obj3.m_address != " "))
|
|
{
|
|
try
|
|
{
|
|
volTest = Convert.ToInt32(obj3.m_address);
|
|
AddressData = "";
|
|
}
|
|
catch
|
|
{
|
|
AddressData = "<br>" + obj3.m_address;
|
|
}
|
|
}
|
|
else AddressData = "";
|
|
|
|
pp1.Note = MainForm2.langTime + " " + obj3.m_time.DateTimeOfDayHHMMLocal() + SpeedData + AddressData;
|
|
pp1.BalloonState = GeoBalloonStatex.geoDisplayNone;
|
|
if (closeTabThread)
|
|
{
|
|
e.Cancel = true;
|
|
return 1;
|
|
}
|
|
|
|
// pp1.MoveTo(vehiclesDataSet2);
|
|
progStep++;
|
|
|
|
if (minTime > obj3.m_time)
|
|
minTime = obj3.m_time;
|
|
|
|
if (maxTime < obj3.m_time)
|
|
maxTime = obj3.m_time;
|
|
}
|
|
|
|
///HISTORY COPY PASTE
|
|
if (cont >= 0)
|
|
{
|
|
ArrayList latlnt = new ArrayList();
|
|
posTemp = new Locationx[cont + 1];
|
|
for (int k = 0; k <= cont; k++)
|
|
{
|
|
posTemp[k] = pos[k];
|
|
latlnt.Add(pos[k].Latitude);
|
|
latlnt.Add(pos[k].Longitude);
|
|
}
|
|
|
|
if (posTemp.Length > 1)
|
|
{
|
|
if (closeTabThread) return 1;
|
|
shp = mapControl.ActiveMap.Shapes.AddPolyline(posTemp);
|
|
shp.Line.Weight = 3;
|
|
shp.Line.color = ((Vehicle)MainForm2.vehicleHT[unit.Text]).histcolor;
|
|
shp.Line.ForeColor = ColorTranslator.ToOle(((Vehicle)MainForm2.vehicleHT[unit.Text]).histcolor);
|
|
shp.Fill.ForeColor = ColorTranslator.ToOle(((Vehicle)MainForm2.vehicleHT[unit.Text]).histcolor);
|
|
shp.Name = "History";
|
|
}
|
|
else
|
|
{
|
|
if (closeTabThread) return 1;
|
|
shp = mapControl.ActiveMap.Shapes.AddLine(posTemp[0], posTemp[0]);
|
|
shp.Name = "History";
|
|
}
|
|
}
|
|
}
|
|
retrynew = true;
|
|
inwhile = false;
|
|
int cntmax = 0;
|
|
Int32 limitstay = 0;
|
|
if (IdReportHS.Keys.Count > 0)
|
|
{
|
|
try
|
|
{
|
|
txProgStatus.Invoke(new UpdateStatusBarCallBack(this.UpdateStatusBar), calcADDr);
|
|
txProgStatus.Invoke(new UpdateStatusBarCallBack(this.UpdateChangeSize), calcADDr);
|
|
//HistroyProgBar.Maximum = IdReportHS.Keys.Count;
|
|
HistroyProgBar.Invoke(new UpdateProgressBarCallBack(this.UpdateProgressBar), IdReportHS.Keys.Count + (Int32)Math.Round(IdReportHS.Keys.Count*0.25));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Error on put on screen calc address:"+ex.ToString());
|
|
}
|
|
Int32 contNR = IdReportHS.Keys.Count;
|
|
if (cntmax >= contNR)
|
|
{
|
|
retrynew = false;
|
|
inwhile = false;
|
|
}
|
|
while (retrynew)
|
|
{
|
|
inwhile = true;
|
|
Thread.Sleep(1000);
|
|
SM.Debug("Wait 1 second to update");
|
|
HistroyProgBar.Invoke(new UpdateProgressBarCallBack(this.UpdateProgressBar), -1);
|
|
cntmax++;
|
|
if (cntmax > contNR) retrynew = false;
|
|
}
|
|
if (GisAddressWorker.IsBusy) GisAddressWorker.CancelAsync();
|
|
}
|
|
try
|
|
{
|
|
foreach (SMposition obj3 in selectedPositions)
|
|
{
|
|
if (IdReportHS[obj3.m_address] != null)
|
|
{
|
|
obj3.m_address = (String)IdReportHS[obj3.m_address];
|
|
if (obj3.m_address != "no address") smdbObj.Update_address_hist(obj3.m_imei, obj3.m_scevMSSQL, obj3.m_address);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Exception on add address data in DB:"+ex.ToString());
|
|
}
|
|
|
|
|
|
if (there_are_routes)
|
|
{
|
|
ListforGrid.Clear();
|
|
int contx = -1;
|
|
foreach (SMposition obj in selectedPositions)
|
|
{
|
|
contx++;
|
|
// convert to km
|
|
volSpeedString = ConvertToKm(obj);
|
|
|
|
volAddress = obj.m_address;
|
|
if ((volAddress == "") || (volAddress == " "))
|
|
volAddress = "LAT:" + Math.Round(obj.m_lat, 5).ToString() + " , LNG:" + Math.Round(obj.m_lng, 5).ToString();
|
|
|
|
ListforGrid.Add(new DataforGRID(contx.ToString(), obj.m_vehName, (obj.m_time).ConvertGMTToLocal().GetDTFromSeconds(), volAddress, volSpeedString, "", "",
|
|
Math.Round(obj.m_lat, 5).ToString(), Math.Round(obj.m_lng, 5).ToString(), Math.Round(obj.m_alt, 5).ToString(),obj.m_heading));
|
|
|
|
obj.m_evnt_id = contx;
|
|
SliderPosition.Add(SliderCount);
|
|
|
|
if ((obj.m_lat != 0) && (obj.m_lng != 0))
|
|
{
|
|
Point_for_play.Add(obj);
|
|
SliderCount++;
|
|
MaxLAT = Math.Max(MaxLAT, obj.m_lat);
|
|
MinLAT = Math.Min(MinLAT, obj.m_lat);
|
|
MaxLNG = Math.Max(MaxLNG, obj.m_lng);
|
|
MinLNG = Math.Min(MinLNG, obj.m_lng);
|
|
}
|
|
}
|
|
worker.ReportProgress(1,-1);
|
|
}
|
|
else worker.ReportProgress(0);
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Ex on thread:" + ex.ToString());
|
|
//this.Dispose();
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
private void WorkerHead_DoWork(object sender, DoWorkEventArgs e)
|
|
{
|
|
//Thread.Sleep(5000);
|
|
BackgroundWorker worker = sender as BackgroundWorker;
|
|
e.Result = ComputHead(worker, e, mapControl);
|
|
}
|
|
|
|
private volatile Boolean respQuest = false;
|
|
private volatile Boolean waitResponse = false;
|
|
|
|
private void WorkerHead_ProgressChanged(object sender, ProgressChangedEventArgs e)
|
|
{
|
|
if (e.ProgressPercentage > -1)//if (e.ProgressPercentage != -1)
|
|
{
|
|
try
|
|
{
|
|
//HISTORY
|
|
foreach (String obj in mapControl.ListShapeCMD)
|
|
{
|
|
if (docLoad)
|
|
{
|
|
ExecuteScript(obj);
|
|
ExecuteScript($"removelabels,{((String [])obj.Split(",".ToCharArray()))[4]}");
|
|
}
|
|
}
|
|
//end history
|
|
Console.WriteLine("MAXlat:"+MaxLAT+" Minlat:"+MinLAT+" MAXlng:"+MaxLNG+" Minlng:"+MinLNG);
|
|
String corner = "setDataset,corner_positions,"
|
|
+ MainForm2.FixDoubleLAT(MaxLAT.ToString()) + ","
|
|
+ MainForm2.FixDoubleLNG(MaxLNG.ToString()) + ","
|
|
+ DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + ",,,,,,false,false,false,"
|
|
+ MainForm2.FixDoubleLAT(MinLAT.ToString()) + ","
|
|
+ MainForm2.FixDoubleLNG(MaxLNG.ToString()) + ","
|
|
+ DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + ",,,,,,false,false,false,"
|
|
+ MainForm2.FixDoubleLAT(MinLAT.ToString()) + ","
|
|
+ MainForm2.FixDoubleLNG(MinLNG.ToString()) + ","
|
|
+ DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + ",,,,,,false,false,false,"
|
|
+ MainForm2.FixDoubleLAT(MaxLAT.ToString()) + ","
|
|
+ MainForm2.FixDoubleLNG(MinLNG.ToString()) + ","
|
|
+ DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + ",,,,,,false,false,false";
|
|
|
|
|
|
ExecuteScript(corner);
|
|
ExecuteScript("putOnMap,once,corner_positions");
|
|
ExecuteScript("removelabels,corner_positions");
|
|
|
|
/* SM.Debug("Face ZOOM pe un dataset");
|
|
if (vehiclesDataSet2.RecordCount > 0)
|
|
vehiclesDataSet2.ZoomTo();*/
|
|
|
|
Boolean there_are_routes = (e.ProgressPercentage == 1) ? true : false;
|
|
string s1 = MainForm2.returnLNGString("showTraceCB");
|
|
|
|
populateTableVehiclesList();
|
|
if (there_are_routes)
|
|
{
|
|
AniStateExpande = true;
|
|
}
|
|
}
|
|
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Erorr Worker Heading ProgressChanged: " + ex.ToString());
|
|
}
|
|
}
|
|
else //-1 when asking for stop reports
|
|
{
|
|
if (e.ProgressPercentage == -1)
|
|
{
|
|
if ((MainForm2.radioType == RADIOTYPE.HARRIS) || (MainForm2.radioType == RADIOTYPE.ATLAS)) ((RadLabel)RadMessageBox.Instance.Controls[1]).LabelElement.ForeColor = MainForm2.HarTextColor;
|
|
//DialogResult dr2 = RadMessageBox.Show(string.Format(youhave, actualNOfPositions.ToString()) + "\n" + googleWork + "\n" + contorsmall, "Info", MessageBoxButtons.YesNo, RadMessageIcon.Info);
|
|
//DialogResult dr2 = RadMessageBox.Show(string.Format(youhave, actualNOfPositions.ToString()) + "\n" + outsideBrowser +"\n"+ setdefault + "\n" + contorsmall, "Info", MessageBoxButtons.YesNo, RadMessageIcon.Info);
|
|
//DialogResult dr2 = RadMessageBox.Show(string.Format(youhave, actualNOfPositions.ToString()) + "\n" + outsideBrowser + "\n<html><size=6><b>" + setdefault + "</b>\n" + contorsmall, "Info", MessageBoxButtons.YesNo, RadMessageIcon.Info);
|
|
DialogResult dr2 = RadMessageBox.Show("<html>" + string.Format(youhave, actualNOfPositions.ToString()) + "\n" +selectinterval, "Info", MessageBoxButtons.OK, RadMessageIcon.Info);
|
|
//if (dr2 == DialogResult.Yes) respQuest = true;
|
|
//else respQuest = false;
|
|
respQuest = false;
|
|
waitResponse = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void WorkerHead_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (!closeTabThread)
|
|
{
|
|
Cursor = Cursors.Arrow;
|
|
mapControl.MousePointer = GeoPointerx.geoPointerDefault;
|
|
HistroyProgBar.Visible = false;
|
|
HistoryPanel.Visible = false;
|
|
HistoryPanel.Update();
|
|
txProgStatus.Visible = false;
|
|
txProgStatus.Update();
|
|
rbSearchHistory.Enabled = true;
|
|
rcbComputeAddress.Enabled = true;
|
|
FirstGoogle = true;
|
|
timeTrackBar.Maximum = Point_for_play.Count-1;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Erorr Worker Heading Complete: " + ex.ToString());
|
|
}
|
|
if (MainForm2.Connfailed)
|
|
{
|
|
if ((MainForm2.radioType == RADIOTYPE.HARRIS)||(MainForm2.radioType == RADIOTYPE.ATLAS))
|
|
((RadLabel)RadMessageBox.Instance.Controls[1]).LabelElement.ForeColor = MainForm2.HarTextColor;
|
|
|
|
RadMessageBox.Show(MainForm2.returnLNGString("database"), MainForm2.returnLNGString("war"), MessageBoxButtons.OK, RadMessageIcon.Exclamation);
|
|
MainForm2.Connfailed = false;
|
|
}
|
|
}
|
|
|
|
private void HistoryTab_Load(object sender, EventArgs e)
|
|
{
|
|
backgroundWorker1.RunWorkerAsync();
|
|
VisualSettings.loadUserVisualSettings(this.Name, this.toolWindow4, MainForm2.HashVal);
|
|
|
|
// convert in km
|
|
if (MainForm2.isInMile)
|
|
{
|
|
rseSpeedLower.Value = (int)Math.Round(Convert.ToInt32(rseSpeedLower.Value) * 0.621371192);
|
|
rseSpeedUpper.Value = (int)Math.Round(Convert.ToInt32(rseSpeedUpper.Value) * 0.621371192);
|
|
}
|
|
|
|
isLoaded = true;
|
|
rseSpeedLower.Value = MainForm2.HistSpeedLimit;
|
|
rcbComputeAddress.Checked = MainForm2.ComputeAddress;
|
|
rsePositionDisplay.Value = MainForm2.PlayTime > rsePositionDisplay.Minimum && MainForm2.PlayTime < rsePositionDisplay.Maximum ? MainForm2.PlayTime : rsePositionDisplay.Maximum;
|
|
rseSkipSeconds.Value = MainForm2.PauseTime > rseSkipSeconds.Minimum && MainForm2.PauseTime < rseSkipSeconds.Maximum ? MainForm2.PauseTime : rseSkipSeconds.Maximum;
|
|
//VisualSettings.loadUserVisualSettings(this.Name, this.windowHistoryResult, MainForm2.HashVal);
|
|
}
|
|
|
|
private void Killtimer_Tick(object sender, EventArgs e)
|
|
{
|
|
if (MainForm2.ClosingApp)
|
|
KillTimerActive = true;
|
|
}
|
|
|
|
private double latitude = 0;
|
|
private double longitude = 0;
|
|
|
|
private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
|
|
{
|
|
if (docLoad)
|
|
{
|
|
try
|
|
{
|
|
if (e.ProgressPercentage == 3)
|
|
ExecuteScript("removeDataset,heading_positions");
|
|
else
|
|
{
|
|
Int32 index = (Int32)e.UserState;
|
|
Console.WriteLine(" Indexul :" + index);
|
|
if (index >= 0)
|
|
{
|
|
// idx
|
|
gridHistoryPoints.Rows[index].IsSelected = true;
|
|
gridHistoryPoints.Rows[index].IsCurrent = true;
|
|
ChangeTrackBarValue((Int32)SliderPosition[index]);
|
|
}
|
|
if (e.ProgressPercentage == 1)
|
|
{
|
|
|
|
ExecuteScript(updatecomand);
|
|
if (updatecomand.StartsWith("setDataset,heading_positions"))
|
|
{
|
|
if (rcbShowLabels.ToggleState == Telerik.WinControls.Enumerations.ToggleState.On)
|
|
ExecuteScript("putlabels,heading_positions");
|
|
else
|
|
mapControl.mapGoogles.ExecuteScript("window.GWTcallback('" + "removelabels,heading_positions" + "');");
|
|
}
|
|
ExecuteScript("putOnMap,none,heading_positions");
|
|
}
|
|
|
|
ExecuteScript($"openInfo,{vehSelect}");
|
|
ExecuteScript($"centerzoom,{latitude},{longitude},-1");
|
|
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Error send data for play: "+ex.ToString());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
private void ExecuteScript(string command)
|
|
{
|
|
mapGoogles?.ExecuteScript($"window.GWTcallback('{command}');");
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
private void StartBasicHistory_Tick(object sender, EventArgs e)
|
|
{
|
|
if (docLoad)
|
|
{
|
|
StartBasicHistory.Stop();
|
|
StartBasicHistory.Enabled = false;
|
|
}
|
|
}
|
|
|
|
private void btStopCalc_Click(object sender, EventArgs e)
|
|
{
|
|
retrynew = false;
|
|
}
|
|
|
|
private void toolWindow2_Resize(object sender, EventArgs e)
|
|
{
|
|
int diffHeight, diffWidth;
|
|
Control control = (Control)sender;
|
|
diffHeight = control.Size.Height / 2;
|
|
diffWidth = control.Size.Width / 2;
|
|
diffHeight = diffHeight - 50;
|
|
diffWidth = diffWidth - 170;
|
|
if ((diffHeight > 0) && (diffWidth > 0))
|
|
HistoryPanel.Location = new System.Drawing.Point(diffWidth, diffHeight);
|
|
}
|
|
|
|
|
|
private Color getcolorFromID(Int32 id)
|
|
{
|
|
Color tmp = Color.Black;
|
|
switch (id)
|
|
{
|
|
case 0: tmp = Color.Cyan; break;
|
|
case 1: tmp = Color.Magenta; break;
|
|
case 2: tmp = Color.Red; break;
|
|
case 3: tmp = Color.Green; break;
|
|
case 4: tmp = Color.Blue; break;
|
|
}
|
|
return tmp;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Set the type of data which will be displayed inside the points grid
|
|
/// </summary>
|
|
private void gridHistoryPoints_CreateCell(object sender, GridViewCreateCellEventArgs e)
|
|
{
|
|
// format Ticket Log table
|
|
if (e.Row is GridDataRowElement)
|
|
{
|
|
// increase row height
|
|
//e.Row.RowInfo.Height = 53;
|
|
|
|
if (e.Column.Name.Equals("history"))
|
|
{
|
|
e.CellType = typeof(HistoryGridColumn);
|
|
e.CellElement = new HistoryGridCellElement(e.Column, e.Row);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// Format the cells of history points to the custom format, including padding
|
|
/// </summary>
|
|
private void gridHistoryPoints_CellFormatting(object sender, CellFormattingEventArgs e)
|
|
{
|
|
GridCellElement cellElement = e.CellElement;
|
|
GridViewDataColumn columnInfo = e.CellElement.ColumnInfo as GridViewDataColumn;
|
|
|
|
// set padding and force the content adding
|
|
if (cellElement is HistoryGridCellElement && columnInfo.Name == "history")
|
|
{
|
|
cellElement.Padding = new Padding(0, 0, 0, 0);
|
|
cellElement.SetContent();
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Display the point on the map when doubled click a point from the grid
|
|
/// </summary>
|
|
private void gridHistoryPoints_CellDoubleClick(object sender, GridViewCellEventArgs e)
|
|
{
|
|
if (e.Row.DataBoundItem != null && e.Row.DataBoundItem is DataforGRID)
|
|
{
|
|
DataforGRID gridData = e.Row.DataBoundItem as DataforGRID;
|
|
// display the bubble for a history point
|
|
DisplayHistoryBuble(gridData);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// Display the bubble when a point is selected in the points list
|
|
/// </summary>
|
|
private void gridHistoryPoints_SelectionChanged(object sender, EventArgs e)
|
|
{
|
|
if(gridHistoryPoints.SelectedRows.Count > 0)
|
|
{
|
|
DataforGRID gridData = gridHistoryPoints.SelectedRows[0].DataBoundItem as DataforGRID;
|
|
// display the bubble for a history point
|
|
|
|
// DisplayHistoryBuble(gridData);
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Display a bubble on the map for a specific history point
|
|
/// </summary>
|
|
/// <param name="gridData">Object containing all the informations for a point</param>
|
|
private void DisplayHistoryBuble(DataforGRID gridData)
|
|
{
|
|
// if (!MainForm2.HistContinu && (gridData.Lat.CompareTo("0") != 0) && (gridData.Lng.CompareTo("0") != 0))
|
|
Boolean PutonMap = false;
|
|
if ((gridData.Lat.CompareTo("0") != 0) && (gridData.Lng.CompareTo("0") != 0))
|
|
{
|
|
if (FirstGoogle)
|
|
{
|
|
|
|
ExecuteScript("removeDataset,heading_positions");
|
|
|
|
|
|
updatecomand = "setDataset,heading_positions,";
|
|
FirstGoogle = false;
|
|
PutonMap = true;
|
|
}
|
|
else updatecomand = "updateDataset,heading_positions,";
|
|
updatecomand+= MainForm2.FixDoubleLAT(gridData.Lat) + ","
|
|
+ MainForm2.FixDoubleLNG(gridData.Lng) + ","
|
|
+ gridData.Datatime.ToString("yyyy-MM-dd HH:mm:ss") + ","
|
|
+ gridData.VehName +"_"+gridData.Id+","
|
|
+ gridData.Speed + (MainForm2.isInMile ? "mph" : "kph") + ","
|
|
+ gridData.Alt + ","
|
|
+ MainForm2.FixComma(gridData.Address) + ","
|
|
+ "history/" + GetSymbName(busSymb.GetSymbolFromOrientation(gridData.Heading_int)) + ","
|
|
+ "false" + "," + "false" + "," + "false";
|
|
Utils.WriteLine(updatecomand,ConsoleColor.Blue);
|
|
if (docLoad)
|
|
{
|
|
|
|
ExecuteScript(updatecomand);
|
|
|
|
if (PutonMap)
|
|
ExecuteScript("putOnMap,none,heading_positions");
|
|
|
|
ExecuteScript($"openInfo,{gridData.VehName}_{gridData.Id}");
|
|
ExecuteScript($"centerzoom,{gridData.Lat},{gridData.Lng},-1");
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void checkBox2_ToggleStateChanged(object sender, StateChangedEventArgs args)
|
|
{
|
|
try
|
|
{
|
|
if (docLoad)
|
|
{
|
|
ExecuteScript($"openInfo,{pp.Name}");
|
|
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Error change Balone state on play interval" + ex.Message);
|
|
}
|
|
}
|
|
|
|
|
|
private volatile Queue AddrGISQueue = new Queue();
|
|
private volatile Boolean findaddress;
|
|
private volatile AddrAndID tmpAddrAndID;
|
|
private Double valHash;
|
|
private volatile String AddrtmpX;
|
|
private volatile ReverseGeocoding volltmpGo2 = new ReverseGeocoding(MainForm2.cfg.ReverseGeoOSM);
|
|
|
|
private void GisAddressWorker_DoWork(object sender, DoWorkEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
BackgroundWorker worker = sender as BackgroundWorker;
|
|
|
|
while (AddrGISQueue.Count > 0)
|
|
{
|
|
if ((worker.CancellationPending == true))
|
|
{
|
|
e.Cancel = true;
|
|
break;
|
|
}
|
|
|
|
tmpAddrAndID = (AddrAndID)AddrGISQueue.Dequeue();
|
|
findaddress = false;
|
|
try
|
|
{
|
|
tmpAddrAndID.LNG = Math.Round(tmpAddrAndID.LNG, 4);
|
|
tmpAddrAndID.LAT = Math.Round(tmpAddrAndID.LAT, 4);
|
|
|
|
valHash = tmpAddrAndID.LNG + tmpAddrAndID.LAT * 0.000001;
|
|
if (MainForm2.AddrHass[valHash] != null)
|
|
{
|
|
tmpAddrAndID.Address = (String)MainForm2.AddrHass[valHash];
|
|
findaddress = true;
|
|
}
|
|
else
|
|
{
|
|
AddrtmpX = smdbObj.get_address(tmpAddrAndID.LAT, tmpAddrAndID.LNG);
|
|
if (AddrtmpX != "")
|
|
{
|
|
MainForm2.AddrHass.Add(valHash, AddrtmpX);
|
|
tmpAddrAndID.Address = AddrtmpX;
|
|
findaddress = true;
|
|
}
|
|
}
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
Utils.WriteLine(ex.ToString(), ConsoleColor.Red);
|
|
}
|
|
|
|
if (!findaddress)
|
|
{
|
|
tmpAddrAndID.Address = volltmpGo2.getAddressLATLNG(tmpAddrAndID.LAT, tmpAddrAndID.LNG);
|
|
}
|
|
|
|
if ((tmpAddrAndID.Address != "") && (tmpAddrAndID.Address != " "))
|
|
{
|
|
if (!findaddress)
|
|
{
|
|
try
|
|
{
|
|
if (tmpAddrAndID.Address != "N/A")
|
|
{
|
|
valHash = tmpAddrAndID.LNG + tmpAddrAndID.LAT * 0.000001;
|
|
MainForm2.AddrHass.Add(valHash, tmpAddrAndID.Address);
|
|
AddrtmpX = smdbObj.get_address(tmpAddrAndID.LAT, tmpAddrAndID.LNG); //just for avoid Error from Event Viewer
|
|
if (AddrtmpX == "") smdbObj.Insert_Address(tmpAddrAndID.Address, tmpAddrAndID.LAT, tmpAddrAndID.LNG);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Error: " + ex.ToString());
|
|
}
|
|
}
|
|
IdReportHS[tmpAddrAndID.ID.ToString()] = tmpAddrAndID.Address;
|
|
if (inwhile)
|
|
HistroyProgBar.Invoke(new UpdateProgressBarCallBack(this.UpdateProgressBar), -1);
|
|
|
|
SM.Debug("Baga google in hash ID:" + tmpAddrAndID.ID.ToString() + "Addr:" + tmpAddrAndID.Address);
|
|
}
|
|
//else
|
|
//{
|
|
// //dau in open street maps si apoi ies prin prin cene
|
|
// Thread.Sleep(1100);
|
|
// tmpAddrAndID.Address = volltmpGo2.getAddressLATLNG2(tmpAddrAndID.LAT, tmpAddrAndID.LNG);
|
|
// if ((tmpAddrAndID.Address != "") && (tmpAddrAndID.Address != " "))
|
|
// {
|
|
// if (!findaddress)
|
|
// {
|
|
// try
|
|
// {
|
|
// if (tmpAddrAndID.Address != "N/A")
|
|
// {
|
|
// valHash = tmpAddrAndID.LNG + tmpAddrAndID.LAT * 0.000001;
|
|
// MainForm2.AddrHass.Add(valHash, tmpAddrAndID.Address);
|
|
// AddrtmpX = smdbObj.get_address(tmpAddrAndID.LAT, tmpAddrAndID.LNG); //just for avoid Error from Event Viewer
|
|
// if (AddrtmpX == "") smdbObj.Insert_Address(tmpAddrAndID.Address, tmpAddrAndID.LAT, tmpAddrAndID.LNG);
|
|
// }
|
|
// }
|
|
// catch (Exception ex)
|
|
// {
|
|
// SM.Debug("Error: " + ex.ToString());
|
|
// }
|
|
// }
|
|
|
|
// IdReportHS[tmpAddrAndID.ID.ToString()] = tmpAddrAndID.Address;
|
|
// if (inwhile) HistroyProgBar.Invoke(new UpdateProgressBarCallBack(this.UpdateProgressBar), -1);
|
|
// SM.Debug("Baga open street maps in hash ID:"+tmpAddrAndID.ID.ToString() + "Addr:" + tmpAddrAndID.Address);
|
|
// }
|
|
// else
|
|
// {
|
|
// SM.Debug("Iese prin Cene cu nimic");
|
|
// }
|
|
//}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Error retrive address:" + ex.ToString());
|
|
}
|
|
Thread.Sleep(10);
|
|
}
|
|
|
|
private void GisAddressWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
|
|
{
|
|
retrynew = false;
|
|
}
|
|
|
|
|
|
private void TimerToLoadMap_Tick(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
String safemobileDirPath = System.Windows.Forms.Application.StartupPath.Replace('\\', '/').Replace(" ", "%20");
|
|
safemobileDirPath = safemobileDirPath.Replace("#", "%23");
|
|
|
|
mapGoogles.LoadWebPage("file:///" + safemobileDirPath + "/resource/" + MainForm2.MapHtmlName);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Ex:" + ex.ToString());
|
|
}
|
|
}
|
|
|
|
private void mapGoogles_KeyDown(object sender, KeyEventArgs e)
|
|
{
|
|
if ((e.KeyValue > 36) && (e.KeyValue < 41)) e.Handled = true;
|
|
}
|
|
|
|
private void mapGoogles_KeyPress(object sender, KeyPressEventArgs e)
|
|
{
|
|
if ((e.KeyChar > 36) && (e.KeyChar < 41)) e.Handled = true;
|
|
}
|
|
private WaitToLoad WaitWindow = null;
|
|
private void MessageScreen_Tick(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
MessageScreen.Stop();
|
|
MessageScreen.Enabled = false;
|
|
WaitWindow = new WaitToLoad(false);
|
|
WaitWindow.ShowDialog();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Ex10:" + ex.ToString());
|
|
}
|
|
}
|
|
|
|
Int32 nrtrys = 0;
|
|
private void ForceRefreshTimer_Tick(object sender, EventArgs e)
|
|
{
|
|
nrtrys++;
|
|
if (nrtrys > 3)
|
|
{
|
|
ForceRefreshTimer.Stop();
|
|
ForceRefreshTimer.Enabled = false;
|
|
}
|
|
}
|
|
|
|
private void ckShowZone_ToggleStateChanged(object sender, StateChangedEventArgs args)
|
|
{
|
|
try
|
|
{
|
|
//mapGoogles.ExecuteScript("window.GWTcallback('" + "showconsole,true" + "');");
|
|
if (rcbShowGeofence.Checked)
|
|
ForceShowZone();
|
|
else ForceHideZone();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("ExLive13:" + ex.ToString());
|
|
}
|
|
}
|
|
|
|
public Int32 nrNavigatecnt = 0;
|
|
public void ForceShowZone()
|
|
{
|
|
try
|
|
{
|
|
if (docLoad)
|
|
{
|
|
|
|
ExecuteScript("deletePolygon,ALL");
|
|
nrNavigatecnt++;
|
|
}
|
|
|
|
List<GeofenceUI> allGeofences = smdbObj.GetAllGeofences();
|
|
|
|
foreach(GeofenceUI geofence in allGeofences)
|
|
{
|
|
String datasetCMD = "";
|
|
foreach (GeofencePoint point in geofence.points)
|
|
{
|
|
datasetCMD = datasetCMD
|
|
+ MainForm2.FixDoubleLAT(point.Latitude + "") + ","
|
|
+ MainForm2.FixDoubleLNG(point.Longitude + "") + ",";
|
|
}
|
|
|
|
// get geofence fill color
|
|
String hexFillColor = "#" + geofence.FillColor.R.ToString("X2") + geofence.FillColor.G.ToString("X2") + geofence.FillColor.B.ToString("X2");
|
|
String hexBorderColor = "#" + geofence.BorderColor.R.ToString("X2") + geofence.BorderColor.G.ToString("X2") + geofence.BorderColor.B.ToString("X2");
|
|
try
|
|
{
|
|
datasetCMD = datasetCMD.Remove(datasetCMD.Length - 1);
|
|
}
|
|
catch (Exception ex) { SM.Debug("Ex:" + ex.ToString()); }
|
|
|
|
if (docLoad)
|
|
{
|
|
mapGoogles.ExecuteScript("window.GWTcallback('" + "setPolygon,"
|
|
+ geofence.Name + ","
|
|
+ hexFillColor + ","
|
|
+ MainForm2.FixDoubleLAT(geofence.FillOpacity.ToString()) + ","
|
|
+ hexBorderColor + ","
|
|
+ MainForm2.FixDoubleLAT(geofence.BorderOpacity.ToString()) + ","
|
|
+ MainForm2.FixDoubleLAT(geofence.BorderWidth.ToString()) + ","
|
|
+ datasetCMD + "');");
|
|
}
|
|
System.Threading.Thread.Sleep(10);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Error zone preview:" + ex.ToString());
|
|
}
|
|
}
|
|
|
|
private Int32 ZoneGoogle = 0;
|
|
public void ForceHideZone()
|
|
{
|
|
try
|
|
{
|
|
if (docLoad)
|
|
{
|
|
|
|
ExecuteScript("deletePolygon,ALL");
|
|
nrNavigatecnt++;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("Unable to remove zones from map " + ex.ToString());
|
|
}
|
|
}
|
|
public delegate void ProcessResponseFromMapInvokeCallBack(String url);
|
|
|
|
/*private void mapGoogles_Navigating(object sender, WebBrowserNavigatingEventArgs e)
|
|
{
|
|
string url = e.Url.ToString();*/
|
|
private void ProcessResponseFromMap(String url)
|
|
{
|
|
if (url.IndexOf("app://") > -1)
|
|
{
|
|
Utils.WriteLine(url);
|
|
//URL-ul: app://map-loaded/
|
|
if (url.IndexOf("map-loaded") > -1)
|
|
{
|
|
if (WaitWindow != null)
|
|
WaitWindow.Close();
|
|
this.Invoke((MethodInvoker)delegate()
|
|
{
|
|
VisualSettings.loadUserVisualSettings(this.Name, this.windowHistoryResult, MainForm2.HashVal);
|
|
});
|
|
|
|
}
|
|
else if (url.IndexOf("street-view-open") > -1)
|
|
{
|
|
String tmpstr = url.Remove(0, url.IndexOf("street-view-open") + 17);
|
|
Utils.WriteLine("parsare:" + tmpstr);
|
|
tmpstr = tmpstr.Trim();
|
|
if (tmpstr.ToUpper().CompareTo("TRUE") == 0) StreetViewOpened = true;
|
|
else StreetViewOpened = false;
|
|
}
|
|
}
|
|
//rsePositionDisplay.Value = MainForm2.PlayTime;
|
|
//rseSkipSeconds.Value = MainForm2.PauseTime;
|
|
}
|
|
|
|
private void rbInterSel_ToggleStateChanged(object sender, StateChangedEventArgs args)
|
|
{
|
|
|
|
}
|
|
|
|
private void radLabel3_Click(object sender, EventArgs e)
|
|
{
|
|
|
|
}
|
|
|
|
private void compAddress_ToggleStateChanged(object sender, StateChangedEventArgs args)
|
|
{
|
|
|
|
}
|
|
|
|
private void radSplitContainer2_Click(object sender, EventArgs e)
|
|
{
|
|
|
|
}
|
|
|
|
private void radCheckBox1_ToggleStateChanged(object sender, StateChangedEventArgs args)
|
|
{
|
|
|
|
}
|
|
|
|
private void StartGoogleMap_Tick(object sender, EventArgs e)
|
|
{
|
|
StartGoogleMap.Stop();
|
|
StartGoogleMap.Enabled = false;
|
|
|
|
String safemobileDirPath = System.Windows.Forms.Application.StartupPath.Replace('\\', '/').Replace(" ", "%20");
|
|
safemobileDirPath = safemobileDirPath.Replace("#", "%23");
|
|
|
|
mapGoogles.LoadWebPage("file:///" + safemobileDirPath + "/resource/" + MainForm2.MapHtmlName);
|
|
docLoad = true;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Enable/disable the speed spinners when the combobox are selected
|
|
/// </summary>
|
|
private void speedLimit_CheckStateChanged(object sender, EventArgs e)
|
|
{
|
|
|
|
if ((RadCheckBox)sender == rcbSpeedLower)
|
|
rseSpeedLower.Enabled = ((RadCheckBox)sender).Checked;
|
|
else if ((RadCheckBox)sender == rcbSpeedUpper)
|
|
rseSpeedUpper.Enabled = ((RadCheckBox)sender).Checked;
|
|
}
|
|
|
|
|
|
#region 24H
|
|
/// <summary>
|
|
/// Enable/Disable the date pickers for history stand and
|
|
/// end date. The icon for the 24H will be changed depanding
|
|
/// on it's state
|
|
/// </summary>
|
|
private void pb24H_Click(object sender, EventArgs e)
|
|
{
|
|
if(pb24H.Tag.Equals("selected"))
|
|
{
|
|
pb24H.Tag = "unselected";
|
|
rdpEndTime.Enabled = true;
|
|
rdpStartTime.Enabled = true;
|
|
pb24H.Image = global::Dispatcher.Properties.Resources.h_24h_w;
|
|
}
|
|
else if (pb24H.Tag.Equals("unselected"))
|
|
{
|
|
pb24H.Tag = "selected";
|
|
rdpEndTime.Enabled = false;
|
|
rdpStartTime.Enabled = false;
|
|
pb24H.Image = theme24H_Image;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Display the tooltip when the mouse enters the 24H picture box
|
|
/// </summary>
|
|
private void pb24H_MouseEnter(object sender, EventArgs e)
|
|
{
|
|
toolTipHelp.ToolTipTitle = MainForm2.returnLNGString("dispLast24") + (pb24H.Tag.Equals("selected") ? MainForm2.returnLNGString("active") : MainForm2.returnLNGString("inactive"));
|
|
toolTipHelp.Show(
|
|
String.Format(MainForm2.returnLNGString("dispLast24det"))
|
|
, pb24H, 150000);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hide the tooltip when the mouse leaves the 24H picture box
|
|
/// </summary>
|
|
private void pb24H_MouseLeave(object sender, EventArgs e)
|
|
{
|
|
toolTipHelp.Hide(pb24H);
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region UNITS FILTER
|
|
/// <summary>
|
|
/// Display the tooltip when the mouse enters the Filter picture box
|
|
/// </summary>
|
|
private void pbFilter_MouseEnter(object sender, EventArgs e)
|
|
{
|
|
toolTipHelp.ToolTipTitle = "Filter units: " + (pbFilter.Tag.Equals("selected") ? "Active" : "Inactive");
|
|
toolTipHelp.Show(
|
|
String.Format("Filter the units list when the text box value changes")
|
|
, pbFilter, 150000);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Hide the tooltip when the mouse leaves the Filter picture box
|
|
/// </summary>
|
|
private void pbFilter_MouseLeave(object sender, EventArgs e)
|
|
{
|
|
toolTipHelp.Hide(pbFilter);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Hide or show the filter for the units tree view
|
|
/// </summary>
|
|
private void pbFilter_Click(object sender, EventArgs e)
|
|
{
|
|
// activate the filter and show the text box
|
|
if (pbFilter.Tag.Equals("unselected"))
|
|
{
|
|
pbFilter.Image = themelFilter_Image;
|
|
pbFilter.Tag = "selected";
|
|
rtbFilterUnits.Visible = true;
|
|
}
|
|
else if (pbFilter.Tag.Equals("selected"))
|
|
{
|
|
pbFilter.Image = global::Dispatcher.Properties.Resources.h_filter_w;
|
|
pbFilter.Tag = "unselected";
|
|
rtbFilterUnits.Visible = false;
|
|
rtbFilterUnits.Text = "";
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Filter the tree view in order for the units to be find faster
|
|
/// </summary>
|
|
private void rtbFilterUnits_TextChanged(object sender, EventArgs e)
|
|
{
|
|
treeViewUnits.Filter = null;
|
|
treeViewUnits.Filter = rtbFilterUnits.Text;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="node"></param>
|
|
/// <returns></returns>
|
|
private bool FilterNode(RadTreeNode node)
|
|
{
|
|
// add Group and 'All units' Nodes
|
|
if (node.Level < 2)
|
|
return true;
|
|
|
|
// add unit if no filtering is required
|
|
if (!rtbFilterUnits.Visible || (rtbFilterUnits.Visible && rtbFilterUnits.Text.Length == 0))
|
|
return true;
|
|
|
|
// add unit if the name contains the desired text
|
|
if (node.Text.ToUpper().Contains(rtbFilterUnits.Text.Trim().ToUpper()))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
/// <summary>
|
|
/// Set the type of the item inside the tree view to be
|
|
/// a Custom Tree Node which will hav the Color in the right
|
|
/// and as a property of the object
|
|
/// </summary>
|
|
private void treeViewUnits_CreateNodeElement(object sender, CreateTreeNodeElementEventArgs e)
|
|
{
|
|
e.NodeElement = new CustomTreeNodeElement();
|
|
if (e.NodeElement.ContentElement is ColorTreeContentElement)
|
|
{
|
|
ColorTreeContentElement treeElement = e.NodeElement.ContentElement as ColorTreeContentElement;
|
|
treeElement.OnColorChanged += delegate(object s2, ColorTreeContentElement.ColorChangedEventArgs e2)
|
|
{
|
|
if (e2.unitName != null && e2.unitName.Length > 0)
|
|
{
|
|
((Vehicle)MainForm2.vehicleHT[e2.unitName]).histcolor = e2.newColor;
|
|
|
|
String imageColor = "#" + e2.newColor.R.ToString("X2") + e2.newColor.G.ToString("X2") + e2.newColor.B.ToString("X2");
|
|
VisualSettings.InsertUpdateHTforVisualItems("histColor", ((Vehicle)MainForm2.vehicleHT[e2.unitName]).sc_id+"", imageColor);
|
|
}
|
|
};
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Format the ticks color
|
|
/// </summary>
|
|
private void timeTrackBar_TickFormatting(object sender, TickFormattingEventArgs e)
|
|
{
|
|
e.TickElement.Line1.BackColor = Color.Red;
|
|
e.TickElement.Line2.BackColor = Color.Orange;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Change the text which is displayed in the timeTrackBar
|
|
/// It will display the start and the end date on the
|
|
/// sides of the track bar
|
|
/// </summary>
|
|
private void timeTrackBar_LabelFormatting(object sender, LabelFormattingEventArgs e)
|
|
{
|
|
if (e.LabelElement.IsTopLeft && e.LabelElement.TrackBarElement != null)
|
|
{
|
|
//Utils.WriteLine("val : " + e.LabelElement.Text, ConsoleColor.Red);
|
|
e.LabelElement.Text = (Int32.Parse(e.LabelElement.Text) + 1) + "";
|
|
}
|
|
/*
|
|
DateTime start = DateTime.Now.AddDays(-1);
|
|
DateTime end = DateTime.Now;
|
|
|
|
// if not last 24 hours is selected
|
|
if (rdpStartTime.Enabled)
|
|
{
|
|
start = rdpStartTime.Value;
|
|
end = rdpEndTime.Value;
|
|
}
|
|
|
|
//make the top left display the start date
|
|
if (e.LabelElement.IsTopLeft)
|
|
{
|
|
if (e.LabelElement.Text.Equals("0"))
|
|
{
|
|
e.LabelElement.Text = String.Format("{0:HH:mm:ss}", start);
|
|
}
|
|
else if (e.LabelElement.Text.Equals(ListforGrid.Count+""))
|
|
{
|
|
e.LabelElement.Text = String.Format("{0:HH:mm:ss}", end);
|
|
}
|
|
else
|
|
e.LabelElement.Text = "";
|
|
}
|
|
else
|
|
{
|
|
// bottom row
|
|
if(e.LabelElement.Text.Equals("0"))
|
|
{
|
|
e.LabelElement.Text = String.Format("{0:MM/dd/yyyy}", start);
|
|
}
|
|
else if (e.LabelElement.Text.Equals(ListforGrid.Count + ""))
|
|
{
|
|
e.LabelElement.Text = String.Format("{0:MM/dd/yyyy}", end);
|
|
}
|
|
else
|
|
e.LabelElement.Text = "";
|
|
}*/
|
|
}
|
|
|
|
/// <summary>
|
|
/// Change the position which is displayed on the history
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void timeTrackBar_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
Utils.WriteLine(timeTrackBar.Value.ToString(), ConsoleColor.Yellow);
|
|
|
|
if (changeTrackbarValueFromCode)
|
|
{
|
|
changeTrackbarValueFromCode = false;
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
SMposition tmpos = (SMposition)Point_for_play[(Int32)timeTrackBar.Value];
|
|
|
|
Index_to_play = (Int32)timeTrackBar.Value;
|
|
|
|
updatecomand = FormatUpdateCommand(tmpos, FirstGoogle);
|
|
if (FirstGoogle)
|
|
FirstGoogle = false;
|
|
|
|
Int32 index = tmpos.m_evnt_id;
|
|
if ((index >= 0) && (index < gridHistoryPoints.RowCount))
|
|
{
|
|
// idx
|
|
gridHistoryPoints.Rows[index].IsSelected = true;
|
|
gridHistoryPoints.Rows[index].IsCurrent = true;
|
|
}
|
|
|
|
|
|
updatecomand = FormatUpdateCommand(tmpos, FirstGoogle);
|
|
|
|
ExecuteScript(updatecomand);
|
|
ExecuteScript("putOnMap,none,heading_positions");
|
|
ExecuteScript($"openInfo,{vehSelect}");
|
|
ExecuteScript($"centerzoom,{tmpos.m_lat},{tmpos.m_lng},-1");
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Utils.WriteLine("Exception on timetrack bar: "+ex.ToString(),ConsoleColor.Red);
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Reset the visual UI for the history tab, including speeds,
|
|
/// times, grids and animation
|
|
/// </summary>
|
|
private void rbResetHistory_Click(object sender, EventArgs e)
|
|
{
|
|
// remove old dataset points
|
|
if (docLoad)
|
|
{
|
|
ExecuteScript("reset");
|
|
}
|
|
|
|
MaxLAT = -90;
|
|
MaxLNG = -180;
|
|
MinLAT = 90;
|
|
MinLNG = 180;
|
|
Index_to_play = 0;
|
|
FirstGoogle = true;
|
|
selectedPositions.Clear();
|
|
|
|
if (gridHistoryPoints.Rows.Count > 0)
|
|
gridHistoryPoints.Rows.Clear();
|
|
|
|
gridHistoryPoints.DataSource = null;
|
|
|
|
|
|
// uncheck all units
|
|
foreach (RadTreeNode node in treeViewUnits.Nodes)
|
|
node.Checked = false;
|
|
|
|
|
|
|
|
// clear speed values
|
|
rseSpeedLower.Value = 0;
|
|
rseSpeedUpper.Value = 0;
|
|
|
|
// clear time values
|
|
rdpStartTime.Value = DateTime.Now.AddDays(-1);
|
|
rdpEndTime.Value = DateTime.Now;
|
|
|
|
|
|
try
|
|
{
|
|
Point_for_play.Clear();
|
|
ListforGrid.Clear();
|
|
if (timeTrackBar.Maximum > 0)
|
|
{
|
|
changeTrackbarValueFromCode = true;
|
|
timeTrackBar.Value = 0;
|
|
timeTrackBar.Maximum = 0;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Utils.WriteLine("Exception put all elements on 0: " + ex.ToString(), ConsoleColor.Red);
|
|
}
|
|
|
|
// reset the animation
|
|
rbStop.PerformClick();
|
|
|
|
rlAnimation.Text = MainForm2.returnLNGString("histAnimation");
|
|
|
|
// disable the history result window
|
|
foreach (Control ctr in windowHistoryResult.Controls)
|
|
ctr.Enabled = false;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Show or hide labels of history points that are displayed on the map
|
|
/// </summary>
|
|
private void rcbShowLabels_ToggleStateChanged(object sender, StateChangedEventArgs args)
|
|
{
|
|
try
|
|
{
|
|
if (rcbShowLabels.ToggleState == Telerik.WinControls.Enumerations.ToggleState.On)
|
|
|
|
ExecuteScript("putlabels, heading_positions");
|
|
else
|
|
ExecuteScript("removelabels, heading_positions");
|
|
|
|
Thread.Sleep(1);
|
|
|
|
checkbox_UpdateHT(sender, args);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("ExLive13:" + ex.ToString());
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Show or hide the geofences on the map
|
|
/// </summary>
|
|
private void rcbShowGeofence_ToggleStateChanged(object sender, StateChangedEventArgs args)
|
|
{
|
|
try
|
|
{
|
|
if (rcbShowGeofence.Checked)
|
|
ForceShowZone();
|
|
else ForceHideZone();
|
|
|
|
checkbox_UpdateHT(sender, args);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SM.Debug("ExLive13:" + ex.ToString());
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Change the buttons background color for the animation buttons depending on their enabled/disabled
|
|
/// state
|
|
/// </summary>
|
|
private void rbtAnimation_EnabledChanged(object sender, EventArgs e)
|
|
{
|
|
Color bkColor = ((RadButton)sender).Enabled ? MainForm2.ButtonColor : MainForm2.ButtonColorDisabled;
|
|
((RadButton)sender).ButtonElement.ButtonFillElement.BackColor = bkColor;
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Event handler for when the left tab panel needs to be docked/transfor in floating state.
|
|
/// This will cancel this event in order to prevent the stupid case with hiding the dock window
|
|
/// </summary>
|
|
private void radDock1_DockStateChanging(object sender, DockStateChangingEventArgs e)
|
|
{
|
|
e.Cancel = true;
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// Change background color for the row according to its state and theme
|
|
/// </summary>
|
|
private void treeViewUnits_NodeFormatting(object sender, TreeNodeFormattingEventArgs e)
|
|
{
|
|
if (e.NodeElement.IsSelected)
|
|
{
|
|
e.NodeElement.DrawFill = true;
|
|
e.NodeElement.BackColor = MainForm2.GridSelectedRow;
|
|
e.NodeElement.NumberOfColors = 1;
|
|
}
|
|
else
|
|
e.NodeElement.DrawFill = false;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Change background color for the row according to its state and theme
|
|
/// </summary>
|
|
private void gridHistoryPoints_RowFormatting(object sender, RowFormattingEventArgs e)
|
|
{
|
|
if (e.RowElement.IsSelected)
|
|
{
|
|
e.RowElement.DrawFill = true;
|
|
e.RowElement.BackColor = MainForm2.GridSelectedRow;
|
|
e.RowElement.NumberOfColors = 1;
|
|
}
|
|
else
|
|
e.RowElement.DrawFill = false;
|
|
}
|
|
|
|
|
|
|
|
#region CHANGE TABS BACKGROUND
|
|
private DockWindow oldDockWindow = null;
|
|
private void radDock1_ActiveWindowChanging(object sender, DockWindowCancelEventArgs e)
|
|
{
|
|
// reset the background icon for the previous tab
|
|
e.OldWindow.TabStripItem.BackColor = Color.White;
|
|
e.OldWindow.TabStripItem.DrawFill = true;
|
|
e.OldWindow.TabStripItem.NumberOfColors = 1;
|
|
|
|
// reset the background for the new window
|
|
e.NewWindow.TabStripItem.DrawFill = true;
|
|
e.NewWindow.TabStripItem.NumberOfColors = 1;
|
|
e.NewWindow.TabStripItem.BackColor = MainForm2.TabSelectedColor;
|
|
|
|
// save old dock window
|
|
oldDockWindow = e.OldWindow;
|
|
}
|
|
|
|
private void radDock1_ActiveWindowChanged(object sender, DockWindowEventArgs e)
|
|
{
|
|
// reset the background icon for the previous tab
|
|
oldDockWindow.TabStripItem.BackColor = Color.White;
|
|
oldDockWindow.TabStripItem.DrawFill = true;
|
|
oldDockWindow.TabStripItem.NumberOfColors = 1;
|
|
|
|
e.DockWindow.TabStripItem.DrawFill = true;
|
|
e.DockWindow.TabStripItem.NumberOfColors = 1;
|
|
e.DockWindow.TabStripItem.BackColor = MainForm2.TabSelectedColor;
|
|
|
|
}
|
|
#endregion
|
|
|
|
private void checkbox_UpdateHT(object sender, StateChangedEventArgs args)
|
|
{
|
|
VisualSettings.InsertUpdateHTforVisualItems(this.Name, ((RadCheckBox)sender).Name, ((RadCheckBox)sender).Checked.ToString());
|
|
}
|
|
|
|
private void rse_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
if (isLoaded)
|
|
{
|
|
|
|
RadSpinEditor spinEditor = sender as RadSpinEditor;
|
|
|
|
int value = Convert.ToInt32(spinEditor.Value);
|
|
if (spinEditor.Name.Equals("rseSpeedLower") || spinEditor.Name.Equals("rseSpeedUpper"))
|
|
{
|
|
if (MainForm2.isInMile) value = (int)(value * 1.60934);
|
|
}
|
|
|
|
VisualSettings.InsertUpdateHTforVisualItems(this.Name, spinEditor.Name, value.ToString());
|
|
|
|
string spinEditorName = string.Empty;
|
|
|
|
if (spinEditor.Name.Equals("rsePositionDisplay"))
|
|
spinEditorName = "hisPlayTime";
|
|
else if (spinEditor.Name.Equals("rseSkipSeconds"))
|
|
spinEditorName = "hisPauseTime";
|
|
|
|
if(!string.IsNullOrEmpty(spinEditorName))
|
|
VisualSettings.InsertUpdateHTforVisualItems(spinEditorName, value.ToString());
|
|
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Prevent the context menu to be shown for this grid
|
|
/// </summary>
|
|
private void gridHistoryPoints_ContextMenuOpening(object sender, ContextMenuOpeningEventArgs e)
|
|
{
|
|
// do not display the context menu
|
|
e.Cancel = true;
|
|
}
|
|
|
|
private void windowHistoryResult_Click(object sender, EventArgs e)
|
|
{
|
|
|
|
}
|
|
|
|
}
|
|
}
|