/*
         *
         */
        //ResizePanel
        public void ResizePanel(VPPanel panel, Size new_size)
        {
            Size old_size = panel.Size;

            panel.Size = new_size;
            foreach (string slave in panel.Rules.Keys)
            {
                foreach (Rule rule in panel.Rules[slave])
                {
                    if (rule.Trigger == typeof(Size))
                    {
                        string visual_part = ConvertToPosition(slave).First();
                        string view        = ConvertToPosition(slave).Last();
                        Dictionary <object, object> args = new Dictionary <object, object>()
                        {
                            {
                                "slave",
                                (pieces.Keys.Contains(visual_part)) ?
                                pieces[visual_part].Item1.GetPanel(view) :
                                GetPanel(slave)
                            },
                            { "master_sizes", new Tuple <Size, Size>(old_size, new_size) }
                        };
                        rule.Execute(args);
                    }
                }
            }
        }
        /*
         *
         */
        //GetPanel
        public VPPanel GetPanel(string name)
        {
            List <string> position = ConvertToPosition(name);

            Control[] subcontainers;
            if (position.Count() == 1 && views.ContainsKey(position[0]))
            {
                subcontainers = new VPPanel[1]
                {
                    views[position[0]]
                };
            }
            else if (position.Count() > 1 && views.ContainsKey(position[0]))
            {
                subcontainers = views[position[0]].Controls.Find(name, true);
            }
            else
            {
                subcontainers = new VPPanel[0];
            }
            if (subcontainers.Count() == 1)
            {
                return((VPPanel)subcontainers[0]);
            }
            else
            {
                throw new Exception("Could not find consistent control at specified position");
            }
        }
        /*
         * views_names : keys = views from added visualPart, values = positions in the current visualPart
         * locations : keys = views from added visualPart, values = locations in the current visualPart
         *
         * create a new panel in current visualPart for each concerned view (path = position + name)
         */
        //AddVisualPart
        public void AddVisualPart(string name, VisualPart visual_part, Dictionary <string, string> views_names, Dictionary <string, Point> locations)
        {
            visual_part.ChangeScaling(scaling);
            pieces.Add(name, new Tuple <VisualPart, HashSet <string> >(visual_part, new HashSet <string>()));
            foreach (string view in views_names.Keys)
            {
                List <string> position = ConvertToPosition(views_names[view]);
                position.Add(name);
                string  view_container = ConvertToName(position);
                VPPanel container      = AddPanel(view_container, locations[view], visual_part.Views[view].Mm_size);

                //container.BorderStyle = BorderStyle.FixedSingle;//MODIF wtf apparence bizarre?

                pieces[name].Item2.Add(view_container);
                container.Controls.Add(visual_part.Views[view]);
                OrderedDictionary size = new OrderedDictionary()
                {
                    { "slave", null },
                    { "master_sizes", null },
                    { "axis_dependency", new Tuple <bool, bool>(true, true) },
                    { "axis_inversion", false }
                };
                Action <VPPanel, Tuple <Size, Size>, Tuple <bool, bool>, bool> SizCopySizeChangeRule = visual_part.CopySizeChangeRule;
                AddRule(container.Name, string.Concat(view, "_" + name), SizCopySizeChangeRule, size, typeof(Size));
                //MODIF desactive peut etre l'opportunite de cliquer sur l'etage, a verifier
            }
        }
Beispiel #4
0
 //SizeDependentPositionRule
 /// <summary>
 /// The rule which change the position if the size is changed
 /// </summary>
 /// <param name="slave"></param>
 /// <param name="master_sizes"></param>
 /// <param name="axis_dependency"></param>
 /// <param name="axis_inversion"></param>
 public void SizeDependentPositionRule(VPPanel slave, Tuple<Size, Size> master_sizes, 
     Tuple<bool, bool> axis_dependency, bool axis_inversion)
 {
     double sx = slave.Size.Width;
     double sy = slave.Size.Height;
     double lx = slave.Location.X + sx / 2;
     double ly = slave.Location.Y + sy / 2;
     double x = (master_sizes.Item2.Width / master_sizes.Item1.Width);
     double y = (master_sizes.Item2.Height / master_sizes.Item1.Height);
     if(axis_dependency.Item1)
     {
         if(axis_inversion)
         {
             ly = ly * x;
         }
         else
         {
             lx = lx * x;
         }
     }
     if(axis_dependency.Item2)
     {
         if(axis_inversion)
         {
             lx = lx * y;
         }
         else
         {
             ly = ly * y;
         }
     }
     lx = lx - sx / 2;
     ly = ly - sy / 2;
     RelocatePanel(slave, new Point(Convert.ToInt32(lx), Convert.ToInt32(ly)));
 }
