Sierra Chart DLL Studies — LTVI, Logo & Algo

GDI+ logo drawing (logo.cpp)

HRSRC hRes = FindResource(hInstance, MAKEINTRESOURCE(IDR_LOGO_IMAGE), RT_RCDATA);
HGLOBAL hResData = LoadResource(hInstance, hRes);
void* pData = LockResource(hResData);
IStream* pStream = SHCreateMemStream((BYTE*)pData, size);
logoImage = Gdiplus::Image::FromStream(pStream);
// ... then draw at (chartLeft + 50, chartTop + 10) with scaling from chart dimensions

Strategies — they can place trades

• Scalper OrderBlock Strategy — Spots places where the order book is heavily one-sided (buy vs sell volume at each price) and where price is near a prior “order block” (a level that previously attracted strong buying or selling). When conditions line up, it can automatically place trades with stop-loss and target, using different sensitivity for New York vs Asian session.
• Trapped Volume Strategy v2 — Reads a list of “signal bars” from a file (exported by another study). On those bars it applies simple candle filters (e.g. momentum or reversal) and can place long or short trades. Used for backtesting or replaying signals.
• Strategy Mimick Live Trapped Volume — Same idea as above: uses a file of precomputed signal bars so you can replay “trapped volume”–style signals as if they were live.
• Strategy GZ and imbalance — Combines chart structure (swing highs/lows, “break of structure”), Fibonacci-style zones (GZ), and volume imbalance. When price retests a zone or breaks a level, it can suggest or place trades with fixed stop-loss and take-profit in points.
• BMFT Quantum Elite (Stability / Set & Forget) — Two variants of a rules-based strategy: one long-only with volatility filters (ATR, RSI, moving averages) and optional “runner” for letting winners run; the other classifies market regime (trending vs choppy) and only enters when conditions match. Both can attach stop and target orders to the platform.
• Absorption Entries (Loop Pop) — Tracks price levels where a lot of volume traded without much price movement (“absorption”). When price later breaks through one of those levels, it marks an entry and can run optional trade logic (e.g. stop and target).

Indicators — they draw on the chart (no auto-trading)

• AOI (Areas of Interest) — Draws and alerts on several types of “interesting” events: when price breaks an absorption line, retests a Fibonacci zone, touches a key moving average or VWAP, or breaks a recent high/low. You choose which event types to show and whether to get sound alerts.
• Unbroken (several variants) — Uses swing highs and lows (fractals) to mark where structure is “broken” and where new long/short setups might form. Different versions add filters (e.g. minimum volatility, absorption lines, or volume imbalance) or extra panels (e.g. RSI).
• Scalper OrderBlock — Same idea as the strategy above but drawing only: it marks one-sided volume (buy vs sell) at each price and highlights “order blocks.” No orders are sent; you use it to see where the strategy would be looking.
• Scalper Sessions — Draws the high and low of each trading session (e.g. Asia, London, New York) on the chart, with correct handling of daylight saving. Useful to see session ranges at a glance.
• Session OHLC Last 3 — For each session type (Asia, London, NY), shows the open, high, low, and close of the last three completed sessions. Handles timezones and DST so the windows are correct.
• Imbalance Ratio Markers — At each price level, compares buy volume to sell volume. When the ratio is extreme (e.g. many more sellers than buyers), it draws a marker. Separate sensitivity for NY vs Asia session.
• Scalper Absorption — Draws horizontal lines at levels where volume was “absorbed” (heavy volume, small price move). You set a lookback; buy and sell absorption lines can be colored differently.
• Scalper Setup — Draws Fibonacci-style zones and “break of structure” from swing points. You can set how many lines to show, when they expire, and optional alerts when price touches them.
• Scalper Hybrid Volume — Combines a simple volume threshold with session-based percentage rules (NY/Asia). Draws markers when conditions are met and can extend lines from those points across the chart.

Indicators — smoothing, trend, and chart tools

