DataTable dt; 

private void Permissions_Load(object sender, EventArgs e){
                  dt = new DataTable();
                  dt.Columns.Add("Feature", typeof(string));
                  dt.Columns.Add("None", typeof(bool));
                  dt.Columns.Add("ReadOnly", typeof(bool));
                  dt.Columns.Add("ReadWrite", typeof(bool));

                  datagridview1.Datasource=dt;
}

private void btnSave_Click(object sender, EventArgs e){

in the grid when i'll click on the any checkbox i want to pass parameter to this function SetPermission( , , );
parameter will be from the two enumeratons below
How manage it?

here picture Picture 
}

 public void SetPermission(Permission feature, PermissionType permission, int userID) {
                  SqlCommand cmd = new SqlCommand("Insert into Permissions       (UserID,Feature,Permission)Values(@UserID,@Feature,@Permission)", con);

                  cmd.Parameters.Add(new SqlParameter("UserID", userID));

 }



      public enum Permission : int
      {
            Country = 0,
            Store = 1,
            City = 2
      }

      public enum PermissionType : byte
      {
            None = 0,
            ReadOnly = 1,
            ReadWrite = 2
      }

        // This event occurs before the cell's state is committed,
        // so you have to check the current value and then negate it
        // to get the proposed state change...
        private void dataGridView1_CellContentClick(object sender, DataGridViewCellEventArgs e)
        {
            int iCol = e.ColumnIndex;
            int iRow = e.RowIndex;
 
            if (dataGridView1.Rows[iRow].Cells[iCol].ValueType == typeof(bool))
            {
                if (dataGridView1.Rows[iRow].Cells[iCol].Value == null ||
                    (bool)dataGridView1.Rows[iRow].Cells[iCol].Value == false)
                {
                    dataGridView1.Rows[iRow].Cells[iCol].Value = true;
                }
                else
                {
                    dataGridView1.Rows[iRow].Cells[iCol].Value = false;
                }
 
            }
        }
 
        // Occurs when the value is changed...
        private void dataGridView1_CellValueChanged(object sender, DataGridViewCellEventArgs e)
        {
            int iCol = e.ColumnIndex;
            int iRow = e.RowIndex;
            if (iRow > -1 & iCol > -1)
            {
                if (dataGridView1.Rows[iRow].Cells[iCol].ValueType == typeof(bool))
                {
                    bool bChecked = (bool)dataGridView1.Rows[iRow].Cells[iCol].Value;
                }
            }
        }

        const int iNoneCol = (int)PermissionType.None + 1;
        const int iROCol = (int)PermissionType.ReadOnly + 1;
        const int iRWCol = (int)PermissionType.ReadWrite + 1;
 
        const int iCountryRow = (int)Permission.Country;
        const int iStoreRow = (int)Permission.Store;
        const int iCityRow = (int)Permission.City;
 
        private void InitCheckBoxValues()
        {
            for (int iRow = iCountryRow; iRow <= iCityRow; iRow++)
            {
                DataGridViewCheckBoxCell cbcNone = (DataGridViewCheckBoxCell)dataGridView1.Rows[iRow].Cells[iNoneCol];
                DataGridViewCheckBoxCell cbcRO = (DataGridViewCheckBoxCell)dataGridView1.Rows[iRow].Cells[iROCol];
                DataGridViewCheckBoxCell cbcRW = (DataGridViewCheckBoxCell)dataGridView1.Rows[iRow].Cells[iRWCol];
 
                cbcNone.Value = cbcNone.TrueValue = true;
                cbcNone.FalseValue = false;
 
                cbcRO.Value = cbcRO.FalseValue = false;
                cbcRW.Value = cbcRW.FalseValue = false;
                cbcRO.TrueValue = cbcRW.TrueValue = true;
            }
        }
 
        // Occurs when the value is changed...
        private void dataGridView1_CellValueChanged(object sender, DataGridViewCellEventArgs e)
        {
            int iCol = e.ColumnIndex;
            int iRow = e.RowIndex;
            if (iRow > -1 & iCol >= iNoneCol)
            {
                System.Diagnostics.Debug.Assert(dataGridView1.Rows[iRow].Cells[iCol].ValueType == typeof(bool));
 
                DataGridViewCheckBoxCell cbcNone = (DataGridViewCheckBoxCell)dataGridView1.Rows[iRow].Cells[iNoneCol];
                DataGridViewCheckBoxCell cbcRO = (DataGridViewCheckBoxCell)dataGridView1.Rows[iRow].Cells[iROCol];
                DataGridViewCheckBoxCell cbcRW = (DataGridViewCheckBoxCell)dataGridView1.Rows[iRow].Cells[iRWCol];
 
                if (iCol == iNoneCol && cbcNone.Value == cbcNone.TrueValue)
                {
                    cbcRO.Value = cbcRO.FalseValue;
                    cbcRW.Value = cbcRW.FalseValue;
                }
                else if (iCol == iROCol && cbcRO.Value == cbcRO.TrueValue)
                {
                    cbcNone.Value = cbcNone.FalseValue;
                    cbcRW.Value = cbcRW.FalseValue;
                }
                else if (iCol == iRWCol && cbcRW.Value == cbcRW.TrueValue)
                {
                    cbcNone.Value = cbcNone.TrueValue;
                    cbcRO.Value = cbcRO.TrueValue;
                }
                // default to none CB if none selected...
                if (!(cbcRO.Value == cbcRO.TrueValue || cbcRW.Value == cbcRW.TrueValue))
                    cbcNone.Value = cbcNone.TrueValue;
            }
        }
 
        private void UpdatePermissions(int userID)
        {
 
            for (int iRow = iCountryRow; iRow <= iCityRow; iRow++)
            {
                Permission feature = (Permission)iRow;
                PermissionType permission;
 
                DataGridViewCheckBoxCell cbcNone = (DataGridViewCheckBoxCell)dataGridView1.Rows[iRow].Cells[iNoneCol];
                DataGridViewCheckBoxCell cbcRO = (DataGridViewCheckBoxCell)dataGridView1.Rows[iRow].Cells[iROCol];
                DataGridViewCheckBoxCell cbcRW = (DataGridViewCheckBoxCell)dataGridView1.Rows[iRow].Cells[iRWCol];
                if (cbcNone.Value == cbcNone.TrueValue)
                    permission = PermissionType.None;
                else if (cbcRO.Value == cbcRO.TrueValue)
                    permission = PermissionType.ReadOnly;
                else if (cbcRW.Value == cbcRW.TrueValue)
                    permission = PermissionType.ReadWrite;
                else
                {
                    permission = PermissionType.None; // must assign something...
                    System.Diagnostics.Debug.Assert(false); // nothing selected!!!???
                }
 
                SetPermission(feature, permission, userID);
            }
        }

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using PermissionType = ForumSolutions.DatabaseStuff.PermissionsTable.PermissionType;
using PermissionsTable = ForumSolutions.DatabaseStuff.PermissionsTable;
 