Beispiel #5
0
        //AddPanel
        /// <summary>
        /// Add a VPPanel in the VisualPart
        /// </summary>
        /// <param name="name">the name(exclusive) of the VPPanel to be added</param>
        /// <param name="location"> the location of the VPPanel in the VisualPart (unit of measurement) </param>
        /// <param name="size"> The size of the VPPanel to be added (unit of measurement) </param>
        /// <param name="color"> The color of the VPPanel to be added </param>
        /// <param name="is_elliptic"> Specify if the VPPanel is elliptic (true) or rectangular (false) </param>
        /// <returns></returns>
        public VPPanel AddPanel(string name, Point location, Size size, Color? color = null, bool is_elliptic = false)
        {
            List<string> position = ConvertToPosition(name);
            VPPanel subcontainer;
            if (HasSubcontainer(position))
            {
                if (position.Count() > 1)
                {
                    subcontainer = GetPanel(ConvertToName(position.Take(position.Count() - 1).ToList()));
                }
                else if (position.Count() == 1)
                {
                    subcontainer = null;
                }
                else
                { throw new Exception("Specify a nonempty position"); }

                positions = AddPosition(positions, position);

                VPPanel new_panel = new VPPanel();

                bool mouseHover = true;
                if (color == null)
                {
                    color = SystemColors.Control;
                    mouseHover = false;
                }

                if(subcontainer != null)
                {
                    subcontainer.Controls.Add(new_panel);
                    new_panel.Click += new EventHandler(Click);
                    if (mouseHover)
                    {
                        new_panel.MouseHover += new EventHandler(MouseHover);
                    }
                }
                else
                {
                    views[name] = new_panel;
                    ChangeConstrainingSize();
                }
                new_panel.BackColor = (Color)color;
                new_panel.Mm_location = location;
                new_panel.Location = ScalePoint(location, scaling);
                new_panel.Name = name;
                new_panel.Mm_size = size;
                new_panel.Size = ScaleSize(size, scaling);
                if(is_elliptic)
                {
                    new_panel.Shape = new EventHandler(new_panel.ShapeElliptic);
                }
                references.Add(new_panel.Name);
                return new_panel;
            }
            else { throw new Exception("The specified position does not contain a subcontainer in this VisualPart"); }
        }
Beispiel #6
0
 /*
  * //MODIF on peut certainement modifier tous les ADDRULES pour qu'ils dépendent d'un code à paramètres (pcq la c'est du recopiage)
  */
 //AddRule
 /// <summary>
 /// Add a Rule to a VPPanel, in short : when a dimension of a master VPPanel change, all of its slave must apply the related
 /// Rule. NONFONCTIONNAL
 /// </summary>
 /// <param name="ref_master"></param>
 /// <param name="ref_slave"></param>
 /// <param name="action"></param>
 /// <param name="args"></param>
 /// <param name="Ttrigger"></param>
 public void AddRule(string ref_master, string ref_slave, Delegate action, OrderedDictionary args, Type Ttrigger)
 {
     Type Ttarget = typeof(VPPanel);
     VPPanel master = GetPanel(ref_master);
     if(!master.Rules.ContainsKey(ref_slave))
     {
         master.Rules[ref_slave] = new List<Rule>();
     }
     master.Rules[ref_slave].Add(new Rule(action, args, Ttrigger, Ttarget));
 }
