Esempio n. 1
0
 private static void GenerateLayoutLevel(IShapeContainer container, GridLayout layout, Transaction transaction)
 {
     foreach (var sub in layout.Contents)
     {
         var item = new Item
         {
             ItemType  = sub.Type,
             StyleType = Item.DefaultItemDisplayTypeForType(sub.Type),
             LineStyle = { Colour = Color.Black },
             FillStyle = { Colour = Color.LightGray },
             LabelText = ""
         };
         item.SetBounds(sub.Bounds);
         var scriptable = new Scriptable(item);
         container.Contents.Add(scriptable);
         scriptable.Parent = container;
         transaction.Create(item);
         transaction.Create(scriptable);
         scriptable.SelectScript = new Script();
         if (sub.Contents != null)
         {
             scriptable.SelectScript.Visit.VisitType = Script.VisitTarget.VisitTypes.Down;
             GenerateLayoutLevel(item, sub, transaction);
         }
         else
         {
             scriptable.SelectScript.Visit.VisitType = Script.VisitTarget.VisitTypes.Up;
         }
     }
     container.FinishedModifyingContents(transaction);
 }
Esempio n. 2
0
 public void CopyPresentationFrom(Scriptable item, bool noOverwriteExisting)
 {         // see Item
     if (HighlightStyle == null)
     {
         HighlightStyle = new HighlightStyleC();
     }
     HighlightStyle.CopyFrom(item.HighlightStyle);
     if (!noOverwriteExisting || Sound == null)
     {
         Sound = item.Sound?.Clone();
     }
     if (!noOverwriteExisting || string.IsNullOrEmpty(OutputText))
     {
         OutputText = item.OutputText;
     }
     OutputAsDisplay = item.OutputAsDisplay;
     if (!noOverwriteExisting || string.IsNullOrEmpty(SpeechText))
     {
         SpeechText = item.SpeechText;
     }
     SpeechAsDisplay = item.SpeechAsDisplay;
     if (!noOverwriteExisting || string.IsNullOrEmpty(PromptText))
     {
         PromptText = item.PromptText;
     }
 }
Esempio n. 3
0
        protected override bool IdenticalToShape(Shape other)
        {
            if (!base.IdenticalToShape(other))
            {
                return(false);
            }
            if (!Element.IdenticalTo(other))
            {
                return(false);
            }
            Scriptable scriptable = (Scriptable)other;

            if (Popup != scriptable.Popup || Shown != scriptable.Shown)
            {
                return(false);
            }
            for (int i = 0; i < Scripts.Length; i++)
            {
                if (Scripts[i] != null && scriptable.Scripts[i] != null && !Scripts[i].IdenticalTo(scriptable.Scripts[i]))
                {
                    return(false);
                }
            }
            return(true);
        }
Esempio n. 4
0
 /// <summary>Display the given scriptable object for editing. Use isDefault when editing one of the set defaults</summary>
 public void Edit(Scriptable item, bool isDefault = false)
 {
     m_Scriptable       = item;
     chkRepeats.Visible = !isDefault;
     m_IsDefault        = isDefault;
     FillUI();
 }
Esempio n. 5
0
 /// <summary>Use overloaded version (Scriptable, which) normally.  This version is intended for the default scripts, and will not support calling thru to default</summary>
 public void Edit(Script script, Page page)
 {
     m_Scriptable    = null;
     m_Script        = script;
     m_Page          = page;
     m_DefaultScript = null;
     FillUI();
 }
Esempio n. 6
0
 /// <summary>Display the given script for editing.</summary>
 public void Edit(Scriptable scriptable, int which)
 {
     m_Scriptable    = scriptable;
     m_Script        = scriptable.Scripts[which];
     m_Page          = scriptable.FindPage();
     m_DefaultScript = m_Scriptable.GetDefaultScript((Scriptable.ScriptTypes)which, Globals.Root.CurrentDocument);
     FillUI();
 }
Esempio n. 7
0
 private void StopCustomRepeat()
 {
     if (m_RepeatItem != null)             // just in case.  Both protects vs null and from running it twice
     {
         InvokeScript(m_RepeatItem, Scriptable.ScriptTypes.PostRepeat, true, m_RepeatItem);
     }
     m_RepeatItem          = null;
     m_RepeatTimer.Enabled = false;
 }
