Example #1
0
 public void CreateLayerWindowToolBar(Gtk.Toolbar toolbar)
 {
     toolbar.AppendItem(AddNewLayer.CreateToolBarItem());
     toolbar.AppendItem(DeleteLayer.CreateToolBarItem());
     toolbar.AppendItem(DuplicateLayer.CreateToolBarItem());
     toolbar.AppendItem(MergeLayerDown.CreateToolBarItem());
     toolbar.AppendItem(MoveLayerUp.CreateToolBarItem());
     toolbar.AppendItem(MoveLayerDown.CreateToolBarItem());
     toolbar.AppendItem(Properties.CreateToolBarItem());
 }
        /// <summary>
        /// control delete state
        /// </summary>
        /// <param name="codeI"></param>
        /// <returns></returns>
        private bool CheckAfterDelete(int codeI)
        {
            DeleteLayer dictDelegat = new DeleteLayer(_layer.Delete);
            bool        result      = dictDelegat(codeI);

            if (!result)
            {
                MessageShow.ShowError(DelMess);
            }
            return(result);
        }
Example #3
0
 public void CreateMainMenu(Gtk.Menu menu)
 {
     menu.Append(AddNewLayer.CreateAcceleratedMenuItem(Gdk.Key.N, Gdk.ModifierType.ControlMask | Gdk.ModifierType.ShiftMask));
     menu.Append(DeleteLayer.CreateAcceleratedMenuItem(Gdk.Key.Delete, Gdk.ModifierType.ControlMask | Gdk.ModifierType.ShiftMask));
     menu.Append(DuplicateLayer.CreateAcceleratedMenuItem(Gdk.Key.D, Gdk.ModifierType.ControlMask | Gdk.ModifierType.ShiftMask));
     menu.Append(MergeLayerDown.CreateAcceleratedMenuItem(Gdk.Key.M, Gdk.ModifierType.ControlMask));
     menu.Append(ImportFromFile.CreateMenuItem());
     menu.AppendSeparator();
     menu.Append(FlipHorizontal.CreateMenuItem());
     menu.Append(FlipVertical.CreateMenuItem());
     menu.Append(RotateZoom.CreateMenuItem());
     menu.AppendSeparator();
     menu.Append(Properties.CreateAcceleratedMenuItem(Gdk.Key.F4, Gdk.ModifierType.None));
 }
Example #4
0
        public ActionResult DeleteLayer(DeleteLayer l, int InstanceID)
        {
            if (!ModelState.IsValid)
            {
                return(Json(new { error = Generic.GetValidationErrors(ModelState) }));
            }

            //confirm layer exists.
            var layer = db.Layers.DefaultIfEmpty(null).FirstOrDefault(x => x.LayerID == l.LayerID && x.InstanceID == l.InstanceID && x.Active);

            if (layer == null)
            {
                ModelState.AddModelError("Layer", "Layer does not exist.");
                return(Json(new { error = Generic.GetValidationErrors(ModelState) }));
            }

            //now count the layers.
            if (db.Layers.Where(x => x.InstanceID == l.InstanceID && x.Active && x.LayerID != layer.LayerID).Count() < 1)
            {
                ModelState.AddModelError("Layer", "There must always be at least one layer.");
                return(Json(new { error = Generic.GetValidationErrors(ModelState) }));
            }

            //disable this layer.
            layer.deleteLayer();
            db.SaveChanges();
            //find the new target layer's ID.
            var targetLayerID = db.Layers.First(x => x.Active && x.InstanceID == l.InstanceID && x.LayerID != l.LayerID).LayerID;

            //find all layer links.
            var layerLinks = db.LayerLinks.Where(x => x.LayerID == l.LayerID).ToList();

            foreach (var n in layerLinks)
            {
                if (!db.LayerLinks.Any(x => x.NodeID == n.NodeID && x.LayerLinkID != n.LayerLinkID))
                {
                    //copy node to new layer.
                    db.LayerLinks.Add(new LayerLink(new CreateLayerLink {
                        NodeID = n.NodeID, LayerID = targetLayerID
                    }));
                }
                n.RemoveLayerLink();
            }
            db.SaveChanges();
            return(Json(new { layer = new JsonLayer(layer) }));
        }
        public InternalLayerDisplay(DeleteLayer deleteLayer, int position, int length) : base()
        {
            InitializeComponent();
            this.deleteLayer = deleteLayer;
            this.Position    = position;
            this.LayerLength = length;
            Button deleteLayerButton = new Button()
            {
                Content             = "X",
                VerticalAlignment   = VerticalAlignment.Bottom,
                HorizontalAlignment = HorizontalAlignment.Center
            };

            deleteLayerButton.Click += DeleteLayerButton_Click;
            DockPanel.SetDock(deleteLayerButton, Dock.Bottom);
            Children.Remove(EllipseContainer);
            Children.Add(deleteLayerButton);
            Children.Add(EllipseContainer);
        }
Example #6
0
        public void RegisterActions(Gtk.Application app, GLib.Menu menu)
        {
            app.AddAccelAction(AddNewLayer, "<Primary><Shift>N");
            menu.AppendItem(AddNewLayer.CreateMenuItem());

            app.AddAccelAction(DeleteLayer, "<Primary><Shift>Delete");
            menu.AppendItem(DeleteLayer.CreateMenuItem());

            app.AddAccelAction(DuplicateLayer, "<Primary><Shift>D");
            menu.AppendItem(DuplicateLayer.CreateMenuItem());

            app.AddAccelAction(MergeLayerDown, "<Primary>M");
            menu.AppendItem(MergeLayerDown.CreateMenuItem());

            app.AddAction(ImportFromFile);
            menu.AppendItem(ImportFromFile.CreateMenuItem());

            var flip_section = new GLib.Menu();

            menu.AppendSection(null, flip_section);

            app.AddAction(FlipHorizontal);
            flip_section.AppendItem(FlipHorizontal.CreateMenuItem());

            app.AddAction(FlipVertical);
            flip_section.AppendItem(FlipVertical.CreateMenuItem());

            app.AddAction(RotateZoom);
            flip_section.AppendItem(RotateZoom.CreateMenuItem());

            var prop_section = new GLib.Menu();

            menu.AppendSection(null, prop_section);

            app.AddAccelAction(Properties, "F4");
            prop_section.AppendItem(Properties.CreateMenuItem());

            app.AddAction(MoveLayerDown);
            app.AddAction(MoveLayerUp);
        }