({{, (RefLink[Dynamic, paclet:ref/Dynamic])[expr]
represents an object that displays as the dynamically updated current value of expr. If the displayed form of (RefLink[Dynamic, paclet:ref/Dynamic])[expr] is interactively changed or edited, an assignment expr=val is done to give expr the new value val that corresponds to the displayed form. }, {, (RefLink[Dynamic, paclet:ref/Dynamic])[expr,(RefLink[None, paclet:ref/None])]
does not allow interactive changing or editing. }, {, (RefLink[Dynamic, paclet:ref/Dynamic])[expr,f]
continually evaluates f[val,expr] during interactive changing or editing of val. }, {, (RefLink[Dynamic, paclet:ref/Dynamic])[expr,{f,(Subscript[f, end])}]
also evaluates (Subscript[f, end])[val,expr] when interactive changing or editing is complete. }, {, (RefLink[Dynamic, paclet:ref/Dynamic])[expr,{(Subscript[f, start]),f,(Subscript[f, end])}]
also evaluates (Subscript[f, start])[val,expr] when interactive changing or editing begins. }})

OpenersNotesSection(Spacer1)Details and Options

(RefLink[Dynamic, paclet:ref/Dynamic])[expr] can appear not only directly as an expression to display, but also for example as a coordinate in a graphics primitive or an object such as a slider, or as a setting for an option.

When used to assign values to expr through interactive operations, the expression in (RefLink[Dynamic, paclet:ref/Dynamic])[expr] will most often be a symbol x, an object x[i], a part e[[i]], or a list {x,y,…}.

In graphics, for example, (RefLink[Point, paclet:ref/Point])[Dynamic[{x,y}]] represents a point whose position is dynamically updated to be given by the current values of x and y. Whenever the point is interactively moved, assignments of the form {x,y}={(Subscript[val, x]),(Subscript[val, y])} are done. (RefLink[Point, paclet:ref/Point])[Dynamic[{x,y}]] can be moved interactively; (RefLink[Dynamic, paclet:ref/Dynamic])[(RefLink[Point, paclet:ref/Point])[{x,y}]] cannot.

(RefLink[Dynamic, paclet:ref/Dynamic])[expr] evaluates expr whenever it needs its value and it determines that any type of value of symbols on which it depends might have changed.

If (RefLink[Refresh, paclet:ref/Refresh]) or (RefLink[Clock, paclet:ref/Clock]) objects appear in the evaluation of the expression in (RefLink[Dynamic, paclet:ref/Dynamic])[expr], then expr will always continually be reevaluated.

(RefLink[Dynamic, paclet:ref/Dynamic]) has attribute (RefLink[HoldFirst, paclet:ref/HoldFirst]), so that expr is not evaluated until its value is needed for display.