Esempio n. 8
0
 public ExecutionContext(Scriptable target, RunView view, Page page, Document doc, Switches.Engine scanEngine, Scriptable.ScriptTypes scriptType)
 {
     TargetItem = target;
     View       = view;
     Page       = page;
     Document   = doc;
     ScanEngine = scanEngine;
     ScriptType = scriptType;
 }
Esempio n. 9
0
 /// <summary>Causes the given command to capture all further scan output until StopContinuous</summary>
 public void StartContinuous(IContinuousCommand command)
 {
     if (m_Continuous == command)
     {
         return;                 // so it doesn't have stop called
     }
     m_Continuous?.Stop();
     m_Continuous = command;
     m_RepeatItem = null;
 }
Esempio n. 10
0
        /// <summary>Run one of the scripts on the item.  If noVisit then the VisitItem is not used (but explicit Visit scripts would still run)
        /// The item which acts as the context can be provided, but is the Current/selected item normally (NOT the item on which the script is invoked - exec commands still
        /// run in the context of the pressed button)</summary>
        public void InvokeScript(Scriptable item, Scriptable.ScriptTypes which, bool noVisit = false, Scriptable contextItem = null)
        {
            //Debug.WriteLine("Invoke script " + which + " on " + item.Description);
            Script script = item.GetScript(which);

            if (contextItem == null)
            {
                contextItem = m_Current;
            }
            // find defaults first, if needed (unlike SAW6 this is possible even if there are genuine scripts)
            Script def = null;

            if (script?.RunDefault ?? true)             // if object missing entirely(?!?) default is used
            {
                def = item.GetDefaultScript(which, m_Document);
            }
            Scriptable originalCurrent = m_Current;            // used below to detect if a custom visit script changed the selection

            Command.ExecutionContext context = new Command.ExecutionContext(contextItem, this, m_Page, m_Document, m_Engine, which);
            if (def != null)
            {
                InvokeScriptCommands(def, context);
            }
            if ((script?.CommandList?.Count ?? 0) != 0)             // either null object, or no commands (only latter possible?) either counts the same
            {
                InvokeScriptCommands(script, context);
            }

            if (noVisit || context.Terminate)
            {
                return;
            }
            // however the default visit is done after any custom commands
            Scriptable target = null;

            if (script != null)
            {
                target = ResolveVisitTarget(script.Visit, contextItem); // 8.0.4 changed to context from Item -
            }
            if (target == null && def != null)                          // default is only used if self is set to None:
            {
                target = ResolveVisitTarget(def.Visit, contextItem);
            }
            if (target == null && which == Scriptable.ScriptTypes.Next && originalCurrent == m_Current)
            {
                target = item;                 // a Next script which references nothing useful should re-select the same item // but only if a custom script didn't make a selection
            }
            if (target != null)
            {
                SelectItem(target, false);
            }
        }
Esempio n. 11
0
 private void m_Engine_EndSelect()
 {
     // switch which was repeat selecting released.  Ensure no repeats (although trigger shouldn't be called anyway!)
     if (m_RepeatItem?.HasRepeatingScript ?? false)
     {            // custom repeating scripts, this would usually stop
                  // but first check if this actually ends, or if they are in the alternate mode:
         if (CurrentConfig.ReadBoolean(Config.Repeat_PressStop))
         {
             return;                     // this doesn't actually stop until clicked again.  The switch up does nothing
         }
         StopCustomRepeat();
     }
     else
     {
         m_RepeatItem = null;
     }
 }
Esempio n. 12
0
 /// <summary>Highlights the item, calling the Visit script.  directSelect=true IFF this is a request from the mouse input</summary>
 public void SelectItem(Scriptable item, bool directSelect)
 {
     if (m_MouseInput && !directSelect)
     {
         return;                 // ignore all other changes when using mouse input
     }
     Debug.Assert(item == null || !item.NotVisited);
     if (m_Current != null && directSelect)             // these may be unnecessary now with above?
     {
         // can't clear m_Current before call (would help avoid infinite loops) since m_Current is always the execution context
         InvokeScript(m_Current, Scriptable.ScriptTypes.Next, true);
         // SAW was changed to include the next script in direct selection modes
         // originally it only did manual deselection
         // and it still manually unhighlights
     }
     m_Current = item;             // must be before script - which might re-assign it
     if (item != null)
     {
         InvokeScript(item, Scriptable.ScriptTypes.Visit);
     }
 }