namespace ForumSolutions
{
    public partial class Form_DataGridView_PermissionsTable : Form
    {
        DataTable dt;
        const int iNoneCol = (int)PermissionType.None + 1;
        const int iROCol = (int)PermissionType.ReadOnly + 1;
        const int iRWCol = (int)PermissionType.ReadWrite + 1;
 
        public Form_DataGridView_PermissionsTable()
        {
            InitializeComponent();
        }
 
        private void Form_DataGridView_Load(object sender, EventArgs e)
        {
            dataGridView1.SuspendLayout();
 
            dt = PermissionsTable.LoadTable();
            dataGridView1.DataSource = dt;
 
            dataGridView1.ResumeLayout(true);
        }
 
        // This event occurs before the cell's state is committed,
        private void dataGridView1_CellContentClick(object sender, DataGridViewCellEventArgs e)
        {
            int c = e.ColumnIndex;
            int r = e.RowIndex;
 
            // if this is a checkbox...
            if (dataGridView1.Rows[r].Cells[c].ValueType == typeof(bool))
                // Toggle the checked state...
                dataGridView1.Rows[r].Cells[c].Value = !(bool)(dataGridView1.Rows[r].Cells[c].Value);
        }
 
        // Occurs when the value is changed...
        static bool bUpdating = false; // used to turn off logic block while updating checkboxes...
        private void dataGridView1_CellValueChanged(object sender, DataGridViewCellEventArgs e)
        {
            int c = e.ColumnIndex;
            int r = e.RowIndex;
            if (r > -1 & c >= iNoneCol && !bUpdating)
            {
                // Prevent this event block from executing for values we are changing in here...
                bUpdating = true;
 
                // Ensure the cell being updated is a checkbox (bool)...
                System.Diagnostics.Debug.Assert(dataGridView1.Rows[r].Cells[c].ValueType == typeof(bool));
 
                // Get the cells as checkboxes...
                DataGridViewCheckBoxCell cbcNone = (DataGridViewCheckBoxCell)dataGridView1.Rows[r].Cells[iNoneCol];
                DataGridViewCheckBoxCell cbcRO = (DataGridViewCheckBoxCell)dataGridView1.Rows[r].Cells[iROCol];
                DataGridViewCheckBoxCell cbcRW = (DataGridViewCheckBoxCell)dataGridView1.Rows[r].Cells[iRWCol];
 
                // Toggle states as only one checkbox checked per row is allowed...
 
                // None
                if (c == iNoneCol && cbcNone.Value.Equals(true))
                {
                    cbcRO.Value = false;
                    cbcRW.Value = false;
                }
                // Read only
                else if (c == iROCol && cbcRO.Value.Equals(true))
                {
                    cbcNone.Value = false;
                    cbcRW.Value = false;
                }
                // Read Write
                else if (c == iRWCol && cbcRW.Value.Equals(true))
                {
                    cbcNone.Value = false;
                    cbcRO.Value = false;
                }
                // default to None if not Read or Write selected...
                if (!(cbcRO.Value.Equals(true) || cbcRW.Value.Equals(true)))
                    cbcNone.Value = true;
 
                // Allow normal event operation to continue...
                bUpdating = false;
            }
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            foreach (DataRow dr in dt.Rows)
            {
                textBox1.AppendText(
                    dr["Property"] + "\t" +
                    dr["None"] + "\t" +
                    dr["Read_Only"] + "\t" +
                    dr["Read_Write"] + "\r\n");
            }
            textBox1.AppendText("\r\n");
        }
 