• Kalman Pressure / Volatility / Fair Value / Trend — Four studies that use a Kalman filter (a way to smooth noisy data and adapt to changes). One smooths the buy–sell volume imbalance (“delta”); one smooths how much price is moving bar to bar; one smooths price itself as a “fair value” line; one gives an adaptive trend line for filtering when to take trades.
• Liquidity Flip + Post-Flip Entry Score — Detects when price sweeps a recent high or low (taking out resting orders) then reverses. Scores how strong the follow-through is (e.g. using volume/delta and absorption) and draws entry signals and a score.
• Momentum EMA Long Filter — Draws a long arrow when price is far enough above a moving average (in ATR terms) and the average is sloping up. A simple “only go long when trend and momentum align” filter.
• EMA Slope — Plots the slope of an exponential moving average (rising = green, falling = red). Quick view of whether short-term trend is up or down.
• Colored T3 MA — A T3 moving average line that turns green when the average is rising and red when it’s falling.
• Overlay Persistent — Takes signals or alerts from up to four other studies on (possibly other) charts and combines them into one place, keeping state across recalculations so you don’t lose the list when the chart updates.
• 1m Signal Overlay — Copies arrow (or other) signals from a different chart and time frame onto this chart. E.g. show 1-minute signals on a 5-minute chart.
• Trade Jumper — Adds “Next” and “Previous” buttons that move the chart to the next or previous bar where another study drew an arrow. Lets you step through trade setups one by one.
• Absorption Tracker — Keeps a list of absorption levels and draws buy/sell arrows when price revisits them within a set number of bars. Levels expire after a while so the list doesn’t grow forever.
• Cumulative Profit (Trade List) — Draws a line of your running P&L from the platform’s trade list (each point = cumulative profit after that trade). Option to reset the line at the start of each session.
• Volatility — Flags when a group of N candles completes in less than a set time (milliseconds). Highlights very fast moves (e.g. a quick spike).
• EOD Slippage Analyzer — Looks at today’s filled orders and compares fill price to your stop price. Reports average slippage (how much worse you got filled than the stop) by hour of the day. You trigger it with a “Recalculate” button.
• Import / Export Subgraph50 — Export: write the values of a chosen study subgraph (e.g. “Subgraph 50”) to a text file so another study or strategy can read it. Import: read index–value pairs from a file and plot them as a line. Used to pass signals between studies or to replay saved signals.
• Print Bar Closed Status — A small debug study that prints to the log whether the current bar is considered “closed” or not. For developers testing bar-timing logic.

Unbroken-family (structure + filters)

• Ema Absorption — Uses the same swing/structure logic as Unbroken but only marks long entries when the shorter moving average is above the longer one and price retests an absorption level. Trend filter + level.
• Base absorption, Volume candles, Chop signal, RSI divergence — Variants that share the same underlying “Unbroken” structure (swing highs/lows, break of structure) but add different filters or displays: e.g. volume-based candles, a chop indicator, or RSI divergence. All draw signals only; no order sending.

The production unity shell the client compiles inside Sierra

#define OFC_MEMBER_BUILD
#include "sierrachart.h"
SCDLLName("scalper_suite")
#if __has_include("scalper_suite_settings.h")
#include "scalper_suite_settings.h"          // owner's baked settings
#else
static const char SCALPER_SUITE_BAKED[] = ""; // fresh machine: no settings yet
#endif
#include "scalper_block_chart.cpp"
#include "scalper_iceberg.cpp"
#include "scalper_premium.cpp"
#include "scalper_ob2.cpp"
#include "scalper_momentum.cpp"
#include "scalper_trend.cpp"

Unbroken: inputs + arrow drawing (structure + pivots)

inline void SetupUnbrokenInputs(SCStudyInterfaceRef sc) {
    SCInputRef FractalPeriod = sc.Input[0];
    SCInputRef ShowArrows = sc.Input[1];
    ShowArrows.Name = "Show Arrows";
    ShowArrows.SetCustomInputStrings("None;Pivots;Unbroken;Sunbroken;IndexUnbMinMaxPP;MinmaxPP");
    ShowArrows.SetCustomInputIndex(0);
}

inline void DrawArrows(SCStudyInterfaceRef sc,
                        SCSubgraphRef& LongArrows,
                        SCSubgraphRef& ShortArrows,
                        SCInputRef& ShowArrows,
                        Unbroken* unb_long,
                        Unbroken* unb_short) {
    if (ShowArrows.GetIndex() == 1) { // pivots
        for (size_t k = 0; k < unb_long->pivot.size(); ++k) {
            int b = unb_long->pivot_seq[k];
            if (b >= 0 && b < sc.ArraySize) {
                LongArrows[b] = -(static_cast<float>(unb_long->pivot[k]));
            }
        }
        for (size_t k = 0; k < unb_short->pivot.size(); ++k) {
            int b = unb_short->pivot_seq[k];
            if (b >= 0 && b < sc.ArraySize) {
                ShortArrows[b] = static_cast<float>(unb_short->pivot[k]);
            }
        }
    }
}

about_pivots: extrema-based pivot detection

void Unbroken::about_pivots(void*,
                              float price,
                              SCDateTimeMS time,
                              int seq,
                              int subindex,
                              float gz) {
    if (seq >= fractal_period && extrema.GetArraySize() > seq) {
        float ext = 0.0f;

        if (direction == "Short") {
            ext = *std::max_element(&extrema[seq - fractal_period],
                                     &extrema[seq]);
        } else {
            ext = *std::min_element(&extrema[seq - fractal_period],
                                     &extrema[seq]);
        }

        // Candidate pivot management (pop/append) based on structure conditions
        if (true && !pivot.empty() && !unbroken_seq.empty()
            && seq - unbroken_seq.back() > fractal_period) {
            pivot.pop_back();
            pivot_time.pop_back();
            // pivot.push_back(unbroken.back()); (in the “append” branch)
        }
    }
}