Esempio n. 13
0
        /// <summary>Returns the item which is referenced by the visit object, or null if nothing found (which usually has same effect as "Me")</summary>
        public Scriptable ResolveVisitTarget(Script.VisitTarget visit, Scriptable source)
        {
            //Debug.WriteLine("Resolve: " + visit.GetDescription() + " from " + (source?.SAWID.ToString() ?? "null"));
            List <Scriptable> items;

            if (source != null)
            {
                items = (source.Parent as IShapeContainer).Contents.OfType <Scriptable>().Where(i => i.Shown && !i.NotVisited).ToList();
            }
            else
            {
                items = new List <Scriptable>();
            }
            int currentIndex = items.IndexOf(source);

            switch (visit.VisitType)
            {
            case Script.VisitTarget.VisitTypes.None:
                return(null);

            case Script.VisitTarget.VisitTypes.Me:
                return(source);

            case Script.VisitTarget.VisitTypes.First:
                return(items.FirstOrDefault());

            case Script.VisitTarget.VisitTypes.Last:
                return(items.LastOrDefault());

            case Script.VisitTarget.VisitTypes.Previous:
                Debug.Assert(currentIndex >= 0);
                currentIndex -= 1;
                if (currentIndex < 0)
                {
                    currentIndex = items.Count - 1;
                }
                return(items[currentIndex]);

            case Script.VisitTarget.VisitTypes.Next:
                Debug.Assert(currentIndex >= 0);
                currentIndex += 1;
                if (currentIndex >= items.Count)
                {
                    currentIndex = 0;
                }
                return(items[currentIndex]);

            case Script.VisitTarget.VisitTypes.Down:
                return(((source.Element as IShapeContainer)?.Contents.OfType <Scriptable>()).FirstOrDefault(i => i.Shown && !i.NotVisited));

            case Script.VisitTarget.VisitTypes.Up:
                return((source.Parent as Shape)?.Parent as Scriptable);                        // will return null if not within an element within a Scriptable

            case Script.VisitTarget.VisitTypes.Item:
                return(m_Page.FindScriptableByID(visit.ItemID));

            default:
                OnError("Unknown visit type: " + visit.VisitType);
                return(null);
            }
        }
Esempio n. 14
0
        private void m_Engine_Trigger(bool isRepeat)
        {
            if (m_frmReport != null)
            {
                m_frmReport.SwitchActivated();
                return;
            }
            if (m_RepeatItem?.HasRepeatingScript ?? false)
            {             // currently doing custom repeats scripts
                if (CurrentConfig.ReadBoolean(Config.Repeat_PressStop) && !isRepeat)
                {
                    StopCustomRepeat();
                }
                // either way no further action is taken on this - the separate timer activates this
                return;
            }
            if (m_Continuous != null)
            {             // a command has captured the output to make a selection
                if (!m_Continuous.Trigger(isRepeat))
                {
                    m_Continuous?.Stop();                     // ? needed in case the command removed itself already
                    m_Continuous = null;
                }
                return;
            }
            var item = isRepeat ? m_RepeatItem : m_Current;

            if (item == null)             // usually this will be because repeating is not enabled on the last item, but also covers the case where nothing was selected for a genuine switch activation
            {
                return;
            }
            if (CurrentConfig.ReadBoolean(Config.Use_Swap_Switch))
            {
                LogicalSwapper.Swap = !LogicalSwapper.Swap && !item.ResetSwap;
            }
            // if item has ResetSwap then the state is forced to false
            // when repeating we explicitly use the remembered item -it may have selected something else as "current"
            //Debug.WriteLine("Trigger");
            var current = m_Current;

            if (isRepeat && item.HasRepeatingScript)
            {
                InvokeScript(item, Scriptable.ScriptTypes.Repeat, true, item);
            }
            else
            {
                InvokeScript(m_Current, Scriptable.ScriptTypes.Select);
            }
            if (!isRepeat)                                                                            // for first activation, set up repeating if needed.
            {                                                                                         // if item is not AutoRepeat, failing to set this will ensure the repeat triggers are ignored
                if (current.HasRepeatingScript)
                {                                                                                     // start up the timer for custom repeat scripts
                    m_RepeatItem = current;
                    InvokeScript(m_RepeatItem, Scriptable.ScriptTypes.PreRepeat, true, m_RepeatItem); // this one fires immediately.
                    m_RepeatTimer.Interval = m_Engine.ConfiguredTiming(Switches.Engine.Timings.FirstRepeat);
                    m_RepeatTimer.Enabled  = true;
                }
                else if (current.AutoRepeat)
                {
                    m_RepeatItem = current;
                }
            }
        }