Beispiel #7
0
 //NoOverLappingRule : size changed
 /// <summary>
 /// The rule which relocate a slave if the master is resized
 /// </summary>
 /// <param name="slave"></param>
 /// <param name="master_sizes"></param>
 /// <param name="axis_dependency"></param>
 /// <param name="axis_inversion"></param>
 public void NoOverlappingRule(VPPanel slave, Tuple<Size, Size> master_sizes, 
     Tuple<bool, bool> axis_dependency, bool axis_inversion)
 {
     int dsx = Convert.ToInt32(axis_dependency.Item1) * (master_sizes.Item2.Width - master_sizes.Item1.Width);
     int dsy = Convert.ToInt32(axis_dependency.Item2) * (master_sizes.Item2.Height - master_sizes.Item1.Height);
     RelocatePanel(
         slave,
         new Point(
             slave.Location.X + (axis_inversion ? dsy : dsx),
             slave.Location.Y + (axis_inversion ? dsx : dsy)));
 }
Beispiel #8
0
 /*
  * master_locations : old, new
  * axis_dependency : x, y : refering to the master
  */
 //NoOverlappingRule : location changed
 /// <summary>
 /// The rule which relocate a slave if the master is relocated
 /// </summary>
 /// <param name="slave"></param>
 /// <param name="master_locations"></param>
 /// <param name="axis_dependency"></param>
 /// <param name="axis_inversion"></param>
 public void NoOverlappingRule(VPPanel slave, Tuple<Point, Point> master_locations, 
     Tuple<bool, bool> axis_dependency, bool axis_inversion)
 {
     int dlx = Convert.ToInt32(axis_dependency.Item1) * (master_locations.Item2.X - master_locations.Item1.X);
     int dly = Convert.ToInt32(axis_dependency.Item2) * (master_locations.Item2.Y - master_locations.Item1.Y);
     RelocatePanel(
         slave,
         new Point(
             slave.Location.X + (axis_inversion ? dly : dlx),
             slave.Location.Y + (axis_inversion ? dlx : dly)));
 }
Beispiel #9
0
 /*
  *
  */
 //CopySizeProportionRule
 /// <summary>
 /// The rule which change the size of a slave if the master size is modified (proportions)
 /// </summary>
 /// <param name="slave"></param>
 /// <param name="master_sizes"></param>
 /// <param name="axis_dependency"></param>
 /// <param name="axis_inversion"></param>
 public void CopySizeProportionRule(VPPanel slave, Tuple<Size, Size> master_sizes,
     Tuple<bool, bool> axis_dependency, bool axis_inversion)
 {
     double cx = Convert.ToInt32(axis_dependency.Item1) * (master_sizes.Item2.Width / master_sizes.Item1.Width);
     double cy = Convert.ToInt32(axis_dependency.Item2) * (master_sizes.Item2.Height / master_sizes.Item1.Height);
     ResizePanel(
         slave,
         new Size(
             Convert.ToInt32(slave.Size.Width * (axis_inversion ? cy : cx)),
             Convert.ToInt32(slave.Size.Height * (axis_inversion ? cx : cy))));
 }
Beispiel #10
0
 //CopySizeChangeRule
 /// <summary>
 /// The rule which change the size of a slave if the size of the master is modified
 /// </summary>
 /// <param name="slave"></param>
 /// <param name="master_sizes"></param>
 /// <param name="axis_dependency"></param>
 /// <param name="axis_inversion"></param>
 public void CopySizeChangeRule(VPPanel slave, Tuple<Size, Size> master_sizes,
     Tuple<bool, bool> axis_dependency, bool axis_inversion)
 {
     int dx = Convert.ToInt32(axis_dependency.Item1) * (master_sizes.Item2.Width - master_sizes.Item1.Width);
     int dy = Convert.ToInt32(axis_dependency.Item2) * (master_sizes.Item2.Height - master_sizes.Item1.Height);
     ResizePanel(
         slave,
         new Size(
             slave.Size.Width + (axis_inversion ? dy : dx),
             slave.Size.Height + (axis_inversion ? dx : dy)));
 }
