Beispiel #1
0
        /// <summary>
        /// This is called when a bound control on the new row changes
        /// </summary>
        /// <param name="sender">The sender of the event</param>
        /// <param name="e">The event arguments</param>
        /// <remarks>When a bound control on the new row changes, we can turn off the <see cref="IsNewRowInternal"/>
        /// flag so that the row will be committed when it loses the focus.</remarks>
        private void Target_PropertyChanged(object sender, EventArgs e)
        {
            // Occasionally, this gets called again after we've already seen it and added the row.  Ignore those
            // calls.
            if (!this.IsNewRowInternal)
            {
                return;
            }

            // See if the user wants to allow the addition
            DataListCancelEventArgs ce = new DataListCancelEventArgs(-1, null);

            this.TemplateParent.OnAddingRow(ce);

            if (ce.Cancel)
            {
                this.CancelChanges();
            }
            else
            {
                this.IsNewRowInternal = false;
                this.WirePropChangedEvents(false);
                this.TemplateParent.AddNewRowTemplate();

                // Tell the user the new row has been added
                this.TemplateParent.OnAddedRow(new DataListEventArgs(this.TemplateParent.CurrentRow, this));
            }
        }
        /// <summary>
        /// Prevent phone information from being entered if the parent row doesn't yet exist in the related data
        /// source or is not valid.
        /// </summary>
        /// <param name="s">The sender of the event</param>
        /// <param name="e">The event arguments</param>
        private void dlPhones_AddingRow(object sender, DataListCancelEventArgs e)
        {
            DataRowView drv = (DataRowView)dnNav.ListManager.List[dnNav.CurrentRow];

            if(drv.IsNew)
            {
                // The add must always be canceled
                e.Cancel = true;

                // If not valid, go back to the panel.  If valid, we need to rebind or the related data source
                // doesn't always pick up on the fact that the parent row got added.
                if(!dnNav.IsValid)
                    txtLName.Focus();
                else
                    dlPhones.SetDataBinding(dsAddresses, "Addresses.AddrPhone", typeof(PhoneRow));
            }
        }
        /// <summary>
        /// This is called when a bound control on the new row changes
        /// </summary>
        /// <param name="sender">The sender of the event</param>
        /// <param name="e">The event arguments</param>
        /// <remarks>When a bound control on the new row changes, we can turn off the <see cref="IsNewRowInternal"/>
        /// flag so that the row will be committed when it loses the focus.</remarks>
        private void Target_PropertyChanged(object sender, EventArgs e)
        {
            // Occasionally, this gets called again after we've already seen it and added the row.  Ignore those
            // calls.
            if(!this.IsNewRowInternal)
                return;

            // See if the user wants to allow the addition
            DataListCancelEventArgs ce = new DataListCancelEventArgs(-1, null);
            this.TemplateParent.OnAddingRow(ce);

            if(ce.Cancel)
                this.CancelChanges();
            else
            {
                this.IsNewRowInternal = false;
                this.WirePropChangedEvents(false);
                this.TemplateParent.AddNewRowTemplate();

                // Tell the user the new row has been added
                this.TemplateParent.OnAddedRow(new DataListEventArgs(this.TemplateParent.CurrentRow, this));
            }
        }
Beispiel #4
0
        /// <summary>
        /// Handle the escape key press to cancel changes
        /// </summary>
        /// <returns>Always returns true</returns>
        private bool HandleEscapeKey()
        {
            TemplateControl tc;
            int row;

            tc = this.CurrentItem;

            if(tc != null && !tc.IsNewRowInternal)
            {
                // Row may not be the same afterwards if canceling changes on the new row
                row = currentRow;

                DataListCancelEventArgs ce = new DataListCancelEventArgs(row, tc);

                OnCancelingEdits(ce);

                if(!ce.Cancel)
                {
                    this.CancelChanges();

                    // If the row changed, pass null and -1 to indicate that the old row went away
                    if(currentRow != row)
                        OnCanceledEdits(new DataListEventArgs(-1, null));
                    else
                        OnCanceledEdits(new DataListEventArgs(row, tc));
                }
            }

            return true;
        }