Esempio n. 15
0
 /// <summary>Changes the highlight state of the item.  Doesn't need to be the current one</summary>
 public void SetItemState(Scriptable item, ButtonShape.States state)
 {
     //Debug.WriteLine("SetItemState " + item.Description + " = " + state);
     item.State = state;
     m_Page.NotifyIndirectChange(item, ChangeAffects.RepaintNeeded, item.RefreshBounds());
 }
Esempio n. 16
0
        public override void CopyFrom(Datum other, CopyDepth depth, Mapping mapID)
        {
            // this is slightly flaky for Undo still, in that the scriptable must be put into the transaction FIRST
            // (otherwise it will refernce differing copies of the contained element)
            base.CopyFrom(other, depth, mapID);
            Scriptable scriptable = (Scriptable)other;

            if (depth > CopyDepth.Transform)
            {
                CopyPresentationFrom(scriptable, false);
            }
            //Debug.WriteLine("Scriptable.CopyFrom, depth=" + depth + " ID=" + scriptable.SAWID);
            // contained element.  Works like ShapeStack containment - Element is tightly bound within this
            if (depth == CopyDepth.Transform && Element != null)
            {
                // first time must copy reference, below
                if (Element != scriptable.Element)
                {
                    Element?.CopyFrom(scriptable.Element, depth, mapID);
                }
            }
            else            // if (depth == CopyDepth.Duplicate)
            {
                if (mapID?.ContainsKey(scriptable.Element.ID) ?? false)
                {
                    Element = (Shape)mapID[scriptable.Element.ID];
                }
                else
                {
                    Element = (Shape)scriptable.Element.Clone(mapID ?? new Mapping());                     // use actual mapID if there is one, otherwise need a real one as Container aspects of Item don't like Ignore
                }
                Element.Parent = this;
            }
            //else
            //{
            //	Element = scriptable.Element;
            //}

            ////else if (depth == CopyDepth.Duplicate)
            ////{
            ////	if (mapID == null)
            ////		mapID = Mapping.Ignore;
            ////	Element = (Shape)scriptable.Element.Clone(mapID);
            ////	Element.Parent = this;
            ////}
            //else
            //{
            //	// undo requires all shapes are copied, because they could later be edited by styling changes
            //	//Element = Shape.CreateShape(scriptable.Element.ShapeCode); // <- this is inadequate as it doesn't clone contents of the items which leaves some reference problems
            //	//Element.CopyFrom(scriptable.Element, depth, null);
            //	Element = (Shape)scriptable.Element.Clone(mapID ?? new Mapping()); // use actual mapID if there is one, otherwise need a real one as Container aspects of Item don't like Ignore
            //	Element.Parent = this;
            //}

            // other fields:
            if (depth > CopyDepth.Transform)
            {
                SAWID         = scriptable.SAWID;
                Popup         = scriptable.Popup;
                Shown         = scriptable.Shown;
                AutoRepeat    = scriptable.AutoRepeat;
                RepeatTimeout = scriptable.RepeatTimeout;
                for (int i = 0; i < Scripts.Length; i++)
                {
                    Scripts[i] = scriptable.Scripts[i]?.Clone();
                }
            }
            m_Bounds = RectangleF.Empty;             // because content may have moved - especially on Undo
        }