        private void button2_Click(object sender, EventArgs e)
        {
            if (!PermissionsTable.SaveTable(dt))
                MessageBox.Show("Error saving table...");
        }
 
        private void UpdatePermissions(int userID)
        {
            //for (int iRow = iCountryRow; iRow <= iCityRow; iRow++)
            for (int r=0; r<dt.Rows.Count; r++)
            {
                DataRow dr = dt.Rows[r];
 
                //Permission feature = (Permission)iRow;
                PermissionType permissionType;
 
                if (dr["None"].Equals(true))
                    permissionType = PermissionType.None;
                else if (dr["Read_Only"].Equals(true))
                    permissionType = PermissionType.ReadOnly;
                else if (dr["Read_Write"].Equals(true))
                    permissionType = PermissionType.ReadWrite;
                else
                {
                    System.Diagnostics.Debug.Assert(false); // should not be here!!!
                    permissionType = PermissionType.None; // must assign something...
                }
 
                string feature = "Object " + r;
                SetPermission(feature, permissionType, userID);
            }
        }
 
        //public void SetPermission(Permission feature, PermissionType permission, int userID)
        public void SetPermission(string objName, PermissionType permission, int userID)
        {
        }
 
    }
}

    public class DatabaseStuff
    {
        public class PermissionsTable
        {
            public enum PermissionType : byte
            {
                None = 0,
                ReadOnly = 1,
                ReadWrite = 2
            }
 
            public static DataTable LoadTable()
            {
                DataTable dt = new DataTable();
 
                dt.Columns.Add("Property", typeof(string));
                dt.Columns.Add("None", typeof(bool));
                dt.Columns.Add("Read_Only", typeof(bool));
                dt.Columns.Add("Read_Write", typeof(bool));
 
                for (int i = 0; i < 10; i++)
                {
                    DataRow dr = dt.NewRow();
                    dr["Property"] = "Object " + i;
                    dr["None"] = true;
                    dr["Read_Only"] = false;
                    dr["Read_Write"] = false;
                    dt.Rows.Add(dr);
                }
 
                return dt;
            }
            public static bool SaveTable(DataTable dt)
            {
                return true;
            }
        }

public partial class Permissions : Form
    {
 
        private SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["G1_StoreHouse.Properties.Settings.StoreHouseConnectionString"].ConnectionString);
        DataTable dt;
 
        DataGridViewCheckBoxCell cbcNone;
        DataGridViewCheckBoxCell cbcRO;
        DataGridViewCheckBoxCell cbcRW;
 
        const int noneCol = (int)PermissionType.None + 1;
        const int roCol = (int)PermissionType.ReadOnly + 1;
        const int rwCol = (int)PermissionType.ReadWrite + 1;
 
        const int countryRow = (int)Permission.Country;
        const int storeRow = (int)Permission.Store;
        const int cityRow = (int)Permission.City;
 
        public Permissions()
        {
            InitializeComponent();
        }
 
        private void Permissions_Load(object sender, EventArgs e)
        {
            this.users_VTableAdapter.Fill(this.usersDS.Users_V);
 
            dt = new DataTable();
            dt.Columns.Add("Feature", typeof(string));
            dt.Columns.Add("None", typeof(bool));
            dt.Columns.Add("ReadOnly", typeof(bool));
            dt.Columns.Add("ReadWrite", typeof(bool));
 
            cmbUsers.Text = "--(Pelase Select)--";
 
            foreach (string item in Enum.GetNames(typeof(Permission)))
            {
                dt.Rows.Add(item, true, false, false);
            }
 
            dataGridView1.DataSource = dt;
        }
 
 
 
        public void SetPermission(Permission feature, PermissionType permission, int userID, int i)
        {
 
 
            SqlCommand cmd1 = new SqlCommand("Delete from Permissions where UserID=@UserID", con);
            cmd1.Parameters.Add(new SqlParameter("UserID", userID));
 
            SqlCommand cmd = new SqlCommand(@"Insert into Permissions 
                                              (UserID,Feature,Permission)
                                              Values
                                              (@UserID,@Feature,@Permission)", con);
            cmd.Parameters.Add(new SqlParameter("UserID", userID));
            cmd.Parameters.Add(new SqlParameter("Feature", (int)feature));
            cmd.Parameters.Add(new SqlParameter("Permission", (int)permission));
 
            if (i == 0)
            {
 
                cmd1.Connection.Open();
                cmd1.ExecuteNonQuery();
                cmd1.Connection.Close();
                cmd.Connection.Open();
                cmd.ExecuteNonQuery();
                cmd.Connection.Close();
            }
            else
            {
                cmd.Connection.Open();
                cmd.ExecuteNonQuery();
                cmd.Connection.Close();
            }
 
 
 
 
 
        }
 
 
 
        public PermissionType GetPermission(Permission feature, int userID)
        {
            SqlCommand cmd = new SqlCommand("select Permission from Permissions where UserID=@UserID and Feature=@Feature", con);
            cmd.Parameters.Add(new SqlParameter("UserID", userID));
            cmd.Parameters.Add(new SqlParameter("Feature", (int)feature));
 
            try
            {
                cmd.Connection.Open();
                SqlDataReader dr = cmd.ExecuteReader();
                if (dr.Read())
                {
                    return (PermissionType)dr[0];
                }
                else
                {
                    return PermissionType.None;
                }
            }
            finally
            {
                cmd.Connection.Close();
            }
        }
 
        private void btnSave_Click(object sender, EventArgs e)
        {
            int i = 0;
            for (int Row = countryRow; Row <= cityRow; Row++)
            {
                Permission feature = (Permission)Row;
                PermissionType permission = new PermissionType();
 
                bool cbcNone = (bool)dataGridView1.Rows[Row].Cells[noneCol].Value;
                bool cbcRO = (bool)dataGridView1.Rows[Row].Cells[roCol].Value;
                bool cbcRW = (bool)dataGridView1.Rows[Row].Cells[rwCol].Value;
                if (cbcNone)
                    permission = PermissionType.None;
                if (cbcRO)
                    permission = PermissionType.ReadOnly;
                if (cbcRW)
                    permission = PermissionType.ReadWrite;
 
 
                int k = i++;
                SetPermission(feature, permission, (int)cmbUsers.SelectedValue, k);
 
            }
        }
 
 
 
        private void dataGridView1_CellContentClick(object sender, DataGridViewCellEventArgs e)
        {
            int c = e.ColumnIndex;
            int r = e.RowIndex;
 
            if (dataGridView1.Rows[r].Cells[c].ValueType == typeof(bool))
                dataGridView1.Rows[r].Cells[c].Value = !(bool)(dataGridView1.Rows[r].Cells[c].Value);
 
            cbcNone = (DataGridViewCheckBoxCell)dataGridView1.Rows[r].Cells[noneCol];
            cbcRO = (DataGridViewCheckBoxCell)dataGridView1.Rows[r].Cells[roCol];
            cbcRW = (DataGridViewCheckBoxCell)dataGridView1.Rows[r].Cells[rwCol];
 
            if (c == noneCol && cbcNone.Value.Equals(true))
            {
                cbcRO.Value = false;
                cbcRW.Value = false;
            }
            else if (c == roCol && cbcRO.Value.Equals(true))
            {
                cbcNone.Value = false;
                cbcRW.Value = false;
            }
            else if (c == rwCol && cbcRW.Value.Equals(true))
            {
                cbcNone.Value = false;
                cbcRO.Value = false;
            }
        }
 
        private void cmbUsers_SelectionChangeCommitted(object sender, EventArgs e)
        {
            dt = new DataTable();
            dt.Columns.Add("Feature", typeof(string));
            dt.Columns.Add("None", typeof(bool));
            dt.Columns.Add("ReadOnly", typeof(bool));
            dt.Columns.Add("ReadWrite", typeof(bool));
 
            foreach (string item in Enum.GetNames(typeof(Permission)))
            {
                Permission s = (Permission)Enum.Parse(typeof(Permission), item);
                PermissionType pt = GetPermission((Permission)Enum.Parse(typeof(Permission), item), (int)cmbUsers.SelectedValue);
                dt.Rows.Add(item, pt == PermissionType.None, pt == PermissionType.ReadOnly, pt == PermissionType.ReadWrite);
 
            }
 
            dataGridView1.DataSource = dt;
        }
 
 
 
    }
 
 
    public enum Permission : int
    {
        Country = 0,
        Store = 1,
        City = 2
    }
 
    public enum PermissionType : byte
    {
        None = 0,
        ReadOnly = 1,
        ReadWrite = 2
    }