(RefLink[Dynamic, paclet:ref/Dynamic])[expr] is equivalent to (RefLink[Dynamic, paclet:ref/Dynamic])[expr,(expr=#)&].

(RefLink[Dynamic, paclet:ref/Dynamic])[expr,f] makes interactive operations not change expr except by virtue of the evaluation of f[val,expr].

Objects represented by (RefLink[Dynamic, paclet:ref/Dynamic])[expr,(RefLink[None, paclet:ref/None])] cannot be changed interactively, but will change if the value of expr changes for other reasons.

(RefLink[Dynamic, paclet:ref/Dynamic])[expr,(RefLink[Temporary, paclet:ref/Temporary])] allows the displayed form of an object to change in the course of interactive operations, but assigns an updated value to expr only when the operations are complete.

For interactive mouse operations, (RefLink[Dynamic, paclet:ref/Dynamic])[expr,{(Subscript[f, start]),f,(Subscript[f, end])}] typically evaluates (Subscript[f, start])[val,expr] once when the mouse is pressed, then evaluates f[val,expr] whenever the mouse is moved, and then evaluates (Subscript[f, end])[val,expr] once when the mouse is released.

If the mouse is not moved, (Subscript[f, start]), f, and (Subscript[f, end]) are each evaluated exactly once.

f[val,expr] is always evaluated once immediately after the evaluation of (Subscript[f, start])[val,expr], and when it is last evaluated, the value of val is always the same as in (Subscript[f, end])[val,expr].

Interactive operations that can affect (RefLink[Dynamic, paclet:ref/Dynamic]) objects include dragging of elements in graphics or in objects such as (RefLink[Slider, paclet:ref/Slider]), as well as editing of fields in objects such as (RefLink[InputField, paclet:ref/InputField]).

The functions (Subscript[f, start]), f, and (Subscript[f, end]) can be the following:

(RefLink[Dynamic, paclet:ref/Dynamic])[expr,f] is equivalent to (RefLink[Dynamic, paclet:ref/Dynamic])[expr,{(RefLink[None, paclet:ref/None]),f,(RefLink[None, paclet:ref/None])}].

(RefLink[Dynamic, paclet:ref/Dynamic])[expr,(RefLink[Temporary, paclet:ref/Temporary])] is equivalent to (RefLink[Dynamic, paclet:ref/Dynamic])[expr,{(RefLink[None, paclet:ref/None]),(RefLink[Temporary, paclet:ref/Temporary]),(RefLink[Automatic, paclet:ref/Automatic])}].

(RefLink[Dynamic, paclet:ref/Dynamic])[expr,f] can be used to enforce constraints on values assigned to expr.

(RefLink[Dynamic, paclet:ref/Dynamic])[expr,f] can be used to do assignments for individual variables when expr is an expression like x+y.

A function func[val,expr] should have attribute (RefLink[HoldRest, paclet:ref/HoldRest]) if it is going to perform an assignment to expr. This can be achieved with (RefLink[Function, paclet:ref/Function])[{v,e},body,(RefLink[HoldRest, paclet:ref/HoldRest])].

The following options can be given:

(RefLink[Dynamic, paclet:ref/Dynamic])[e] displays as the dynamically updated current value of e in (RefLink[StandardForm, paclet:ref/StandardForm]) and (RefLink[TraditionalForm, paclet:ref/TraditionalForm]), but just as (RefLink[Dynamic, paclet:ref/Dynamic])[e] in (RefLink[InputForm, paclet:ref/InputForm]) and (RefLink[OutputForm, paclet:ref/OutputForm]).

(RefLink[Dynamic, paclet:ref/Dynamic])[expr] provides an analog of delayed assignment, where values are implicitly requested by the need to display, rather than by evaluation of an expression.

OpenersPrimaryExamplesSection(Spacer1)Examples  (49)

OpenersExampleSection0(Spacer1)Basic Examples  (1)

(RefLink[Dynamic, paclet:ref/Dynamic]) simply returns the current value of its argument:

Dynamic[x]

Assign a value to x to update the output above:

x=0.5

Tie the symbol x to a (RefLink[Slider, paclet:ref/Slider]):

Slider[Dynamic[x]]

OpenersExampleSection1(Spacer1)Scope  (22)

OpenersExampleSubsection0(Spacer1)Basic Dynamic  (6)

Any expression can be wrapped with (RefLink[Dynamic, paclet:ref/Dynamic]):

Dynamic/@{1+x,"string",Graphics[{Red,Disk[]},ImageSize->Tiny]}

(RefLink[Dynamic, paclet:ref/Dynamic]) is not shown in (RefLink[StandardForm, paclet:ref/StandardForm]), but is still present:

InputForm/@%

Use (RefLink[Dynamic, paclet:ref/Dynamic]) to link the currently displayed value depending on n:

Dynamic[n]

Slider[Dynamic[n]]

Dynamic[NIntegrate[Sin[t],{t,-Pi,n}]]

SetterBar[Dynamic[n],Range[0,1,0.2]]

Dynamic[Plot[Sin[(n+1) x],{x,0,6}]]

By default, variables inside (RefLink[Dynamic, paclet:ref/Dynamic]) are not localized:

{Slider[Dynamic[x]],Dynamic[x]}

Use (RefLink[DynamicModule, paclet:ref/DynamicModule]) to localize variables:

{DynamicModule[{x},{Slider[Dynamic[x]],Dynamic[x]}],Dynamic[x]}

And to initialize variables:

{DynamicModule[{x=0.5},{Slider[Dynamic[x]],Dynamic[x]}],Dynamic[x]}

A (RefLink[Dynamic, paclet:ref/Dynamic]) expression can be self-triggering:

DynamicModule[{x=1},Dynamic[x=Max[0,x-0.01]]]

Use with (RefLink[Slider, paclet:ref/Slider]):

DynamicModule[{x=1},{Slider[Dynamic[x]],Dynamic[x=Max[0,x-0.01]]}]

Expressions such as (RefLink[RandomReal, paclet:ref/RandomReal]) and (RefLink[DateString, paclet:ref/DateString]) do not automatically update:

Dynamic[RandomReal[]]

Dynamic[DateString[]]

Use (RefLink[UpdateInterval, paclet:ref/UpdateInterval]) to force dynamic updating:

Dynamic[RandomReal[],UpdateInterval->1/2]

Dynamic[DateString[],UpdateInterval->1]

(RefLink[Dynamic, paclet:ref/Dynamic]) holds its argument and never evaluates it unless it displays as output:

Dynamic[a=5];

Since the above (RefLink[Dynamic, paclet:ref/Dynamic]) was never displayed, the assignment was never executed:

a

OpenersExampleSubsection1(Spacer1)Placing Dynamic  (3)

(RefLink[Plot, paclet:ref/Plot]) needs specific numerical values to create the output:

DynamicModule[{x},{Slider[Dynamic[x],{1,5}],Plot[Sin[Dynamic[x]i],{i,0,2Pi}]}]

DynamicModule[{x},{Slider[Dynamic[x],{1,5}],Dynamic[Plot[Sin[x i],{i,0,2Pi}]]}]

Separate (RefLink[Dynamic, paclet:ref/Dynamic]) expressions update independently, allowing for efficiency:

x=Plot3D[Sin[n m],{n,0,4},{m,0,4}];

Slider[Dynamic[y]]

TabView[{{Dynamic[x],Dynamic[y]},Dynamic[{x,y}]}]

Use graphics coordinates as control input by placing (RefLink[Dynamic, paclet:ref/Dynamic]) around them:

{DynamicModule[{p={0,0}},Framed@Graphics[{Locator[Dynamic[p]]},PlotRange->1,PlotLabel->Dynamic[p]]],DynamicModule[{p={0,0}},Framed@Graphics[{Dynamic[Locator[p]]},PlotRange->1,PlotLabel->Dynamic[p]]]}

Use the graphics coordinates as control input and see the effects on 2D sliders:

DynamicModule[{p1={0,0},p2={1,0},p3={0,1}},{Framed@Graphics[Polygon[{Dynamic[p1],Dynamic[p2],Dynamic[p3]}],PlotRange->1],Column[Slider2D[#,{-1,1}]&/@{Dynamic[p1],Dynamic[p2],Dynamic[p3]}]}]

OpenersExampleSubsection2(Spacer1)Interactive Dynamic  (7)

Use (RefLink[Dynamic, paclet:ref/Dynamic]) to connect variables with interactive controls, such as (RefLink[Slider, paclet:ref/Slider]):

{Slider[Dynamic[x]],Dynamic[x]}

(RefLink[Slider2D, paclet:ref/Slider2D]):

{Slider2D[Dynamic[x]],Dynamic[x]}

(RefLink[InputField, paclet:ref/InputField]):

{InputField[Dynamic[x]],Dynamic[x]}

(RefLink[ColorSlider, paclet:ref/ColorSlider]):

{ColorSlider[Dynamic[x]],Dynamic[x]}

(RefLink[PopupMenu, paclet:ref/PopupMenu]):

{PopupMenu[Dynamic[x],Range[10]],Dynamic[x]}

(RefLink[Locator, paclet:ref/Locator]):

DynamicModule[{x={0,0}},{Graphics[Locator[Dynamic[x]],PlotRange->1],Dynamic[x]}]

Use (RefLink[Dynamic, paclet:ref/Dynamic]) to control view elements, such as (RefLink[TabView, paclet:ref/TabView]):

d=Table[Graphics[Disk[],ImageSize->t],{t,{10,20,30,40}}]

{TabView[d,Dynamic[x]],Dynamic[x]}

(RefLink[FlipView, paclet:ref/FlipView]):

{FlipView[d,Dynamic[x]],Dynamic[x]}

(RefLink[PopupView, paclet:ref/PopupView]):

{PopupView[d,Dynamic[x]],Dynamic[x]}

(RefLink[OpenerView, paclet:ref/OpenerView]):

{OpenerView[{Disk,d},Dynamic[t]],Dynamic[t]}

OpenersExampleSubsection3(Spacer1)Advanced Dynamic  (6)

By default, (RefLink[Dynamic, paclet:ref/Dynamic]) performs an assignment operation when used in an interactive element:

{Slider[Dynamic[x]],Dynamic[x]}

{Slider[Dynamic[y,(y=#)&]],Dynamic[y]}

{Slider[Dynamic[z,Automatic]],Dynamic[z]}

Use the second argument to specify a function to be evaluated during interaction:

col=None;{Slider[Dynamic[x,(col=Blue;x=#)&],Background->Dynamic[col]],Dynamic[x]}

Supply a list of two functions to be evaluated during and after interaction:

col=None;{Slider[Dynamic[x,{(col=Blue;x=#)&,(col=Green)&}],Background->Dynamic[col]],Dynamic[x]}

Supply a list of three functions to be evaluated before, during, and after interaction:

x=0.5;{Slider[Dynamic[x,{(y=x)&,(x=#)&,(x=y)&}]],Dynamic[x]}

Use (RefLink[Temporary, paclet:ref/Temporary]) to update the dynamic variable at the end of interaction:

{Slider[Dynamic[x,Temporary]],Dynamic[x]}

Use (RefLink[None, paclet:ref/None]) to disallow updating the dynamic variable:

{Slider[Dynamic[x,None]],Dynamic[x]}

OpenersExampleSection2(Spacer1)Options  (8)

OpenersExampleSubsection4(Spacer1)BaseStyle  (1)

Set the base style:

DynamicModule[{x="this is some text"},Dynamic[x,BaseStyle->{FontColor->Orange}]]

OpenersExampleSubsection5(Spacer1)Deinitialization  (1)

Specify expressions to be evaluated when output is no longer displayed:

CreateDialog[Dynamic[f[Pink],Initialization:>(f[x_]:=Graphics[{x,Disk[]}]),Deinitialization:>CreateDialog[f[Blue]]]];

OpenersExampleSubsection6(Spacer1)Evaluator  (1)

Specify a (RefLink[Dynamic, paclet:ref/Dynamic]) that will only run in the kernel named "Local":

Dynamic[$CommandLine, Evaluator->"Local"]

OpenersExampleSubsection7(Spacer1)Initialization  (2)

By default, external definitions are lost between kernel sessions:

f[x_]:=Range[x]

Dynamic[f[10]]

Use (RefLink[Initialization, paclet:ref/Initialization]) to evaluate expressions necessary for displaying the output:

Dynamic[g[10],Initialization:>(g[x_]:=Range[x])]

OpenersExampleSubsection8(Spacer1)ShrinkingDelay  (1)

Assign a number or graphics to h:

SetterBar[Dynamic[h],{Graphics[Disk[],ImageSize->Tiny]->"Graphics",1->"Number"}]

Use (RefLink[ShrinkingDelay, paclet:ref/ShrinkingDelay]) to allow lapse time before shrinking the size of the output:

Framed/@{Dynamic[h],Dynamic[h,ShrinkingDelay->2]}

OpenersExampleSubsection9(Spacer1)SynchronousUpdating  (1)

Prevent a lengthy evaluation from timing out or hanging the system:

Dynamic[Pause[5];"result",SynchronousUpdating->False]

OpenersExampleSubsection10(Spacer1)TrackedSymbols  (1)

Updates y only when x changes:

DynamicModule[{x,y},Column@{Labeled[Slider[Dynamic[x]],"x",Left],Labeled[Slider[Dynamic[y]],"y",Left],Dynamic[{x,y},TrackedSymbols:>{x}]}]

OpenersExampleSection3(Spacer1)Applications  (5)

Constrain the coordinates of a point to lie on a circle:

DynamicModule[{p={0,1}},Graphics[{Dashed,Circle[],PointSize[0.1],Point[Dynamic[p,(p=Normalize[#])&]]},ImageSize->Tiny,PlotRange->1.2]]

Construct a dynamic calculating interface:

DynamicModule[{a=0,b=0,s={{5,30},{1,Infinity}}},Deploy[Style[Panel[Grid[Transpose[{{Style["input a number",Red],Style["input another number",Red],"here is their sum","their difference","their product"},{InputField[Dynamic[a],Number],InputField[Dynamic[b],Number],InputField[Dynamic[a+b],Enabled->False],InputField[Dynamic[a-b],Enabled->False],InputField[Dynamic[a b],Enabled->False]}}],Alignment->Right],ImageMargins->10],DefaultOptions->{InputField->{ContinuousAction->True,FieldSize->s}}]]]

Create a timer to track lapsed minutes and seconds, with (RefLink[Trigger, paclet:ref/Trigger]) for the controls:

{Trigger[Dynamic[x,(a=FractionalPart[#];x=Round[#])&],{0,Infinity}],Dynamic[{Quotient[x,60],Mod[x,60],SetPrecision[10a,2]}]}

Create a simple interface that looks up the shapes of countries:

DynamicModule[{c},{PopupMenu[Dynamic[c],CountryData[]],Dynamic[CountryData[c,"Shape"],SynchronousUpdating->False]}]

Construct custom controls, e.g. an angular slider with range (-π,π):

DynamicModule[{angle=0,p={1,0}},{LocatorPane[Dynamic[p,(angle=ArcTan@@#;p={Cos[angle],Sin[angle]})&],Graphics[{Circle[],Arrowheads[0.15],Arrow[Dynamic[{{0,0},p}]]},ImageSize->Tiny],Appearance->None],Dynamic[angle]}]

An angular slider with range (-∞,∞):

DynamicModule[{angle=0,p={1,0},angleCalc},{LocatorPane[Dynamic[p,(angleCalc@@Normalize/@{#,p})&],Graphics[{Circle[],Arrowheads[0.15],Arrow[Dynamic[{{0,0},p}]]},ImageSize->Tiny],Appearance->None],Dynamic[angle]},Initialization:>(angleCalc[newp_,oldp_]:=(angle=angle+ArcCos[newp.oldp]Sign[Cross[newp].(newp-oldp)];p={Cos[angle],Sin[angle]}))]

OpenersExampleSection4(Spacer1)Properties & Relations  (3)

Dynamic expressions do not evaluate their contents until the result is displayed onscreen:

x=.;
result=Dynamic[x=5];
Print["x = ",x]

Even showing the result is not a guarantee that it will resolve immediately:

result
Print["x = ",x];

Use (RefLink[FinishDynamic, paclet:ref/FinishDynamic]) when timing is important:

Dynamic[y=10]
FinishDynamic[]
Print["y = ",y];

Synchronous dynamics are time-limited according to the value of (RefLink[DynamicEvaluationTimeout, paclet:ref/DynamicEvaluationTimeout]):

Style[Dynamic[Pause[2];"result"],DynamicEvaluationTimeout->1]

An evaluation can detect if it's being dynamically evaluated by using (RefLink[$DynamicEvaluation, paclet:ref/$DynamicEvaluation]):

{Dynamic[$DynamicEvaluation], $DynamicEvaluation}

OpenersExampleSection5(Spacer1)Possible Issues  (4)

The following example does not work because the assignment operation fails:

{Slider[Dynamic[1-x]],Dynamic[x]}

Use the second argument of (RefLink[Dynamic, paclet:ref/Dynamic]) to control the assignment operation:

{Slider[Dynamic[1-y,(y=1-#)&]],Dynamic[y]}

Self-triggering (RefLink[Dynamic, paclet:ref/Dynamic]) can easily cause infinite loops (delete the output to stop it):

DynamicModule[{x=1},Dynamic[x=x+1]]

By default, view elements generate the entire contents before displaying:

Timing[MenuView[(#->PolyhedronData[#])&/@PolyhedronData["Uniform"]]]

Use (RefLink[Dynamic, paclet:ref/Dynamic]) and (RefLink[ImageSize, paclet:ref/ImageSize])->(RefLink[Automatic, paclet:ref/Automatic]) to generate the contents only when displayed:

Timing[MenuView[(#->Dynamic[PolyhedronData[#]])&/@PolyhedronData["Uniform"],ImageSize->Automatic]]

(RefLink[Module, paclet:ref/Module]) variables are not initialized, and returning a (RefLink[Module, paclet:ref/Module]) variable leaks the internal symbol name:

Module[{x=5},Dynamic[x]]
FinishDynamic[];
Quit[]

Generally, variables should be initialized and localized using (RefLink[DynamicModule, paclet:ref/DynamicModule]) instead:

DynamicModule[{x=5},Dynamic[x]]
FinishDynamic[];
Quit[]

It is also acceptable to wrap (RefLink[Dynamic, paclet:ref/Dynamic]) entirely around a (RefLink[Module, paclet:ref/Module]):

Dynamic[Module[{x=5},x]]
FinishDynamic[];
Quit[]

OpenersExampleSection6(Spacer1)Neat Examples  (6)

Coupled (RefLink[Slider, paclet:ref/Slider]):

{Slider[Dynamic[x]],Slider[Dynamic[1-x,(x=1-#)&]]}

Coupled (RefLink[Slider2D, paclet:ref/Slider2D]):

{Slider2D[Dynamic[r],{-1,1}],Slider2D[Dynamic[Through[{Cos,Sin}[ArcTan@@r]],(r=Normalize[#])&],{-1,1}],Slider2D[Dynamic[{r[[1]],Sin[r[[1]] Pi]},(r={#[[1]],Sin[#[[1]] Pi]})&],{-1,1}],Slider2D[Dynamic[{r[[1]],Cos[r[[1]] Pi]},(r={#[[1]],Cos[#[[1]] Pi]})&],{-1,1}]}

A "droopy" (RefLink[Slider, paclet:ref/Slider]):

DynamicModule[{x=1},{Slider[Dynamic[x]],Dynamic[x=Max[0,x-0.01]]}]

Center a disk at the mouse position as it moves over the graphics area:

Framed@Graphics[Disk[Dynamic[MousePosition[{"Graphics",Graphics},{0,0}]],0.2],PlotRange->2]

Remember the last mouse position as it leaves the graphics area:

DynamicModule[{pt={0,0}},Framed@Graphics[Disk[Dynamic[pt=MousePosition[{"Graphics",Graphics},pt];pt],0.2],PlotRange->2]]

Click inside the framed area to see bouncing balls:

Framed@DynamicModule[{contents={}},EventHandler[Graphics[{PointSize[0.1],Point[Dynamic[contents=Map[If[#[[1,2]]≥0,{#[[1]]-#[[2]],#[[2]]+{0,0.001}},{{#[[1,1]],0},{1,-0.8}#[[2]]}]&,contents];Map[First,contents]]]},PlotRange->{{0,1},{0,1}}],"MouseDown":>(AppendTo[contents,{MousePosition["Graphics"],{0,0}}])]]

({{DocumentationFooterIconsRelatedFunction.png, ({{See Also}, {(RefLink[Manipulate, paclet:ref/Manipulate])  ▪  (RefLink[Animate, paclet:ref/Animate])  ▪  (RefLink[Control, paclet:ref/Control])  ▪  (RefLink[Monitor, paclet:ref/Monitor])  ▪  (RefLink[Refresh, paclet:ref/Refresh])  ▪  (RefLink[Deploy, paclet:ref/Deploy])  ▪  (RefLink[ContinuousAction, paclet:ref/ContinuousAction])  ▪  (RefLink[FinishDynamic, paclet:ref/FinishDynamic])  ▪  (RefLink[PreemptProtect, paclet:ref/PreemptProtect])  ▪  (RefLink[Button, paclet:ref/Button])  ▪  (RefLink[SetDelayed, paclet:ref/SetDelayed])  ▪  (RefLink[DynamicModule, paclet:ref/DynamicModule])  ▪  (RefLink[DynamicSetting, paclet:ref/DynamicSetting])  ▪  (RefLink[DynamicWrapper, paclet:ref/DynamicWrapper])  ▪  (RefLink[SessionSubmit, paclet:ref/SessionSubmit])}})}})

({{DocumentationFooterIconsRelatedTutorial.png, ({{Tutorials}, {▪(RefLinkPlain[Introduction to Dynamic, paclet:tutorial/IntroductionToDynamic])}, {▪(RefLinkPlain[Advanced Dynamic Functionality, paclet:tutorial/AdvancedDynamicFunctionality])}, {▪(RefLinkPlain[Notebook Security, paclet:tutorial/NotebookSecurity])}})}})

({{DocumentationFooterIconsRelatedGuide.png, ({{Related Guides}, {▪(RefLinkPlain[Custom Interface Construction, paclet:guide/CustomInterfaceConstruction])}, {▪(RefLinkPlain[Dynamic Interactivity Language, paclet:guide/DynamicInteractivityLanguage])}, {▪(RefLinkPlain[Click-Interactive Panels, paclet:guide/ClickInteractivePanels])}, {▪(RefLinkPlain[Low-Level Interface Control, paclet:guide/LowLevelInterfaceControl])}, {▪(RefLinkPlain[Creating Inspectors, paclet:guide/CreatingInspectors])}, {▪(RefLinkPlain[Standard Namespaces, paclet:guide/StandardNamespaces])}, {▪(RefLinkPlain[Evaluation Control, paclet:guide/EvaluationControl])}, {▪(RefLinkPlain[Dialog Boxes, paclet:guide/DialogBoxes])}, {▪(RefLinkPlain[Control Objects, paclet:guide/ControlObjects])}, {▪(RefLinkPlain[Creating & Importing Images, paclet:guide/CreatingAndImportingImages])}, {▪(RefLinkPlain[Symbolic Graphics Language, paclet:guide/SymbolicGraphicsLanguage])}, {▪(RefLinkPlain[Setting Up User Interactions, paclet:guide/SettingUpUserInteractions])}})}})

({{(Spacer1), ({{(Spacer1)Related Links}, {(WebLink[DocumentationFooterIconsRelatedLinks-FastIntro.png(Spacer1)Fast Introduction for Programmers: Interactive Interfaces, http://www.wolfram.com/language/fast-introduction-for-programmers/interactive-interfaces/])}})}})