Beispiel #5
0
        /// <summary>
        /// This is called to handle the actual deletion of rows when requested by the user and also when a row
        /// is deleted externally from the data source other than by us.
        /// </summary>
        /// <param name="delRow">The row to delete</param>
        /// <param name="externalRequest">True if the request didn't come from us, false if it was requested by
        /// us.</param>
        private bool DeleteRowInternal(int delRow, bool externalRequest)
        {
            Control c;
            ControlCollection cc;
            TemplateControl tc;
            int ctlRow;

            // Nested deletes are not supported
            if(inDelRow)
                return false;

            ctlRow = delRow;

            if(showSep)
                ctlRow *= 2;

            cc = pnlRows.Controls;
            tc = (TemplateControl)cc[ctlRow];

            // Ignore the request if on the new row template
            if(tc.IsNewRowInternal)
                return false;

            // If someone besides us removed the row, remove the row template without asking
            if(!externalRequest)
                try
                {
                    inDelRow = true;

                    // See if the user will allow the delete to occur
                    DataListCancelEventArgs ce = new DataListCancelEventArgs(delRow, tc);

                    // Allow the row template a chance to allow or deny the deletion.  It has the current row
                    // values in its controls which may or may not be in the data source yet due to the way data
                    // binding works.
                    if(tc.CanDelete)
                        OnDeletingRow(ce);
                    else
                        ce.Cancel = true;

                    // Ignore the request if canceled
                    if(ce.Cancel)
                    {
                        // Return focus to the row template to avoid some weird data binding issues
                        if(!tc.ContainsFocus)
                            tc.Focus();

                        return false;
                    }

                    // If deleting the current row, cancel any pending changes
                    if(delRow == currentRow)
                        this.CancelChanges();
                }
                finally
                {
                    inDelRow = false;
                }

            Cursor oldCursor = this.Cursor;

            if(oldCursor != Cursors.WaitCursor)
                this.Cursor = Cursors.WaitCursor;

            try
            {
                inDelRow = true;

                // Remove the row template and separator
                pnlRows.SuspendLayout();
                cc.RemoveAt(ctlRow);
                tc.Dispose();

                if(showSep)
                {
                    c = cc[ctlRow];
                    cc.RemoveAt(ctlRow);
                    c.Dispose();
                }

                // Delete the row from the data source if it is there
                if(!externalRequest && delRow < listManager.Count)
                    listManager.RemoveAt(delRow);

                // Adjust the row selection if necessary
                if(selStart != -1)
                    if(delRow >= selStart && delRow <= selEnd)
                    {
                        selEnd--;

                        if(selEnd < selStart)
                            selStart = selEnd = -1;
                    }
                    else
                        if(delRow < selStart)
                        {
                            selStart--;
                            selEnd--;
                        }

                // Adjust the position of the other controls and rebind them to their new row
                while(ctlRow < cc.Count)
                {
                    c = cc[ctlRow];
                    c.Top -= rowHeight;

                    tc = c as TemplateControl;

                    if(tc != null && !tc.IsNewRowInternal)
                    {
                        tc.SetRowSourceInternal(listManager.List[delRow]);
                        delRow++;
                    }

                    ctlRow++;
                }
            }
            finally
            {
                if(oldCursor != Cursors.WaitCursor)
                    this.Cursor = oldCursor;

                inDelRow = false;
                pnlRows.ResumeLayout();
            }

            lblRowCount.Text = LR.GetString("DLNavRowCount", listManager.Count);

            if(rowHeadersVisible)
            {
                this.Invalidate(new Rectangle(0, 0, rowHeaderWidth, this.Height), false);
                this.Update();
            }

            // Force the focus to the proper row
            currentRow = -1;
            DataSource_PositionChanged(this, EventArgs.Empty);

            OnDeletedRow(new DataListEventArgs(-1, null));

            // If there are no rows and additions are allowed, focus the new row template
            if(currentRow == -1 && changePolicy.AllowAdditions)
                this.RowTemplate_Enter(pnlRows.Controls[0], EventArgs.Empty);

            btnDelete.Enabled = (changePolicy.AllowDeletes &&
                listManager.Count > 0);

            return true;
        }
Beispiel #6
0
        /// <summary>
        /// This raises the <see cref="CancelingEdits"/> event
        /// </summary>
        /// <param name="e">The event arguments</param>
        protected internal virtual void OnCancelingEdits(DataListCancelEventArgs e)
        {
            var handler = CancelingEdits;

            if(handler != null)
                handler(this, e);
        }
Beispiel #7
0
        /// <summary>
        /// This raises the <see cref="DeletingRow"/> event
        /// </summary>
        /// <param name="e">The event arguments</param>
        protected virtual void OnDeletingRow(DataListCancelEventArgs e)
        {
            var handler = DeletingRow;

            if(handler != null)
                handler(this, e);
        }
Beispiel #8
0
        /// <summary>
        /// This raises the <see cref="AddingRow"/> event
        /// </summary>
        /// <param name="e">The event arguments</param>
        protected internal virtual void OnAddingRow(DataListCancelEventArgs e)
        {
            var handler = AddingRow;

            if(handler != null)
                handler(this, e);
        }