BioImager.Function Class Reference

Public Types
enum	FunctionType
enum	ButtonState

Public Member Functions
override string	ToString ()
string	Serialize ()
object	PerformFunction (bool imagej)
void	Save ()
	It saves all the functions in the Functions dictionary to a file. More...

Static Public Member Functions
static Function	Parse (string s)
static void	Initialize ()

Static Public Attributes
static Dictionary< string, Function >	Functions = new Dictionary<string, Function>()
static InputSimulator	input = new InputSimulator()

Properties
ButtonState	State [get, set]
VirtualKeyCode	Key [get, set]
VirtualKeyCode	Modifier [get, set]
FunctionType	FuncType [get, set]
string	File [get, set]
string	Script [get, set]
string	Name [get, set]
string	MenuPath [get, set]
string	ContextPath [get, set]
double	Value [get, set]

Detailed Description

Definition at line 397 of file FunctionForm.cs.

Member Enumeration Documentation

ButtonState

enum BioImager.Function.ButtonState

Definition at line 431 of file FunctionForm.cs.

        {
            Pressed,
            Released
        }

FunctionType

enum BioImager.Function.FunctionType

Definition at line 401 of file FunctionForm.cs.

        {
            Key,
            StageUp,
            StageRight,
            StageDown,
            StageLeft,
            FocusUp,
            FocusDown,
            StageFieldUp,
            StageFieldRight,
            StageFieldDown,
            StageFieldLeft,
            TakeImage,
            TakeImageStack,
            RL,
            TL,
            Objective,
            StoreCoordinate,
            NextCoordinate,
            PreviousCoordinate,
            NextSnapCoordinate,
            PreviousSnapCoordinate,
            Recording,
            Property,
            ImageJ,
            Script,
            None
        }

Member Function Documentation

Initialize()

static void BioImager.Function.Initialize ( )

static

It reads all the files in the Functions folder, parses them into Function objects, and adds them to the Functions dictionary

Definition at line 718 of file FunctionForm.cs.

        {
            string st = Application.StartupPath + "/Functions";
            if (!Directory.Exists(st))
                Directory.CreateDirectory(st);
            string[] sts = Directory.GetFiles(st);
            for (int i = 0; i < sts.Length; i++)
            {
                string fs = System.IO.File.ReadAllText(sts[i]);
                Function f = Function.Parse(fs);
                if(!Functions.ContainsKey(f.Name))
                Functions.Add(f.Name, f);
                App.AddMenu(f.MenuPath, f);
                App.AddContextMenu(f.ContextPath, f);
            }
        }

References BioImager.App.AddContextMenu(), and BioImager.App.AddMenu().

Parse()

static Function BioImager.Function.Parse ( string  s )

static

Definition at line 561 of file FunctionForm.cs.

        {
            if (s == "")
                return new Function();
            try
            {
                return JsonConvert.DeserializeObject<Function>(s);
            }
            catch (Exception)
            {
                return new Function();
            }
        }

PerformFunction()

object BioImager.Function.PerformFunction

(

bool

imagej

)

It runs a function based on the type of function it is

Parameters

imagej

boolean

Returns

The return value is the object that is being returned.

Definition at line 586 of file FunctionForm.cs.

        {
            if(FuncType == FunctionType.Key && Script!="")
            if(imagej)
            {
                FuncType = FunctionType.ImageJ;
            }
            else
                FuncType = FunctionType.Script;
            if (FuncType == Function.FunctionType.Script)
            {
                Scripting.RunString(script);
            }
            if (FuncType == Function.FunctionType.ImageJ)
            {
                ImageJ.RunOnImage(script, false, BioConsole.onTab, BioConsole.useBioformats, BioConsole.newTab);
            }
            if (FuncType == Function.FunctionType.Property)
            {
                if (Name.StartsWith("Get"))
                {
                    Automation.Recording r = (Automation.Recording)Automation.Properties[System.IO.Path.GetFileNameWithoutExtension(File)];
                    return r.Get();
                }
                else if (Name.StartsWith("Set"))
                {
                    Automation.Recording r = (Automation.Recording)Automation.Properties[System.IO.Path.GetFileNameWithoutExtension(File)];
                    r.Set(Value.ToString());
                }
 
            }
            if (FuncType == Function.FunctionType.Key)
            {
                if (Modifier != VirtualKeyCode.NONAME)
                {
                    input.Keyboard.ModifiedKeyStroke(Modifier, Key);
                }
                else
                {
                    input.Keyboard.KeyPress(Key);
                }
                return null;
            }
            if (FuncType == Function.FunctionType.Recording)
            {
                Automation.Recording r = (Automation.Recording)Automation.Recordings[System.IO.Path.GetFileNameWithoutExtension(File)];
                r.Run();
            }
            if (FuncType == Function.FunctionType.Objective)
            {
                App.imager.PerformFunction(this);
            }
            if (FuncType == Function.FunctionType.StoreCoordinate)
            {
                App.imager.PerformFunction(this);
            }
            if (FuncType == Function.FunctionType.NextCoordinate)
            {
                App.imager.PerformFunction(this);
            }
            if (FuncType == Function.FunctionType.PreviousCoordinate)
            {
                App.imager.PerformFunction(this);
            }
            if (FuncType == Function.FunctionType.NextSnapCoordinate)
            {
                App.imager.PerformFunction(this);
            }
            if (FuncType == Function.FunctionType.PreviousSnapCoordinate)
            {
                App.imager.PerformFunction(this);
            }
            if (FuncType == Function.FunctionType.StageUp)
            {
                Microscope.MoveUp(Value);
            }
            if (FuncType == Function.FunctionType.StageRight)
            {
                Microscope.MoveRight(Value);
            }
            if (FuncType == Function.FunctionType.StageDown)
            {
                Microscope.MoveDown(Value);
            }
            if (FuncType == Function.FunctionType.StageLeft)
            {
                Microscope.MoveLeft(Value);
            }
            if (FuncType == Function.FunctionType.FocusUp)
            {
                Microscope.SetFocus(Value);
            }
            if (FuncType == Function.FunctionType.FocusDown)
            {
                Microscope.SetFocus(-Value);
            }
            if (FuncType == Function.FunctionType.StageFieldUp)
            {
                Microscope.MoveFieldUp();
            }
            if (FuncType == Function.FunctionType.StageFieldRight)
            {
                Microscope.MoveFieldRight();
            }
            if (FuncType == Function.FunctionType.StageFieldDown)
            {
                Microscope.MoveFieldDown();
            }
            if (FuncType == Function.FunctionType.StageFieldLeft)
            {
                Microscope.MoveFieldLeft();
            }
            if (FuncType == Function.FunctionType.TakeImage)
            {
                Microscope.TakeImage();
            }
            if (FuncType == Function.FunctionType.TakeImageStack)
            {
                Microscope.TakeImageStack();
            }
            if (FuncType == Function.FunctionType.RL)
            {
                Microscope.RLShutter.SetPosition((int)Value);
            }
            if (FuncType == Function.FunctionType.TL)
            {
                Microscope.TLShutter.SetPosition((int)Value);
            }
            return null;
        }

