Tutorial 226 | Sharing inputs between EasyLanguage programs using GlobalDictionary

The two programs work together as a pair. The first, _Tutorial226-Send, is an indicator that owns the user inputs. The second, _Tutorial226PB, is a PaintBar study that colours the chart bars based on those inputs. The key idea is that you only ever need to change the inputs in one place — the Send indicator — and the PaintBar will automatically pick up the changes and redraw.

The Send Indicator

When the indicator is first applied to a chart, the Once block runs and does two things. First it creates a GlobalDictionary object called T226Inputs. Then it writes each of the six user inputs into the dictionary as key/value pairs. Notice that each key is prefixed with GetSymbolName — for example GetSymbolName + "ATR_Length" — so that the keys are unique to the symbol on that chart. This is an important detail that prevents the dictionary entries for one symbol from clashing with those of another symbol if the programs are applied to multiple charts in the same workspace.

After the Once block, the indicator runs on every bar, calculating:

• The Average True Range over the user-specified length
• A baseline of that ATR using a longer average
• A volatility ratio — the current ATR divided by the baseline, giving a value centred around 1.0
• An optional smoothed version of that ratio
• A regime classification — 1 for low volatility, 2 for normal, 3 for high — based on where the ratio falls relative to the two thresholds

I covered the exact same calculation in Quick-tip 104.

Four plots are produced: the regime level, the smoothed ratio, and the two threshold lines, giving a clear visual reference in a separate subgraph.

The PaintBar Study

The PaintBar is structured to mirror the Send indicator but receives its parameters from the dictionary rather than from its own inputs. When it is first applied, its Once block runs and does three things:

First it calls GlobalDictionary.Create() to connect to the shared dictionary. It then checks whether each key already exists in the dictionary using Contains — and if so, reads the value back and assigns it to the corresponding local variable. This handles the case where the Send indicator was already applied before the PaintBar.

Second, it registers the ItemChanged_Updated event handler. This is the mechanism that keeps the two programs in sync going forward — whenever the Send indicator updates a value in the dictionary, this event fires in the PaintBar, reads all the values back, and throws a RecalculateException to force the chart to redraw with the new parameters.

Third, it pre-calculates the HotPink colour once using the LegacyColorFromColObject method and stores it in PlotCol. This is more efficient than converting the color string on every bar, and avoids the Print statement inside that method running repeatedly.

The PaintBar then runs the identical volatility calculation on every bar and uses PlotPB to colour each bar — red for low volatility, green for normal, and HotPink for high.

The GetSymbolName Key Prefix — Why It Matters

This is probably the most important design decision in the programs. Because GlobalDictionary can be accessible across studies within a workspace, using plain key names like "ATR_Length" could cause two charts trading different symbols to interfere with each other. By prefixing every key with the symbol name, each chart effectively has its own private namespace within the shared dictionary, so long as multiple charts are not open for the same symbol.

Summary

Together the two programs demonstrate a clean and reusable pattern for inter-study communication in TradeStation EasyLanguage — one program owns the inputs, writes them to a shared dictionary, and the other listens for changes via an event handler and recalculates automatically. The GetSymbolName prefix makes the design robust enough to use across a multi-chart workspace without conflict.