Beispiel #11
0
 //RemovePanel
 /// <summary>
 /// Remove the VPPanel with the name
 /// </summary>
 /// <param name="name"></param>
 public void RemovePanel(string name)
 {
     List<string> position = ConvertToPosition(name);
     List<string> container_position = position.Take(position.Count() - 1).ToList();
     VPPanel container = GetPanel(ConvertToName(container_position));
     container.Controls.RemoveByKey(name);
     references.Remove(name);
     if (position.Count() == 1)
     {
         views.Remove(name);
     }
     positions = RemovePosition(positions, position);
 }
Beispiel #12
0
 //ReinsertPiece
 /// <summary>
 /// When a piece is displayed in a screen, the related controls are removed from the VisualPart that contained the piece
 /// This method adds the said removed controls in the right place anew
 /// </summary>
 /// <param name="name">the name of the piece that had been displayed</param>
 public void ReinsertPiece(string name)
 {
     VisualPart piece = Pieces[name].Item1;
     foreach(string container in Pieces[name].Item2.Keys)
     {
         VPPanel master = GetPanel(container);
         VPPanel slave = piece.GetPanel(Pieces[name].Item2[container]);
         if(!master.Controls.Contains(slave))
         {
             master.Controls.Add(slave);
         }
     }
 }
 /*
  *
  */
 //ChangeScaling : scaling
 public void ChangeScaling(double scaling)
 {
     foreach (string reference in references)
     {
         VPPanel current = GetPanel(reference);
         current.Location = ScalePoint(current.Mm_location, scaling);
         current.Size     = ScaleSize(current.Mm_size, scaling);
     }
     foreach (string visual_part in pieces.Keys)
     {
         VisualPart piece = pieces[visual_part].Item1;
         piece.ChangeScaling(scaling);
     }
 }
Beispiel #14
0
 //CreateViews
 /// <summary>
 /// Construct as many VPPanel as the number of elements in mm_sizes, with the related dimensions
 /// </summary>
 /// <param name="mm_sizes">The sizes of the views (keys are the views names) (unit of measurement)</param>
 private void CreateViews(Dictionary<string, Size> mm_sizes)
 {
     this.views = new Dictionary<string, VPPanel>();
     List<string> list_views = mm_sizes.Keys.ToList();
     for (int i = 0; i < list_views.Count(); i++)
     {
         VPPanel new_panel = new VPPanel();
         new_panel.BackColor = SystemColors.Control;
         new_panel.Location = new Point(0, 0);
         new_panel.Mm_location = new Point(0, 0);
         new_panel.Name = list_views[i];
         new_panel.Size = mm_sizes[list_views[i]];
         new_panel.Mm_size = mm_sizes[list_views[i]];
         views[list_views[i]] = new_panel;
         positions[list_views[i]] = null;
         references.Add(list_views[i]);
     }
 }
Beispiel #15
0
 //SelectPiece
 /// <summary>
 /// This method can be used to select a Component of the VisualPart, the colors will be adapted to
 /// have a better visualization of the selection, the selected Component will have its name stored in Pointer
 /// </summary>
 /// <param name="sender"></param>
 public void SelectPiece(object sender)
 {
     if(!typeof(VPPanel).IsInstanceOfType(sender))
     {
         return;
     }
     VPPanel current_sender = (VPPanel)sender;
     string piece_name = ConvertToPosition(current_sender.Name).Last();
     if(pieces.Keys.Contains(piece_name))
     {
         UndoFocus();
         pointer = current_sender.Name;
         Focus(current_sender);
         SearchScreen(sender);
     }
     else
     {
         SelectPiece(current_sender.Parent);
     }
 }
Beispiel #16
0
 //RelocatePanel
 /// <summary>
 /// Relocate a VPPanel
 /// </summary>
 /// <param name="panel"></param>
 /// <param name="new_location"></param>
 public void RelocatePanel(VPPanel panel, Point new_location)
 {
     Point old_location = panel.Location;
     panel.Location = new_location;
     foreach (string slave in panel.Rules.Keys)
     {
         foreach (Rule rule in panel.Rules[slave])
         {
             if (rule.Trigger == typeof(Point))
             {
                 Dictionary<object, object> args = new Dictionary<object, object>()
                 {
                     { "slave", GetPanel(slave) },
                     { "master_locations", new Tuple<Point, Point>(old_location, new_location) }
                 };
                 rule.Execute(args);
             }
         }
     }
 }