I have a Dynamic-based GUI, and one part of it will kick off a calculation that could take longer than the default 5-second dynamic timeout.
I know that Button has a Method -> "Queued" option for performing an evaluation on the main link rather than by doing a pre-emptive evaluation.
How can I initiate a main link evaluation without requiring the user to click a button?
If you pass SynchronousUpdating->False to Dynamic, it will perform operations on the main link. Note that this only works where Dynamic is displayed as a typeset result (i.e., typeset as a DynamicBox). It does not presently work where Dynamic is used to give a value to a control (such as Slider) or an option.
A quick survey of other constructs...
ActionMenu has a Method option which works identically to Button.
EventHandler, as of version 9, has no way to do main link evaluations.
(Edit: As of v10, the EventHandler and the various EventHandler-like options now accept a Method option.)
FrontEndDynamicExpression and friends, as of version 9, have no way to do main link evaluations.
While John Fultz gave a depressing answer concerning GUI controls, I doubted that this cannot be done in Mathematica. A bit of exploration and Rojo's extremely useful answer helped me to come up with a workaround to simulate Method -> Queued for GUI controllers other than Button.
The function queued accepts any dynamic controller as its first argument and any command as its second argument and whenever dynamic manipulation of the controller is done, it fires the command just like Button[..., Method -> "Queued"] would do:
Attributes[queued] = {HoldRest}; queued[gui_, action_] := DynamicModule[{trigger = False}, DynamicWrapper[EventHandler[gui, {"MouseDown" :> (trigger = False), "MouseDragged" :> (trigger = False), "MouseUp" :> (trigger = True)}, PassEventsDown -> True, PassEventsUp -> False], If[trigger, Refresh[action, None]], SynchronousUpdating -> False ]]; Now simulate a long calculation that depends on a slider-value and wrap the whole in queued. Whenever the Slider is released, the updating of the long calculation starts:
long[x_] := Module[{a = .3}, Do[a = x a (1 - a), {i, 10^6}]]; active = False; x = 3.5; queued[Slider[Dynamic[x], {1, 4}, Appearance -> "Labeled"], active = True; long@x; active = False;] Dynamic@If[active, ProgressIndicator[i, {0, 10^6}], "Ready."] 
Just for reference, the same cannot be done with the second argument of Dynamic (as discussed here). This won't work:
Slider@Dynamic[x, {(x = #) &, active = True; long@x; active = False;}] Concerning ContinuousAction -> False, my problem is twofold: first, it does not update the controller variable continuously (which is an unnecessary limitation in my case), second, the following code won't work as expected:
trigger = False; x = 3.5; Slider[Dynamic[x, (x = #; trigger = True; long[x]; trigger = False;) &], {1, 4}, ContinuousAction -> False, Appearance -> "Labeled"] Dynamic@If[trigger, ProgressIndicator[i, {0, 10^6}], "Ready."] Neither does this:
trigger = False; x = 3.5; DynamicWrapper[Slider[Dynamic[x, (x = #; trigger = True;) &], {1, 4}, ContinuousAction -> False, Appearance -> "Labeled"], If[trigger, Refresh[long[x]; trigger = False;, None]]] Dynamic@If[trigger, ProgressIndicator[i, {0, 10^6}], "Ready."] 
DynamicWrapper something like the following: Slider[Dynamic[x, (x = #; trigger = True) &], {1, 4}, ContinuousAction -> False, Appearance -> "Labeled"]. This is not only somewhat simpler, it also will work with gui elements which are not triggered by the mouse, as e.g. InputField... $\endgroup$ EventHandler to handle those. $\endgroup$ Based on Istvans solution this should do the same thing, but is somewhat simpler in that it avoids the EventHandler which would need adoption to match the possible interactions of the gui element used. The use of the three "change functions" also makes possible to continuously update the controller variable but only trigger the long calculation when the "editing" is finished:
long[x_] := Module[{a = .3}, Do[a = x a (1 - a), {i, 10^6}]] x = 3.5; active = False; DynamicModule[{trigger = False}, Column[{ DynamicWrapper[ Slider[ Dynamic[x, {(x = #) &, (x = #) &, (x = #; trigger = True) &}], {1, 4}, ContinuousAction -> True, Appearance -> "Labeled" ], If[trigger, Refresh[active = True; long@x; active = False; trigger = False;, None]], SynchronousUpdating -> False ], Dynamic@If[active, ProgressIndicator[i, {0, 10^6}], "Ready."] }] ] This should work just as well for e.g. an InputField:
long[x_] := Module[{a = .3}, Do[a = x a (1 - a), {i, 10^6}]] x = 3.5; active = False; DynamicModule[{trigger = False}, Column[{ DynamicWrapper[ InputField[ Dynamic[x, {(x = #) &, (x = #) &, (x = #; trigger = True) &}], Number, ContinuousAction -> False ], If[trigger, Refresh[active = True; long@x; active = False; trigger = False;, None]], SynchronousUpdating -> False ], Dynamic@If[active, ProgressIndicator[i, {0, 10^6}], "Ready."] }] ] 
Slider[..., Method -> "Queued"] and similar for all gui controls. I was about to aim for solving {$f_{start}$, $f$, $f_{end}$}, but this is now handled beautifully. $\endgroup$ You can also do this inside a Manipulate. Two useful settings are:
SynchronousUpdating -> False and
ContinuousAction -> False which apply to any of the possible control types (including sliders). The first specifies "whether or not contents are evaluated synchronously" and the second specifies whether an "action should be taken continuously while controls are moved". The latter is something like Istvan's queued slider.
