Firebird Duplicating items C# .NET

主宰稳场 提交于 2021-02-05 10:43:05

问题


We have a Till Software which also works with restaurants built on .NET (C#) and Firebird DB. We are having a strange problem recently, the items in an order are duplicating themselves when we go back to the order.

Strangely it's not the case always. It's happening only sometimes. I tried to figure out under what conditions it's happening but it's so random that it doesn't happen for a couple of days and then start duplicating items for the next two days.

The software is so huge that I don't know what code snippets to even post. As it's not happening always and is random I guess it doesn't have to do with the code but with Firebird DB maybe.

The other thing I wanted to mention is that we had a Firebird DB built on a 32-bit machine and when we tried to put it on a 64 - bit machine it didn't work. So, we had to take a backup of the DB on a 32-bit machine and restore it on a 64-bit machine and it worked with the software. I'm thinking does that have something to do with it? but we have another user on 32-bit with no conversion and it's the same case for him as well.

I'll really appreciate any help or guidance on this.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;
using Till_Library.Till_Controls;
using Till_Library.Till_Interfaces;
using Till_Library.Till_Presenters;
using Till_Library.Till_Types;

namespace Till_Library.Till_Views
{
    public partial class viewOrderItems : UserControl
    {
        private IOrder mIOrder;
        private PresenterOrder mPresenterOrder;
        private readonly List<OrderGridItemRow> mOrderItemRowList;

        private OrderGridItemRow mCurrentItemRow;

        private readonly Color paidBckcolour = Color.GreenYellow;

        private decimal mTillMode;

        private readonly int ITEM_GRID_ROWS;
        private int mItemGridStartIdx;
        private int mItemGridEndIdx;
        private int mLastDisplayedRowIdx;
        private int mLastItemCount;

        private bool mSplitMode;
        public bool mIsRefund;
        private RestTable mCurrentTable;

        public delegate void TillCustDetailsClickedHandler();

        public delegate void TillOrderItemPhoneClickedHandler();

        public delegate void TillOrderTableSelectionClickedHandler();

        public delegate void TillOrderTableCoverClickedHandler();

        public delegate void TillOrderPriceClickedHandler(Point KeyPadLocation);

        public delegate void TillOrderQuantityClickedHandler(Point KeyPadLocation);

        public delegate void TillOrderItemClickedHandler(bool Option);

        public delegate void TillOrderCheckBoxClickedHandler(OrderItemDetails pOrderItemRow);

        public viewOrderItems(bool isRefund = false)
        {
            InitializeComponent();

            ITEM_GRID_ROWS = 11;
            mItemGridStartIdx = 0;
            mItemGridEndIdx = ITEM_GRID_ROWS;
            mIsRefund = isRefund;
            int CurY = 0;
            mIOrder = new IOrder();

            mOrderItemRowList = new List<OrderGridItemRow>();
            for (int i = 1; i <= ITEM_GRID_ROWS; i++)
            {
                CreateOrderItemRowControl(i, CurY);
                CurY += 36;
            }
        }

        private void CreateOrderItemRowControl(int pIdx, int pCurY)
        {
            string ItemRowName = "orderGridItemRow" + pIdx;
            mOrderItemRowList.Add(new OrderGridItemRow(pIdx));
            mOrderItemRowList[pIdx - 1].Name = ItemRowName;
            mOrderItemRowList[pIdx - 1].Location = new Point(4, pCurY);
            mOrderItemRowList[pIdx - 1].Parent = panItems;
            //OrderItemRowList[pIdx - 1].Parent = panel2;
            mOrderItemRowList[pIdx - 1].OrderItemClicked += TillOrderItemClicked;
            mOrderItemRowList[pIdx - 1].OrderItemPriceClicked += TillOrderItemPriceClicked;
            mOrderItemRowList[pIdx - 1].OrderItemPriceLeft += TillOrderItemPriceLeft;
            mOrderItemRowList[pIdx - 1].OrderItemQuantityClicked += TillOrderItemQuantityClicked;
            mOrderItemRowList[pIdx - 1].OrderCheckBoxClicked += OrderCheckboxClicked;
            mOrderItemRowList[pIdx - 1].Visible = true;
            mOrderItemRowList[pIdx - 1].SetOrderType(false);
            mOrderItemRowList[pIdx - 1].IsRefund(mIsRefund);
        }

        [Category("Action")]
        [Description("Cust Details clicked.")]
        public event TillCustDetailsClickedHandler TillCustDetailsClicked;

        protected virtual void OnCustDetailsClicked()
        {
            if (TillCustDetailsClicked != null)
            {
                //if(mTillMode != 3)
                TillCustDetailsClicked(); // Notify Subscribers
            }
        }

        public void AttachInterface(IOrder pIOrder)
        {
            mIOrder = pIOrder;
        }

        public void AttachPresenter(PresenterOrder pPresenter)
        {
            mPresenterOrder = pPresenter;
        }

        public void AttachOptions(IOptions pIOptions)
        {
        }

        public void AttachTableControl(RestTable pTable)
        {
            if (pTable != null)
            {
                mCurrentTable = pTable;
                labTableNo.Text = mCurrentTable.Name;
            }
            else
            {
                labTableNo.Text = "0";
                labTableCovers.Text = "0";
            }
        }

        public void SetTillMode(decimal pTillMode)
        {
            mTillMode = pTillMode;

            if (mTillMode == 2) // Restaurant Mode
            {
                labTableNo.Visible = true;
                labTableNoDesc.Visible = true;
                labTableCovers.Visible = true;
                labTableCoversDesc.Visible = true;
                labCustName.Visible = false;
                labCustNameTitle.Visible = false;
            }
            else if (mTillMode == 3) // Supermarket Mode
            {
                // This till mode also stops OnCustDetailsClicked() from firing

                labTableNo.Visible = false;
                labTableNoDesc.Visible = false;
                labTableCovers.Visible = false;
                labTableCoversDesc.Visible = false;

                labCustName.Visible = false;
                labCustNameTitle.Visible = false;

                panPhone.Visible = false;
            }
            else // Takeaway Mode (Default)
            {
                labTableNo.Visible = false;
                labTableNoDesc.Visible = false;
                labTableCovers.Visible = false;
                labTableCoversDesc.Visible = false;

                labCustName.Visible = true;
                labCustNameTitle.Visible = true;
            }
        }

        public ORDERTYPE GetOrderType()
        {
            return mIOrder.mCurrentOrderDetails.OrderType;
        }

        public void DisplayOrder(bool pRecall, bool pMoveToLast = false)
        {
            mPresenterOrder.AttachOrderView(this);
            mPresenterOrder.AttachOrderItemRowList(mOrderItemRowList);

           if (mIOrder.mCurrentOrderItems.Count <= 11 && mIOrder.mCurrentOrderItems.Count > mLastItemCount &&
                !pRecall && mTillMode == 3)
                mPresenterOrder.ProcessPanelDisplayBETA(false);
            else
                mPresenterOrder.ProcessPanelDisplay(false, pMoveToLast); // time waster

            mLastItemCount = mIOrder.mCurrentOrderItems.Count; // Accumulated Quantity Bug Fix & void ln

           // DisplayOrderDetails();
        }

        public void DisplayOrderDetails()
        {
            labOrderNo.Text = mIOrder.mCurrentOrderDetails.OrderNo.ToString();
            labCustNo.Text = mIOrder.mCurrentOrderDetails.OrderCustDetails.CustNo;
            labTableNo.Text = mIOrder.mCurrentOrderDetails.OrderTableNo.ToString();
            labTableCovers.Text = mIOrder.mCurrentOrderDetails.OrderTableCovers.ToString();
            labCustNameTitle.Visible = false;
            labCustName.Text = mIOrder.mCurrentOrderDetails.OrderCustDetails.CustName;
            if (labCustName.Text != "")
            {
                labCustNameTitle.Visible = true;
            }

            //mPresenterOrder.UpdateTotals();
            //labDeliveryAmt.Text = mIOrder.mCurrentOrderDetails.OrderDeliveryTotal.ToString("0.00");
            //labDiscountAmt.Text = mIOrder.mCurrentOrderDetails.OrderDiscountPerc.ToString()+"%";         


            if (mIOrder.mCurrentOrderDetails.OrderDeliveryTotal > 0)
            {
                labDelivery.Text = "Delivery";
                labDelivery.Visible = true;
                labDeliveryAmt.Text = mIOrder.mCurrentOrderDetails.OrderDeliveryTotal.ToString("0.00");
            }
            else if (mTillMode == 3 && mIOrder.mCurrentOrderDetails.OrderQty > 0 &&
                     mIOrder.mCurrentOrderDetails.OrderVAT == 0)
            {
                labDelivery.Text = "Item Qty";
                labDelivery.Visible = true;
                labDeliveryAmt.Text = mIOrder.mCurrentOrderDetails.OrderQty.ToString();
            }
            else if (mIOrder.mCurrentOrderDetails.OrderVAT > 0)
            {
                labDelivery.Text = "VAT";
                labDelivery.Visible = true;
                labDeliveryAmt.Text = mIOrder.mCurrentOrderDetails.OrderVAT.ToString("0.00");

                labDelivery.Font = new Font(labNetAmt.Font.FontFamily.Name, labNetAmt.Font.Size);
            }
            else
            {
                labDelivery.Visible = false;
                labDeliveryAmt.Text = string.Empty;
            }

            if (mTillMode == 3 && mIOrder.mCurrentOrderDetails.OrderQty > 0 && mIOrder.mCurrentOrderDetails.OrderVAT > 0)
            {
                labDiscount.Text = "Item Qty";
                labDiscount.Visible = true;
                labDiscountAmt.Text = mIOrder.mCurrentOrderDetails.OrderQty.ToString();
            }
            else if (mIOrder.mCurrentOrderDetails.OrderDiscountAmt > 0)
            {
                labDiscount.Text = "Discount";
                labDiscount.Visible = true;
                labDiscountAmt.Text = mIOrder.mCurrentOrderDetails.OrderDiscountAmt.ToString("0.00");
            }
            else
            {
                labDiscount.Visible = false;
                labDiscountAmt.Text = string.Empty;
            }

            double NetAmount = mIOrder.mCurrentOrderDetails.OrderNET;
                // +mIOrder._mCurrentOrderDetails.OrderVAT;             

            if (mIOrder.mCurrentOrderDetails.OptionAddVATToPrice)
            {
                labNetAmt.Text = NetAmount.ToString("0.00");
                labTotalAmt.Text =
                    (NetAmount + +mIOrder.mCurrentOrderDetails.OrderVAT +
                     mIOrder.mCurrentOrderDetails.OrderDeliveryTotal - mIOrder.mCurrentOrderDetails.OrderDiscountAmt)
                        .ToString("0.00");
            }
            else
            {
                labNetAmt.Text = (NetAmount - mIOrder.mCurrentOrderDetails.OrderVAT).ToString("0.00");
                labTotalAmt.Text =
                    (NetAmount + mIOrder.mCurrentOrderDetails.OrderDeliveryTotal -
                     mIOrder.mCurrentOrderDetails.OrderDiscountAmt).ToString("0.00");
            }


            if (Convert.ToDouble(labTotalAmt.Text) < 0)
                labTotalAmt.Text = "0.00";

            CheckPaid();
        }

        public List<OrderGridItemRow> GetOrderItemRowList()
        {
            return mOrderItemRowList;
        }

        public IOrder GetIOrder()
        {
            return mIOrder;
        }

        public int GetPanelHeight()
        {
            return panItems.Height;
        }

        private void CheckPaid()
        {
            // RP Sets the total box to the local 'paidBckcolour' if the order displaied has been paid for, if not reverts back to default.
            if ((mIOrder.mCurrentOrderDetails.OrderPayment >= mIOrder.mCurrentOrderDetails.OrderTotal) &&
                mIOrder.mCurrentOrderDetails.OrderTotal != 0)
            {
                labDeliveryAmt.BackColor = paidBckcolour;
                labDiscountAmt.BackColor = paidBckcolour;
                labNetAmt.BackColor = paidBckcolour;
                labTotalAmt.BackColor = paidBckcolour;

                labDelivery.BackColor = paidBckcolour;
                labDiscount.BackColor = paidBckcolour;
                labNet.BackColor = paidBckcolour;
                labTotal.BackColor = paidBckcolour;
            }
            else
            {
                labDeliveryAmt.BackColor = Color.WhiteSmoke;
                labDiscountAmt.BackColor = Color.WhiteSmoke;
                labNetAmt.BackColor = Color.WhiteSmoke;
                labTotalAmt.BackColor = Color.WhiteSmoke;

                labDelivery.BackColor = Color.WhiteSmoke;
                labDiscount.BackColor = Color.WhiteSmoke;
                labNet.BackColor = Color.WhiteSmoke;
                labTotal.BackColor = Color.WhiteSmoke;
            }
        }

         private void btnOrderItemGridUp_Click(object sender, EventArgs e)
        {
            // TODO 
            bool bFirstItem = false;
            int OffsetIdx = 0;
            int OrderItemRowListCount = mOrderItemRowList.Count;

            if (OrderItemRowListCount > 0)
            {
                for (int i = 0; i < OrderItemRowListCount; i++)
                {
                    if (mOrderItemRowList[i].Top >= 0)
                    {
                        OffsetIdx = i;
                        break;
                    }
                }
            }
            mItemGridEndIdx = mItemGridStartIdx + OffsetIdx;
            mItemGridStartIdx = mItemGridEndIdx - ITEM_GRID_ROWS;
            if (mItemGridStartIdx < 0 && mItemGridEndIdx < ITEM_GRID_ROWS &&
                (mItemGridStartIdx + mItemGridEndIdx + OffsetIdx < ITEM_GRID_ROWS))
            {
                bFirstItem = true;
                mItemGridEndIdx = ITEM_GRID_ROWS;
            }

            if (!bFirstItem)
            {
                int GridRowOffset = mOrderItemRowList[mLastDisplayedRowIdx].Bottom - panItems.Height;

                if (OrderItemRowListCount > 0 && GridRowOffset > 0)
                {
                    for (int i = 0; i < OrderItemRowListCount; i++)
                    {
                        mOrderItemRowList[i].Location = new Point(1, mOrderItemRowList[i].Top - GridRowOffset);
                    }
                }
            }

            setItemGridIndex(mItemGridStartIdx, mItemGridEndIdx);
            mPresenterOrder.ProcessPanelDisplay(false);
            mLastDisplayedRowIdx = mPresenterOrder.mLastDisplayedRowIdx;
            mItemGridStartIdx = mPresenterOrder.mItemGridStartIdx;
            mItemGridEndIdx = mPresenterOrder.mItemGridEndIdx;
        }
        
        private void btnOrderItemGridDown_Click(object sender, EventArgs e)
        {
            int OffsetIdx = 0;
            int OrderItemListCount = mOrderItemRowList.Count;

            if (OrderItemListCount > 0)
            {
                for (int i = 0; i < OrderItemListCount; i++)
                {
                    if (mOrderItemRowList[i].Bottom > panItems.Height)
                    {
                        OffsetIdx = i;
                        break;
                    }
                }
            }

            if (OffsetIdx == 0)
            {
                OffsetIdx = ITEM_GRID_ROWS;
            }

            if (mItemGridStartIdx + OffsetIdx <= mIOrder.mCurrentOrderItems.Count)
            {
                mItemGridStartIdx += OffsetIdx;
                mItemGridEndIdx = mItemGridStartIdx + ITEM_GRID_ROWS;

                setItemGridIndex(mItemGridStartIdx, mItemGridEndIdx);

                mPresenterOrder.ProcessPanelDisplay(false);

                mLastDisplayedRowIdx = mPresenterOrder.mLastDisplayedRowIdx;
                mItemGridStartIdx = mPresenterOrder.mItemGridStartIdx;
                mItemGridEndIdx = mPresenterOrder.mItemGridEndIdx;
                //mPresenterOrder.DisplayOrderItems(mOrderItemRowList, panItems.Height);
            }
        }


        private void setItemGridIndex(int pStartIndex, int pEndIndex)
        {
            if (pStartIndex < 0)
                pStartIndex = 0;
            mPresenterOrder.mItemGridStartIdx = pStartIndex;
            mPresenterOrder.mItemGridEndIdx = pEndIndex;
            mPresenterOrder.mLastDisplayedRowIdx = mLastDisplayedRowIdx;
            // mLastDisplayedRowIdx = mPresenterOrder.mLastDisplayedRowIdx;
        }

        public void setSplitMode(bool pMode)
        {
            mSplitMode = pMode;
        }

        private void labCustNo_Click(object sender, EventArgs e)
        {
            OnCustDetailsClicked();
        }

        private void labCustNoDesc_Click(object sender, EventArgs e)
        {
            OnCustDetailsClicked();
        }

        private void labCustName_Click(object sender, EventArgs e)
        {
            OnCustDetailsClicked();
        }

        private void labCustNameTitle_Click(object sender, EventArgs e)
        {
            OnCustDetailsClicked();
        }

        private void labOrderNoDesc_Click(object sender, EventArgs e)
        {
            OnCustDetailsClicked();
        }

        private void labOrderNo_Click(object sender, EventArgs e)
        {
            OnCustDetailsClicked();
        }

        private void panCustInfo_Click(object sender, EventArgs e)
        {
            OnCustDetailsClicked();
        }

        public void TillMark2PrintClicked()
        {
            if (mIOrder.mCurrentOrderItems.Count > 0 && mCurrentItemRow != null)
            {
                mCurrentItemRow.SetMark2PrintOrderSelected(true);

                foreach (TillOrderItem item in mIOrder.mCurrentOrderItems)
                    if (item.GetItemID() == mIOrder.mCurrentOrderItemID)
                        if (!item.GetMarked2Print())
                            item.SetMark2Print(true);
                        else
                            item.SetMark2Print(false);
            }
        }

        public void TillMark2PrintReset()
        {
            foreach (TillOrderItem item in mIOrder.mCurrentOrderItems)
                item.SetMark2Print(false);
        }

        [Category("Action")]
        [Description("Order Item Price Clicked.")]
        public event TillOrderPriceClickedHandler TillOrderPriceClicked;

        protected virtual void OnTillOrderPriceClicked(Point pKeyPadLoc)
        {
            if (TillOrderPriceClicked != null)
            {
                TillOrderPriceClicked(pKeyPadLoc); // Notify Subscribers
            }
        }

        private void TillOrderItemPriceClicked(OrderGridItemRow pOrderItemRow)
        {
            OnTillOrderPriceClicked(GetRowLocation(pOrderItemRow));
        }

        private Point GetRowLocation(OrderGridItemRow pOrderItemRow)
        {
            int mKeyPadX, mKeyPadY;

            Point mFloutingKeypadLoc;

            mCurrentItemRow = pOrderItemRow;

            mKeyPadX = pOrderItemRow.Location.X + pOrderItemRow.Width + 2;
            mKeyPadY = pOrderItemRow.Parent.Location.Y + pOrderItemRow.Location.Y + (pOrderItemRow.Height/2);

            mPresenterOrder.ClearOrderItemGridSelections(false);
            mIOrder.mCurrentOrderItemID = mCurrentItemRow.ItemID;

            mFloutingKeypadLoc = new Point(mKeyPadX, mKeyPadY);

            return mFloutingKeypadLoc;
        }

        private bool TillOrderItemPriceLeft(double pNewItemPrice, double pOldItemPrice)
        {
            if (pOldItemPrice >= 0)
            {
                if (pNewItemPrice >= 0)
                {
                    if (SetTillItemPrice(pNewItemPrice))
                        return true;
                }
            }
            else
            {
                if (pNewItemPrice < 0)
                {
                    if (SetTillItemPrice(pNewItemPrice))
                        return true;
                }
            }
            return false;
        }

        private bool SetTillItemPrice(double pNewItemPrice)
        {
            foreach (TillOrderItem Item in mIOrder.mCurrentOrderItems)
            {
                if (Item.GetItemID() == mIOrder.mCurrentOrderItemID)
                {
                    Item.SetItemPrice(pNewItemPrice);
                    mPresenterOrder.UpdateTotals();
                    DisplayOrder(false);
                    return true;
                }
            }
            return false;
        }

        [Category("Action")]
        [Description("Order Item Quantity Clicked.")]
        public event TillOrderQuantityClickedHandler TillOrderQuantityClicked;

        protected virtual void OnTillOrderQuantityClicked(Point pKeyPadLoc)
        {
            if (TillOrderQuantityClicked != null)
            {
                TillOrderQuantityClicked(pKeyPadLoc); // Notify Subscribers
            }
        }

        private void TillOrderItemQuantityClicked(OrderGridItemRow pOrderItemRow)
        {
            OnTillOrderQuantityClicked(GetRowLocation(pOrderItemRow));
        }

        public void SetItemQty()
        {
            mCurrentItemRow.RefreshItemRow();

            if (mCurrentItemRow.ItemQty == 0)
                mCurrentItemRow.ItemQty = 1;

            mIOrder.mCurrentOrderItems[
                mIOrder.mCurrentOrderItems.FindIndex(i => i.GetItemID() == mIOrder.mCurrentOrderItemID)].SetItemQty(
                    (int) mCurrentItemRow.ItemQty);

            mPresenterOrder.UpdateTotals();
            DisplayOrder(false);
        }

        private void TillOrderItemClicked(OrderGridItemRow pOrderItemRow)
        {
            mCurrentItemRow = pOrderItemRow;
            mPresenterOrder.ClearOrderItemGridSelections(false);
            mIOrder.mCurrentOrderItemID = pOrderItemRow.ItemID;

            if (mSplitMode)
            {
                mPresenterOrder.SetAsSplitItem(mIOrder.mCurrentOrderItemID);
                DisplayOrder(false);
                mPresenterOrder.ProcessPanelDisplay(mSplitMode);
                //mPresenterOrder.ProcessPanelDisplay(!mSplitMode);
            }
            else
            {
                mCurrentItemRow.SetOrderItemSelected(true);
                ShowItemControls(true);

                //  viewfunc
            }
        }

        public void UpdatePhone()
        {
            if ((string) picPhone1.Tag == "1")
            {
                picPhone1.BackgroundImage = Properties.Resources.phone_ringing;
                panPhone.BackColor = Color.White;
                picPhone1.Tag = "2";
            }
            else
            {
                picPhone1.BackgroundImage = Properties.Resources.phone1;
                //picPhone1.BackColor = Color.Aqua;
                panPhone.BackColor = Color.FromArgb(114, 205, 206);
                picPhone1.Tag = "1";
            }
        }

        [Category("Action")]
        [Description("Order Item Phone Clicked.")]
        public event TillOrderItemPhoneClickedHandler TillOrderItemPhoneClicked;

        protected virtual void OnOrderItemPhoneClicked()
        {
            if (TillOrderItemPhoneClicked != null)
            {
                TillOrderItemPhoneClicked(); // Notify Subscribers
            }
        }

        private void picPhone1_Click(object sender, EventArgs e)
        {
            OnOrderItemPhoneClicked();
        }

        public void ResetPhone()
        {
            picPhone1.BackgroundImage = Properties.Resources.phone1;
            panPhone.BackColor = Color.Aqua;
            picPhone1.BackColor = Color.Aqua;
            picPhone1.Tag = "1";
        }

        public int getCurrentTableNo()
        {
            return Convert.ToInt32(labTableNo.Text);
        }


        [Category("Action")]
        [Description("Order Item Clicked, Show Controls")]
        public event TillOrderItemClickedHandler TillShowControls;

        protected virtual void OnTillShowControls(bool pOption)
        {
            if (TillShowControls != null)
            {
                TillShowControls(true); // Notify Subscribers
            }
        }

        private void OrderCheckboxClicked(OrderItemDetails pOrderItemRow)
        {
            OnOrderChecked(pOrderItemRow);
        }

        [Category("Action")]
        [Description("Order Checkbox Clicked")]
        public event TillOrderCheckBoxClickedHandler OrderChecked;

        protected virtual void OnOrderChecked(OrderItemDetails pOrderItemRow)
        {
            if(OrderChecked != null)
            {
                OrderChecked(pOrderItemRow);
            }
        }

        private void ShowItemControls(bool pOption)
        {
            OnTillShowControls(pOption);
        }


        [Category("Action")]
        [Description("Assign Order to Table Clicked.")]
        public event TillOrderTableSelectionClickedHandler TillOrderTableSelectionClicked;

        protected virtual void OnTillOrderTableSelectionClicked()
        {
            if (TillOrderTableSelectionClicked != null)
            {
                TillOrderTableSelectionClicked(); // Notify Subscribers
            }
        }

        private void panTableSel_Click(object sender, EventArgs e)
        {
            // Table Selections
            Console.Write("Table Selection");
            OnTillOrderTableSelectionClicked();
        }

        private void labTableNoDesc_Click(object sender, EventArgs e)
        {
            Console.Write("Table Selection");
            OnTillOrderTableSelectionClicked();
        }

        private void labTableNo_Click(object sender, EventArgs e)
        {
            Console.Write("Table Selection");
            OnTillOrderTableSelectionClicked();
        }

        [Category("Action")]
        [Description("Assign Customers to Table Clicked.")]
        public event TillOrderTableCoverClickedHandler TillOrderTableCoverClicked;

        protected virtual void OnTillOrderTableCoverClicked()
        {
            if (TillOrderTableCoverClicked != null)
            {
                TillOrderTableCoverClicked(); // Notify Subscribers
            }
        }

        private void panTableCov_Click(object sender, EventArgs e)
        {
            // No of People on Table, Selections
            Console.Write("Table Covers");
            OnTillOrderTableCoverClicked();
        }

        private void labTableCoversDesc_Click(object sender, EventArgs e)
        {
            Console.Write("Table Covers");
            OnTillOrderTableCoverClicked();
        }

        private void labTableCovers_Click(object sender, EventArgs e)
        {
            Console.Write("Table Covers");
            OnTillOrderTableCoverClicked();
        }
    }
}

来源:https://stackoverflow.com/questions/64875908/firebird-duplicating-items-c-sharp-net

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!