References BioImager.Imager.PerformFunction(), BioImager.ImageJ.RunOnImage(), and BioImager.Scripting.RunString().

Save()

void BioImager.Function.Save

(

)

It saves all the functions in the Functions dictionary to a file.

Definition at line 735 of file FunctionForm.cs.

        {
            string st = Application.StartupPath;
            
            if(!Directory.Exists(st + "/Functions"))
            {
                Directory.CreateDirectory(st + "/Functions");
            }
            foreach (Function f in Functions.Values)
            {
                System.IO.File.WriteAllText(st + "/Functions/" + f.Name + ".func",f.Serialize());
            }
        }

Serialize()

string BioImager.Function.Serialize

(

)

Definition at line 575 of file FunctionForm.cs.

        {
            return JsonConvert.SerializeObject(this);
        }

ToString()

override string BioImager.Function.ToString

(

)

Definition at line 557 of file FunctionForm.cs.

        {
            return name + ", " + MenuPath;
        }

Member Data Documentation

Functions

Dictionary<string, Function> BioImager.Function.Functions = new Dictionary<string, Function>()

static

Definition at line 399 of file FunctionForm.cs.

input

InputSimulator BioImager.Function.input = new InputSimulator()

static

Definition at line 580 of file FunctionForm.cs.

Property Documentation

ContextPath

string BioImager.Function.ContextPath

getset

Definition at line 533 of file FunctionForm.cs.

        {
            get
            {
                return menuPath;
            }
            set
            {
                menuPath = value;
            }
        }

File

string BioImager.Function.File

getset

Definition at line 492 of file FunctionForm.cs.

        {
            get { return file; }
            set { file = value; }
        }

FuncType

FunctionType BioImager.Function.FuncType

getset

Definition at line 479 of file FunctionForm.cs.

        {
            get
            {
                return functionType;
            }
            set
            {
                functionType = value;
            }
        }

Key

VirtualKeyCode BioImager.Function.Key

getset

Definition at line 453 of file FunctionForm.cs.

        {
            get
            {
                return key;
            }
            set
            {
                key = value;
            }
        }

MenuPath

string BioImager.Function.MenuPath

getset

Definition at line 521 of file FunctionForm.cs.

        {
            get
            {
                return menuPath;
            }
            set
            {
                menuPath = value;
            }
        }

Modifier

VirtualKeyCode BioImager.Function.Modifier

getset

Definition at line 466 of file FunctionForm.cs.

        {
            get
            {
                return modifier;
            }
            set
            {
                modifier = value;
            }
        }

Name

string BioImager.Function.Name

getset

Definition at line 509 of file FunctionForm.cs.

        {
            get
            {
                return name;
            }
            set
            {
                name = value;
            }
        }

Script

string BioImager.Function.Script

getset

Definition at line 499 of file FunctionForm.cs.

        {
            get { return script; }
            set 
            { 
                script = value;
            }
        }

State

ButtonState BioImager.Function.State

getset

Definition at line 439 of file FunctionForm.cs.

        {
            get
            {
                return buttonState;
            }
            set
            {
                buttonState = value;
            }
        }

Value

double BioImager.Function.Value

getset

Definition at line 546 of file FunctionForm.cs.

        {
            get
            {
                return val;
            }
            set
            {
                val = value;
            }
        }

---

The documentation for this class was generated from the following file:

• F:/repos/BioImager/BioImager/Source/FunctionForm.cs