示例#1
0
        private void toolStripMenuItemTreeViewEdit_Click(object sender, EventArgs e)
        {
            TreeListNode treeListNode = treeList.FocusedNode;
            Type type = treeListNode.Tag.GetType();

            if (type == typeof(Slyce.TemplateInfo.Option))
            {
                Slyce.ITemplate.IOption option = (Slyce.ITemplate.IOption)treeListNode.Tag;
                Slyce.ITemplate.IUserOption userOption = null;
                object parentObject = treeListNode.ParentNode.ParentNode.Tag;
                Type parentType = parentObject.GetType();

                if (parentType == typeof(ArchAngel.Providers.Database.Model.Table) ||
                parentType == typeof(ArchAngel.Providers.Database.Model.View) ||
                parentType == typeof(ArchAngel.Providers.Database.Model.StoredProcedure))
                {
                    ArchAngel.Providers.Database.Model.ScriptObject parentScriptObject = (ArchAngel.Providers.Database.Model.ScriptObject)parentObject;

                    for (int i = 0; i < parentScriptObject.UserOptions.Count; i++)
                    {
                        if (parentScriptObject.UserOptions[i].Name == option.VariableName)
                        {
                            userOption = parentScriptObject.UserOptions[i];
                            FormObjectOptionEdit form = new FormObjectOptionEdit(option, userOption, parentScriptObject);

                            if (form.ShowDialog(this.ParentForm) == DialogResult.OK)
                            {
                                Controller.MainForm.Cursor = Cursors.WaitCursor;
                                parentScriptObject.UserOptions[i].Value = form.UserOption.Value;
                                treeList.Selection[0].Tag = form.CurrentOption;
                                treeList.Selection[0].SetValue(1, form.UserOption.Value);
                                ProcessTreeValidity(treeList.Nodes);
                                Controller.MainForm.Cursor = Cursors.Default;
                            }

                            //((ArchAngel.Providers.Database.Model.ScriptObject)treeList.Selection[0].ParentNode.ParentNode.Tag).UserOptions[i].Value = Convert.ChangeType(form.CurrentOption.DefaultValue, form.CurrentOption.VarType);
                            //parentScriptObject.UserOptions[i].Value = Convert.ChangeType(form.CurrentOption.DefaultValue, form.CurrentOption.VarType);
                            break;
                        }
                    }
                    return;
                }
                else if (parentType == typeof(ArchAngel.Providers.Database.Model.Column))
                {
                    ArchAngel.Providers.Database.Model.Column parentColumn = (ArchAngel.Providers.Database.Model.Column)parentObject;

                    for (int i = 0; i < parentColumn.UserOptions.Count; i++)
                    {
                        if (parentColumn.UserOptions[i].Name == option.VariableName)
                        {
                            userOption = parentColumn.UserOptions[i];
                            FormObjectOptionEdit form = new FormObjectOptionEdit(option, userOption, parentColumn);

                            if (form.ShowDialog(this.ParentForm) == DialogResult.OK)
                            {
                                Controller.MainForm.Cursor = Cursors.WaitCursor;
                                parentColumn.UserOptions[i].Value = form.UserOption.Value;
                                treeList.Selection[0].Tag = form.CurrentOption;
                                treeList.Selection[0].SetValue(1, form.UserOption.Value);
                                ProcessTreeValidity(treeList.Nodes);
                                Controller.MainForm.Cursor = Cursors.Default;
                            }
                            break;
                        }
                    }
                    return;
                }
            }
            ScriptBase scriptBase = (ScriptBase)treeListNode.Tag;

            if (type == typeof(ArchAngel.Providers.Database.Model.Table) ||
                type == typeof(ArchAngel.Providers.Database.Model.View) ||
                type == typeof(ArchAngel.Providers.Database.Model.StoredProcedure))
            {
                FormScriptObject form = new FormScriptObject((ScriptObject)scriptBase, (ScriptObject[])treeListNode.ParentNode.Tag);

                if (form.ShowDialog(this.ParentForm) == DialogResult.OK)
                {
                    Controller.MainForm.Cursor = Cursors.WaitCursor;
                    UpdateTreeListNodeText(treeListNode, form.ScriptObject);

                    //TreeListHelper.TreeListNodeValidate(treeListNode);
                    foreach (ArchAngel.Providers.Database.Model.Database database in Controller.Instance.BllDatabase.Databases)
                    {
                        database.SnapshotMode = true;
                    }
                    treeList.BeginUpdate();
                    //ValidateNode(treeListNode);
                    ProcessTreeValidity(treeList.Nodes);
                    treeList.EndUpdate();

                    foreach (ArchAngel.Providers.Database.Model.Database database in Controller.Instance.BllDatabase.Databases)
                    {
                        database.SnapshotMode = false;
                    }
                    Controller.MainForm.Cursor = Cursors.Default;
                    return;
                }
            }
            else if (type == typeof(Column))
            {
                FormColumn form = new FormColumn((Column)scriptBase);

                if (form.ShowDialog(this.ParentForm) == DialogResult.OK)
                {
                    Controller.MainForm.Cursor = Cursors.WaitCursor;
                    UpdateTreeListNodeText(treeListNode, form.Column);

                    //TreeListHelper.TreeListNodeValidate(treeListNode.ParentNode);
                    ProcessTreeValidity(treeList.Nodes);
                    Controller.MainForm.Cursor = Cursors.Default;
                    return;
                }
            }
            else if (type == typeof(MapColumn))
            {
                FormMapColumn form = new FormMapColumn((ScriptObject)treeListNode.ParentNode.ParentNode.Tag, (MapColumn)scriptBase);

                if (form.ShowDialog(this.ParentForm) == DialogResult.OK)
                {
                    Controller.MainForm.Cursor = Cursors.WaitCursor;
                    MapColumn mapColumn = (MapColumn)scriptBase;

                    UpdateTreeListNodeText(treeListNode, form.MapColumn);

                    //TreeListHelper.TreeListNodeValidate(treeListNode.ParentNode);
                    ProcessTreeValidity(treeList.Nodes);
                    Controller.MainForm.Cursor = Cursors.Default;
                    return;
                }
            }
            else if (type.BaseType == typeof(Relationship))
            {
                ArchAngel.Providers.Database.Model.Database database = (ArchAngel.Providers.Database.Model.Database)treeListNode.ParentNode.ParentNode.ParentNode.ParentNode.ParentNode.Tag;
                FormRelationship form = new FormRelationship((Relationship)scriptBase, Controller.Instance.BllDatabase.ScriptObjects);

                if (form.ShowDialog(this.ParentForm) == DialogResult.OK)
                {
                    Controller.MainForm.Cursor = Cursors.WaitCursor;
                    UpdateTreeListNodeText(treeListNode, form.PrimaryRelationship);

                    //TreeListHelper.TreeListNodeValidate(treeListNode.ParentNode.ParentNode);
                    ProcessTreeValidity(treeList.Nodes);
                    Controller.MainForm.Cursor = Cursors.Default;
                    return;
                }
            }
            else if (type == typeof(Filter))
            {
                ArchAngel.Providers.Database.Model.Database database = (ArchAngel.Providers.Database.Model.Database)treeListNode.ParentNode.ParentNode.ParentNode.ParentNode.Tag;
                Filter filter = (Filter)scriptBase;

                FormFilter2 form;
                // Stored Procedure Filters can only be created from other Stored Procedures (Enabled or Disabled)
                if (filter.Parent.GetType() == typeof(ArchAngel.Providers.Database.Model.StoredProcedure))
                {
                    form = new FormFilter2(this.ParentForm, filter, database.StoredProcedures);
                }
                else
                {
                    form = new FormFilter2(this.ParentForm, filter, database.EnabledScriptObjects);
                }
                if (form.ShowDialog(this.ParentForm) == DialogResult.OK)
                {
                    Controller.MainForm.Cursor = Cursors.WaitCursor;
                    UpdateTreeListNodeText(treeListNode, form.Filter);

                    //TreeListHelper.TreeListNodeValidate(treeListNode.ParentNode);
                    ProcessTreeValidity(treeList.Nodes);
                    Controller.MainForm.Cursor = Cursors.Default;
                    return;
                }
            }
            else if (type == typeof(Index))
            {
                FormIndex form = new FormIndex((Index)scriptBase);

                if (form.ShowDialog(this.ParentForm) == DialogResult.OK)
                {
                    Controller.MainForm.Cursor = Cursors.WaitCursor;
                    UpdateTreeListNodeText(treeListNode, form.Index);

                    //TreeListHelper.TreeListNodeValidate(treeListNode.ParentNode);
                    ProcessTreeValidity(treeList.Nodes);
                    Controller.MainForm.Cursor = Cursors.Default;
                    return;
                }
            }
            else if (type == typeof(Key))
            {
                FormKey form = new FormKey((Key)scriptBase);

                if (form.ShowDialog(this.ParentForm) == DialogResult.OK)
                {
                    Controller.MainForm.Cursor = Cursors.WaitCursor;
                    UpdateTreeListNodeText(treeListNode, form.Key);

                    //TreeListHelper.TreeListNodeValidate(treeListNode.ParentNode);
                    ProcessTreeValidity(treeList.Nodes);
                    Controller.MainForm.Cursor = Cursors.Default;
                    return;
                }
            }
        }
