コード例 #1
0
        private void RemoveSlotMachineGroupFromUI(SlotMachineGroupPair slotGroupPair)
        {
            SlotMachineGroup newMachineGroup = slotGroupPair.MachineGroup;
            DispatcherObject parent = LogicalTreeHelper.GetParent(newMachineGroup);

            if (slotGroupPair.IsAdded &&
                parent != null)
            {
                //if (!Monitor.TryEnter(_floorView._clearLock, 5))
                //{
                //    clearMachines = true;
                //    break;
                //}
                _canvas.Children.Remove(newMachineGroup);
                slotGroupPair.IsAdded = false;
            }
        }
コード例 #2
0
        /// <summary>
        /// Refreshes the data.
        /// </summary>
        /// <param name="barPositions">The bar positions.</param>
        public void RefreshData(List<FloorStatusData> barPositions)
        {
            const string PROC = "[RefreshData]";
            double widthmargin = 10;
            double heightmargin = 20;
            var curPos = 1;
            bool clearMachines = false;
            bool groupby = false;
            _dispatcher.Invoke(new Action(
                   delegate()
                   {
                       groupby = _floorView.GroupByMachines;
                   }));
            bool hasPositionSaved = false;
            _floorView._teFloorPositions.Wait(TimeSpan.FromSeconds(30)); // wait for worst case seconds to retrive floor position from exchange server

            int userId = CDOSettings.Current.LoggedInUser.SecurityUserID;
            FloorPositionDto savedPositions = null;            

            try
            {
                // clear all the slot machine groupings
                if (_floorView.DisplayGroupMachines)
                {
                    foreach (var slotMachineGroupItem in _slotMachineGroups.Values)
                    {
                        slotMachineGroupItem.SlotMachineKeys.Clear();
                        if (!groupby)
                            _dispatcher.Invoke(new Action(
                                delegate()
                                {
                                    this.RemoveSlotMachineGroupFromUI(slotMachineGroupItem);
                                }));
                    }
                }

                // add or update the slot machines
                int rowIndex = 1;
                foreach (FloorStatusData position in barPositions)
                {
                    string key = position.Bar_Pos_Name;

                    _dispatcher.Invoke(new Action(
                        delegate()
                        {
                            SlotMachine newMachine = null;
                            SlotMachinePair pair = null;

                            if (_slotMachines.ContainsKey(key))
                            {
                                pair = _slotMachines[key];
                                newMachine = pair.Machine;
                            }
                            else
                            {
                                newMachine = new SlotMachine()
                                {
                                    SlotNumber = Convert.ToInt32(position.Bar_Pos_Name).ToString(),
                                    SlotNumberString = position.Bar_Pos_Name.ToString(),
                                    SlotID = position.Bar_Pos_No,
                                    AssetNumber = position.Asset_No
                                };
                                pair = new SlotMachinePair
                                {
                                    Key = key,
                                    PositionName = position.Bar_Pos_Name,
                                    AssetNo = position.Asset_No,
                                    Machine = newMachine
                                };
                                _slotMachines.Add(key, pair);
                            }

                            // slot status grouping
                            newMachine.SlotStatusString = position.Slot_Status;
                            SlotMachineGroupPair groupPair = null;
                            IList<string> groupItems = null;
                            if (_floorView.DisplayGroupMachines)
                            {
                                if (!_slotMachineGroups.ContainsKey(position.Slot_Status))
                                {
                                    groupPair = new SlotMachineGroupPair()
                                    {
                                        Status = _floorView.GetSlotStatus(position.Slot_Status),
                                        MachineGroup = new SlotMachineGroup()
                                        {
                                            Width = _canvas.Width - 10,
                                            Height = 30,
                                        },
                                        DisplayText = _floorView.GetSlotStatusDecription(position.Slot_Status),
                                    };
                                    _slotMachineGroups.Add(position.Slot_Status, groupPair);
                                }
                                else
                                {
                                    groupPair = _slotMachineGroups[position.Slot_Status];
                                }
                                groupItems = groupPair.SlotMachineKeys;
                                groupItems.Add(key);
                            }

                            // display game name instead of asset no
                            string assetNo = position.Asset_No;
                            if (Settings.DisplayGameNameInFloorView)
                            {
                                assetNo = position.Game_Name;
                            }

                            // Fix for Asset Number not displayed after finishing the Enrollment 
                            pair.AssetNo = assetNo;
                            newMachine.AssetNumber = assetNo;

                            pair.RowIndex = rowIndex++;
                            newMachine.Top = Convert.ToDouble(position.FLOORTOP);
                            newMachine.Left = Convert.ToDouble(position.FLOORLEFT);
                            _floorView.SetSlotMouseUpEvent(newMachine);

                            if (position.Install_No != 0)
                            {
                                newMachine.InstallationNo = position.Install_No;
                                newMachine.IsEventUnCleared = !(newMachine.IsEventUnCleared);
                                newMachine.IsEventUnCleared = (bool)position.UnClearedEvent;
                                newMachine.Status = (SlotMachineStatus)Enum.Parse(typeof(SlotMachineStatus), position.Slot_Status);
                                newMachine.StackerEventReceived = position.StackerEventReceived.HasValue ? position.StackerEventReceived.Value : false;
                                newMachine.IsCollectable = position.IsCollectable < 1;
                                if (newMachine.StackerEventReceived)
                                {
                                    newMachine.OuterRoundColor = Brushes.Goldenrod;
                                    newMachine.InnerRoundColor = Brushes.IndianRed;
                                }
                            }
                            else
                            {
                                newMachine.Status = SlotMachineStatus.EmptyPosition;
                                newMachine.InstallationNo = 0;
                            }
                            if (_floorView.DisplayGroupMachines &&
                                groupPair.MachineGroup.OuterColor == null)
                            {
                                groupPair.MachineGroup.OuterColor = _floorView._slotMachineGroupBgBrush;// newMachine.OuterRoundColor;
                                groupPair.MachineGroup.OuterForeColor = _floorView._slotMachineGroupFgBrush;// newMachine.ForeColorBrush;
                            }
                        }));
                }

                // remove the slot machine
                List<SlotMachinePair> removedMachines = (from a in _slotMachines
                                                         join b in barPositions
                                                         on a.Key equals b.Bar_Pos_Name
                                                         into matched
                                                         from c in matched.DefaultIfEmpty()
                                                         where c == null
                                                         select new SlotMachinePair
                                                         {
                                                             Key = a.Key,
                                                             Machine = a.Value.Machine
                                                         }).ToList();
                if (removedMachines != null)
                {
                    foreach (SlotMachinePair removedMachine in removedMachines)
                    {
                        _dispatcher.Invoke(new Action(
                        delegate()
                        {
                            this.ClearMachine(removedMachine.Machine);
                        }));
                        _slotMachines.Remove(removedMachine.Key);
                    }
                }

                // finally add the slot machines to the UI
                _dispatcher.Invoke(new Action(
                    delegate()
                    {
#if DEBUG
                        Stopwatch watch = new Stopwatch();
                        watch.Start();
#endif

                        try
                        {
                            if (groupby)
                            {
                                // draw the headers
                                int slotPerWidth = Convert.ToInt32((_floorView.Width - SlotMachine.SlotMachineGap) / SlotMachine.SlotMachineWidthGap);
                                int gap = SlotMachine.SlotMachineGap;
                                double y = gap;
                                foreach (var group in _slotMachineGroups)
                                {
                                    string title = group.Key;
                                    SlotMachineGroupPair groupPair = group.Value;
                                    SlotMachineGroup machineGroup = groupPair.MachineGroup;
                                    int slots = groupPair.SlotMachineKeys.Count;

                                    if (slots <= 0)
                                    {
                                        this.RemoveSlotMachineGroupFromUI(groupPair);
                                        continue;
                                    }
                                    this.AddSlotMachineGroupToUI(groupPair);

                                    groupPair.Left = 0;
                                    groupPair.Top = y;
                                    machineGroup.DisplayText = groupPair.DisplayText + " (" + slots.ToString() + ")";
                                    Canvas.SetLeft(machineGroup, groupPair.Left);
                                    Canvas.SetTop(machineGroup, groupPair.Top);
                                    _floorView.CalculateGroupedSlotMachines(groupPair, slotPerWidth);

                                    int row = 0;
                                    int column = 0;
                                    double sx = groupPair.Left + gap;
                                    double sy = groupPair.Top + machineGroup.Height + gap;
                                    foreach (var slotKey in groupPair.SlotMachineKeys)
                                    {
                                        SlotMachinePair slotPair = _slotMachines[slotKey];
                                        SlotMachine newMachine = slotPair.Machine;

                                        if (column >= slotPerWidth)
                                        {
                                            column = 0;
                                            row++;
                                            sx = groupPair.Left + gap;
                                            sy += SlotMachine.SlotMachineHeightGap;
                                        }

                                        Canvas.SetLeft(newMachine, sx);
                                        Canvas.SetTop(newMachine, sy);
                                        this.AddSlotMachineToUI(slotPair, newMachine);

                                        sx += SlotMachine.SlotMachineWidthGap;
                                        column++;
                                    }
                                    y += machineGroup.Height + groupPair.SlotsHeight + 5;
                                }

                                _canvas.Height = y + SlotMachine.SlotMachineGap;
                                _floorView.Border_Bottom.Margin = new Thickness(-50, 0, 0, 0);
                            }
                            else
                            {
                                List<string> orderedData = (from o in _slotMachines
                                                            orderby o.Value.RowIndex
                                                            select o.Key).ToList();
                                if (orderedData.Count > 72)
                                {
                                    _canvas.Height = (barPositions.Count / 12) * 110;
                                    _floorView.Border_Bottom.Width = 780;
                                    _floorView.Border_Bottom.Margin = new Thickness(-50, 0, 0, 0);
                                }

                                foreach (string slotKey in orderedData)
                                {
                                    SlotMachinePair slotPair = _slotMachines[slotKey];
                                    SlotMachine newMachine = slotPair.Machine;
                                    FloorPositionDataDto floorPosition = null;

                                    if (_floorView._floorViewUserLocations)
                                    {
                                        floorPosition = _floorView.GetFloorPosition(newMachine.SlotID);
                                        if (floorPosition != null)
                                        {
                                            newMachine.PositionData = floorPosition;
                                        }
                                    }

                                    UIElement dragging = _canvas.ElementBeingDragged;
                                    bool isDragging = false;
                                    if (dragging != null && dragging == newMachine)
                                    {
                                        isDragging = true;
                                    }

                                    if (!isDragging && _floorView._floorViewUserLocations)
                                    {
                                        if (floorPosition != null)
                                        {
                                            newMachine.Left = floorPosition.Left;
                                            newMachine.Top = floorPosition.Top;
                                            DragCanvas.SetZIndex(newMachine, floorPosition.RowNo);
                                        }
                                    }

                                    if (newMachine != null && !isDragging)
                                    {
                                        if (newMachine.Left > 0 || newMachine.Top > 0)
                                        {
                                            if ((_floorView.chkSortPos.IsChecked.Value) ||
                                                (_floorView.chkSortAsset.IsChecked.Value))
                                            {
                                                newMachine.Top = 0;
                                                newMachine.Left = 0;

                                                // Don't uncomment these lines, we should not reposition the slot machines during loading.
                                                // Slot machines position should be saved only during dragging.
                                                //if (newMachine.Status != SlotMachineStatus.EmptyPosition)
                                                //{
                                                //    _floorView.SaveFloorPosition(newMachine, true, ref hasPositionSaved);
                                                //}
                                                _floorView.CalculatePositionAndPaint(ref widthmargin, ref heightmargin, ref curPos, newMachine);
                                            }
                                            else
                                            {
                                                Canvas.SetLeft(newMachine, Convert.ToDouble(newMachine.Left));
                                                Canvas.SetTop(newMachine, Convert.ToDouble(newMachine.Top));
                                            }
                                        }
                                        else
                                        {
                                              _floorView.CalculatePositionAndPaint(ref widthmargin, ref heightmargin, ref curPos, newMachine);
                                              if (_floorView._floorViewUserLocations)
                                              {
                                                  if (!(_floorView.chkSortPos.IsChecked.Value &&
                                                        _floorView.chkSortAsset.IsChecked.Value))
                                                  {
                                                      if (savedPositions == null) savedPositions = new FloorPositionDto();
                                                      savedPositions.Modify(userId, newMachine.SlotID, TypeSystem.GetValueInt(newMachine.Left), TypeSystem.GetValueInt(newMachine.Top), 0);
                                                  }
                                              }
                                        }

                                        //// save the initial positions
                                        //if (CFloorView._FirstDragPosition)
                                        //{
                                        //    if (savedPositions == null) savedPositions = new FloorPositionDto();
                                        //    savedPositions.Modify(userId, newMachine.SlotID, TypeSystem.GetValueInt(newMachine.Left), TypeSystem.GetValueInt(newMachine.Top), 0);
                                        //}

                                        this.AddSlotMachineToUI(slotPair, newMachine);
                                    }
                                }
                            }
                        }
                        catch (ThreadAbortException)
                        {
                            LogManager.WriteLog(PROC + " => Thread was instructed to close.", LogManager.enumLogLevel.Error);
                        }
                        catch (Exception ex)
                        {
                            ExceptionManager.Publish(ex);
                        }
                        finally
                        {
#if DEBUG
                            watch.Stop();
                            LogManager.WriteLog(PROC + string.Format(" => Total time taken [{0}] to load the slot machines into UI.", watch.Elapsed.ToString()), LogManager.enumLogLevel.Info);
#endif
                            if (hasPositionSaved)
                            {
                                CDOSettings.Current.Save();
                            }

                            // notify the initial positions to all the clients logged in with the current user id
                            if (savedPositions != null && savedPositions.Count > 0)
                            {
                                _floorView.NotifyFloorPosition(savedPositions);                                
                            }
                            //if (CFloorView._FirstDragPosition)
                            //{
                            //    CFloorView._FirstDragPosition = false;
                            //}
                        }
                    }));

                if (clearMachines)
                {
                    LogManager.WriteLog(PROC + " => Unable to refresh. Clear machines called instead.", LogManager.enumLogLevel.Error);
                }
            }
            catch (ThreadAbortException)
            {
                LogManager.WriteLog(PROC + " => Thread was instructed to close.", LogManager.enumLogLevel.Error);
            }
            catch (Exception ex)
            {
                LogManager.WriteLog(PROC + " => Exception occured in function.", LogManager.enumLogLevel.Error);
                ExceptionManager.Publish(ex);
            }
            finally
            {
#if DEBUG
                LogManager.WriteLog(PROC + " => Finished.", LogManager.enumLogLevel.Error);
#endif
            }
        }
コード例 #3
0
        private void AddSlotMachineGroupToUI(SlotMachineGroupPair slotGroupPair)
        {
            SlotMachineGroup newMachineGroup = slotGroupPair.MachineGroup;
            DispatcherObject parent = LogicalTreeHelper.GetParent(newMachineGroup);

            if (!slotGroupPair.IsAdded ||
                parent == null)
            {
                _canvas.Children.Add(newMachineGroup);
                slotGroupPair.IsAdded = true;
            }
        }
コード例 #4
0
 internal void CalculateGroupedSlotMachines(SlotMachineGroupPair group, int slotPerWidth)
 {
     try
     {
         var slotLength = group.SlotMachineKeys.Count;
         int slotPerHeight = Convert.ToInt32(Math.Ceiling((double)(slotLength) / slotPerWidth));
         var ch = (slotPerHeight * SlotMachine.SlotMachineHeightGap) + SlotMachine.SlotMachineGap;
         group.SlotsHeight = ch;
     }
     catch { }
 }