示例#2
0
        private void toolStripMenuItemTreeViewEdit_Click(object sender, EventArgs e)
        {
            Refresh();
            Node treeListNode = treeList.SelectedNode;
            Type type = treeListNode.Tag.GetType();

            if (type == typeof(Lookup))
            {
                try
                {
                    Interfaces.Events.SetCursor(Cursors.WaitCursor);
                    this.Refresh();
                    FormLookup form = new FormLookup((Lookup)treeListNode.Tag);

                    if (form.ShowDialog(ParentForm) == DialogResult.OK)
                    {
                        treeList.BeginUpdate();
                        treeListNode.Text = form.Lookup.Alias;
                        treeListNode.Tag = form.Lookup;
                        treeList.EndUpdate();
                        return;
                    }
                }
                finally
                {
                    Interfaces.Events.UnShadeMainForm();
                    Interfaces.Events.RaiseRefreshApplicationEvent();
                    Interfaces.Events.SetCursor(Cursors.Default);
                    this.Refresh();
                }
            }
            else if (type == typeof (Option))
            {
                IOption option = (IOption) treeListNode.Tag;
                IUserOption userOption;
                object parentObject = treeListNode.Parent.Parent.Tag;
                Type parentType = parentObject.GetType();

                Type scriptBaseInterface = typeof (IScriptBaseObject);

                if (scriptBaseInterface.IsInstanceOfType(parentObject))
                {
                    IScriptBaseObject parentScriptObject = (IScriptBaseObject) parentObject;

                    for (int i = 0; i < parentScriptObject.Ex.Count; i++)
                    {
                        if (parentScriptObject.Ex[i].Name == option.VariableName)
                        {
                            userOption = parentScriptObject.Ex[i];
                            FormVirtualPropertyEdit form = new FormVirtualPropertyEdit(userOption,
                                                                                                                               parentScriptObject);

                            if (form.ShowDialog(ParentForm) == DialogResult.OK)
                            {
                                Interfaces.Events.UnShadeMainForm();
                                Interfaces.Events.RaiseRefreshApplicationEvent();
                                Interfaces.Events.SetCursor(Cursors.WaitCursor);
                                treeList.BeginUpdate();
                                ProcessTreeValidity(treeList.Nodes);
                                treeList.EndUpdate();
                                Interfaces.Events.SetCursor(Cursors.Default);
                            }
                            break;
                        }
                    }
                    return;
                }
                if (parentType == typeof (Column))
                {
                    Column parentColumn = (Column) parentObject;

                    for (int i = 0; i < parentColumn.Ex.Count; i++)
                    {
                        if (parentColumn.Ex[i].Name == option.VariableName)
                        {
                            userOption = parentColumn.Ex[i];
                            FormVirtualPropertyEdit form = new FormVirtualPropertyEdit(userOption,
                                                                                                                               parentColumn);

                            if (form.ShowDialog(ParentForm) == DialogResult.OK)
                            {
                                Interfaces.Events.UnShadeMainForm();
                                Interfaces.Events.RaiseRefreshApplicationEvent();
                                Interfaces.Events.SetCursor(Cursors.WaitCursor);
                                treeList.BeginUpdate();
                                parentColumn.Ex[i].Value = form.VirtualProperty.Value;
                                treeList.SelectedNode.Cells[1].Text = form.VirtualProperty.Value.ToString();
                                ProcessTreeValidity(treeList.Nodes);
                                treeList.EndUpdate();
                                Interfaces.Events.SetCursor(Cursors.Default);
                            }
                            break;
                        }
                    }
                    return;
                }
            }
            if (type == typeof (Association))
            {
                frmAssociationWizard.Association = (Association) treeListNode.Tag;
                frmAssociationWizard form = new frmAssociationWizard();

                if (form.ShowDialog(ParentForm) == DialogResult.OK)
                {
                    Interfaces.Events.UnShadeMainForm();
                    Interfaces.Events.RaiseRefreshApplicationEvent();
                    Interfaces.Events.SetCursor(Cursors.WaitCursor);
                    treeList.BeginUpdate();
                    treeListNode.Cells[1].Text = frmAssociationWizard.Association.Name;
                    treeListNode.Tag = frmAssociationWizard.Association;
                    SetNodeImage(treeListNode, Images.GreenBullet);

                    foreach (Model.Database database in ProviderInfo.TheBllDatabase.Databases)
                    {
                        database.SnapshotMode = true;
                    }
                    ProcessTreeValidity(treeList.Nodes);
                    treeList.EndUpdate();

                    foreach (Model.Database database in ProviderInfo.TheBllDatabase.Databases)
                    {
                        database.SnapshotMode = false;
                    }
                    Interfaces.Events.RaiseIsDirtyEvent();
                    Interfaces.Events.SetCursor(Cursors.Default);
                    return;
                }
                return;
            }
            ScriptBase scriptBase = (ScriptBase) treeListNode.Tag;

            if (type == typeof (Table) ||
                type == typeof (View) ||
                type == typeof (StoredProcedure))
            {
                FormScriptObject form = new FormScriptObject((ScriptObject) scriptBase, (ScriptObject[]) treeListNode.Parent.Tag);

                if (form.ShowDialog(ParentForm) == DialogResult.OK)
                {
                    Interfaces.Events.UnShadeMainForm();
                    Interfaces.Events.RaiseRefreshApplicationEvent();
                    Interfaces.Events.SetCursor(Cursors.WaitCursor);
                    treeList.BeginUpdate();
                    UpdateTreeListNodeText(treeListNode, form.ScriptObject);

                    foreach (Model.Database database in ProviderInfo.TheBllDatabase.Databases)
                    {
                        database.SnapshotMode = true;
                    }
                    ProcessTreeValidity(treeList.Nodes);
                    treeList.EndUpdate();

                    foreach (Model.Database database in ProviderInfo.TheBllDatabase.Databases)
                    {
                        database.SnapshotMode = false;
                    }
                    Interfaces.Events.SetCursor(Cursors.Default);
                    return;
                }
            }
            else if (type == typeof (Column))
            {
                FormColumn form = new FormColumn((Column) scriptBase);

                if (form.ShowDialog(ParentForm) == DialogResult.OK)
                {
                    Interfaces.Events.UnShadeMainForm();
                    Interfaces.Events.RaiseRefreshApplicationEvent();
                    Interfaces.Events.SetCursor(Cursors.WaitCursor);
                    treeList.BeginUpdate();
                    UpdateTreeListNodeText(treeListNode, form.Column);
                    ProcessTreeValidity(treeList.Nodes);
                    treeList.EndUpdate();
                    Interfaces.Events.SetCursor(Cursors.Default);
                    return;
                }
            }
            else if (ModelTypes.MapColumn == type)
            {
                FormMapColumn form = new FormMapColumn((ScriptObject) treeListNode.Parent.Parent.Tag, (MapColumn) scriptBase);

                if (form.ShowDialog(ParentForm) == DialogResult.OK)
                {
                    Interfaces.Events.UnShadeMainForm();
                    Interfaces.Events.RaiseRefreshApplicationEvent();
                    Interfaces.Events.SetCursor(Cursors.WaitCursor);
                    treeList.BeginUpdate();

                    UpdateTreeListNodeText(treeListNode, form.MapColumn);
                    ProcessTreeValidity(treeList.Nodes);
                    treeList.EndUpdate();
                    Interfaces.Events.SetCursor(Cursors.Default);
                    return;
                }
            }
            else if (type.BaseType == typeof (Relationship))
            {
                FormRelationship form = new FormRelationship((Relationship) scriptBase, ProviderInfo.TheBllDatabase.AllScriptObjects);

                if (form.ShowDialog(ParentForm) == DialogResult.OK)
                {
                    Interfaces.Events.UnShadeMainForm();
                    Interfaces.Events.RaiseRefreshApplicationEvent();
                    Interfaces.Events.SetCursor(Cursors.WaitCursor);
                    treeList.BeginUpdate();
                    UpdateTreeListNodeText(treeListNode, form.PrimaryRelationship);
                    ProcessTreeValidity(treeList.Nodes);
                    treeList.EndUpdate();
                    Interfaces.Events.SetCursor(Cursors.Default);
                    return;
                }
            }
            else if (type == typeof (Filter))
            {
                Model.Database database = (Model.Database) treeListNode.Parent.Parent.Parent.Parent.Tag;
                Filter filter = (Filter) scriptBase;

                FormFilter2 form;
                // Stored Procedure Filters can only be created from other Stored Procedures (Enabled or Disabled)
                if (filter.Parent.GetType() == typeof (StoredProcedure))
                {
                    form = new FormFilter2(ParentForm, filter);
                }
                else
                {
                    form = new FormFilter2(ParentForm, filter);
                }
                if (form.ShowDialog(ParentForm) == DialogResult.OK)
                {
                    Interfaces.Events.UnShadeMainForm();
                    Interfaces.Events.RaiseRefreshApplicationEvent();
                    Interfaces.Events.SetCursor(Cursors.WaitCursor);
                    treeList.BeginUpdate();
                    UpdateTreeListNodeText(treeListNode, form.TheFilter);
                    ProcessTreeValidity(treeList.Nodes);
                    treeList.EndUpdate();
                    Interfaces.Events.SetCursor(Cursors.Default);
                    return;
                }
            }
            else if (type == typeof (Index))
            {
                FormIndex form = new FormIndex((Index) scriptBase);

                if (form.ShowDialog(ParentForm) == DialogResult.OK)
                {
                    Interfaces.Events.UnShadeMainForm();
                    Interfaces.Events.RaiseRefreshApplicationEvent();
                    Interfaces.Events.SetCursor(Cursors.WaitCursor);
                    treeList.BeginUpdate();
                    UpdateTreeListNodeText(treeListNode, form.Index);
                    ProcessTreeValidity(treeList.Nodes);
                    treeList.EndUpdate();
                    Interfaces.Events.SetCursor(Cursors.Default);
                    return;
                }
            }
            else if (type == typeof (Key))
            {
                FormKey form = new FormKey((Key) scriptBase);

                if (form.ShowDialog(ParentForm) == DialogResult.OK)
                {
                    Interfaces.Events.UnShadeMainForm();
                    Interfaces.Events.RaiseRefreshApplicationEvent();
                    Interfaces.Events.SetCursor(Cursors.WaitCursor);
                    treeList.BeginUpdate();
                    UpdateTreeListNodeText(treeListNode, form.Key);
                    ProcessTreeValidity(treeList.Nodes);
                    treeList.EndUpdate();
                    Interfaces.Events.SetCursor(Cursors.Default);
                    return;
                }
            }
        }
示例#3
0
        private void toolStripMenuItemTreeViewAddMapColumn_Click(object sender, EventArgs e)
        {
            treeList.BeginUpdate();

            TreeListNode treeListNode = treeList.FocusedNode;

            ScriptObject parent = (ScriptObject)treeListNode.ParentNode.Tag;
            FormMapColumn form = new FormMapColumn(parent);

            if (form.ShowDialog(this.ParentForm) == DialogResult.OK)
            {
                parent.AddColumn(form.MapColumn);

                TreeListNode newTreeListNode = treeList.AppendNode(GetTreeListNodeText(form.MapColumn), treeListNode);
                newTreeListNode.Tag = form.MapColumn;

                treeListNode.Tag = parent.Columns;

                //TreeListHelper.TreeListNodeValidate(treeListNode.ParentNode);
                ValidateNode(treeListNode.ParentNode);
            }
            treeList.EndUpdate();
        }
示例#4
0
        private void toolStripMenuItemTreeViewAddMapColumn_Click(object sender, EventArgs e)
        {
            treeList.BeginUpdate();

            Node treeListNode = treeList.SelectedNode;

            ScriptObject parent = (ScriptObject) treeListNode.Parent.Tag;
            FormMapColumn form = new FormMapColumn(parent);

            if (form.ShowDialog(ParentForm) == DialogResult.OK)
            {
                parent.AddColumn(form.MapColumn);
                Node newTreeListNode = AddNode(treeListNode, "", form.MapColumn, Images.GreenBullet, true,
                                                                     form.MapColumn.Enabled);
                treeListNode.Tag = parent.Columns;

                GetTreeListNodeText(form.MapColumn, newTreeListNode);
                ValidateNode(treeListNode.Parent);
            }
            treeList.EndUpdate();
        }