rytikov0285/mql5
Watch
1
0
Fork
You've already forked mql5
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
mql5/Indicators/CodeLock/CodeLock.mq5
3371 lines
106 KiB
MQL5
RawPermalinkNormal ViewHistory
rytikov0285
new files added
2026-11-05 12:52:36 +03:00
//+------------------------------------------------------------------+
//| CodeLock.mq5 |
//| CodeLock — модель уровней + Dashboard + TickGraphic. |
//+------------------------------------------------------------------+
#property strict
#property indicator_separate_window
#property indicator_plots 0
#property version "4.02"
#property description "CodeLock: independent LEVEL grids, DIRECTION, REVERSAL, ALERT"
#include <Canvas\Canvas.mqh>
//============================================================================
// SECTION 1: DEFINES
//============================================================================
#define INVALID_GRID (-2147483647)
#define KEY_ESCAPE_CODE 27
#define MIN_VISUAL_ROWS 5
#define MAX_VISUAL_ROWS 100
#define VISUAL_LEVEL_MIN 10
#define VISUAL_LEVEL_MAX 2000
#define VISUAL_LEVEL_STEP 10
#define DEFAULT_VISUAL_ROWS "5,10,20,30,40,50"
#define PANEL_PREFIX "TPDR_"
#define DASH_PREFIX "TPDRD_"
#define STORAGE_PREFIX "CodeLock_LEVELS_"
#define STORAGE_DASH_PREFIX "CodeLock_DASH_"
//============================================================================
// SECTION 2: STRUCTURES
//============================================================================
struct TickLevelRow
{
int level;
int direction;
int directionGrid;
int lastCrossedGrid;
int lastCrossingDirection;
int consecutiveCrossings;
double lastReversalPrice;
double reversalAtPrice;
double lastDown1Price;
double lastDown2Price;
double lastUp1Price;
double lastUp2Price;
double phaseMinBid;
double phaseMaxAsk;
bool alertEnabled;
};
struct SignalMark
{
long serial;
double price;
int level;
bool up;
bool reversal;
};
struct DashVisualRow
{
int level;
};
//============================================================================
// SECTION 3: INPUTS
//============================================================================
input double StartPrice = 1.0;
input int BufferPoints = 0;
input string InitialVisualRows = "5,10,20,30,40,50";
input int MaxModelHistoryTicks = 2000000;
input int HistoryGraphTicks = 200000;
input int HistoryBootstrapTicks = 500000;
input int HistoryChunkSize = 5000;
input int InpGraphLevelsPerSide = 10;
input int InpGraphDisplayedLevelCount = 5;
int GraphLevelsPerSide = 10;
int GraphDisplayedLevelCount = 5;
input bool DrawReversalArrows = true;
input int ReversalArrowsHistory = 20;
input bool DrawRayObjects = true;
input int InitialViewTicks = 50000;
input int MinViewTicks = 5;
input int PriceScaleWidth = 85;
input bool EnableAlert = true;
input bool EnablePushNotification = false;
input bool EnableEmailNotification = false;
input bool EnableSoundNotification = true;
input string NotificationSound = "alert.wav";
input int PanelLeftMargin = 12;
input int PanelTopMargin = 12;
input int RowHeight = 25;
input int HeaderHeight = 72;
input int DashboardFontSize = 11;
input int UpdateIntervalMs = 50;
input int AlertActivityMs = 500;
input color TickGraphColor = clrDodgerBlue;
input color RayColor = clrSilver;
input color CurrentRayColor = clrGold;
input color UpCrossColor = clrGreen;
input color DownCrossColor = clrRed;
input color BuyColor = clrBlue;
input color SellColor = clrRed;
input color PanelBackground = C'16,20,28';
input color RowBackground = C'29,35,46';
input color RowBackgroundAlt = C'24,30,40';
input color BorderColor = C'75,88,108';
input color HeaderColor = clrDeepSkyBlue;
input color TextColor = clrWhiteSmoke;
input color MutedTextColor = C'155,165,180';
input color UpColor = clrLimeGreen;
input color DownColor = clrTomato;
input color WaitColor = clrSilver;
input color AlertOnColor = clrOrange;
input color AlertOffColor = C'55,62,74';
input color AlertActivityColor = clrLimeGreen;
input color AlertTextColor = clrWhite;
//============================================================================
// SECTION 4: GLOBAL VARIABLES
//============================================================================
TickLevelRow TickLevelRows[];
int TickLevelRowCount = 0;
DashVisualRow DashVisualRows[MAX_VISUAL_ROWS];
int DashVisualRowCount = 0;
bool DashAlertEnabled[MAX_VISUAL_ROWS];
ulong DashAlertActivityUntil[MAX_VISUAL_ROWS];
double TickPrices[];
int TickCount = 0;
int TickHead = 0;
long TickSerial = 0;
double ModelTickPrices[];
double ModelTickAsks[];
int ModelTickCount = 0;
int ModelTickHead = 0;
long AttachMsc = 0;
long CursorMsc = 1;
int CursorSameMsc = 0;
int BootstrapAttempts = 0;
int HistoryBootstrapTargetTicks = 0;
bool BootstrapComplete = false;
bool LiveMode = false;
bool HavePreviousBid = false;
double PreviousBid = 0.0;
int SubWindow = -1;
SignalMark SignalMarks[];
long RebuildArrowSerialOverride = -1;
CCanvas TickCanvas;
bool CanvasReady = false;
int CanvasWidth = 0;
int CanvasHeight = 0;
int CanvasSubWindow = -1;
double GraphScaleMin = 0.0;
double GraphScaleMax = 0.0;
double ViewportCenterPrice = 0.0;
int ScaleCenterGrid = 0;
bool ScaleInitialized = false;
bool AutoScaleInitialized = false;
double VerticalScaleHalfRange = 0.0;
bool VerticalScaleManual = false;
bool VerticalScaleDragActive = false;
bool VerticalPanDragActive = false;
bool PointerDragTracking = false;
int VerticalPanDragStartY = 0;
double VerticalPanDragStartCenterPrice = 0.0;
int VerticalScaleDragStartY = 0;
double VerticalScaleDragStartHalfRange = 0.0;
double VerticalScaleDragSensitivity = 0.008;
bool InitialArrowHistoryScalePending = false;
int ViewSpan = 0;
int ViewEndOffset = 0;
bool DragActive = false;
int DragStartX = 0;
int DragStartOffset = 0;
bool MouseInTickSubwindow = false;
bool InitialViewLayoutActive = false;
bool PreviousChartMouseScroll = true;
bool ResetButtonHeld = false;
const int ZoomButtonWidth = 36;
const int ZoomButtonHeight = 28;
const int ZoomButtonGap = 6;
const int ResetButtonWidth = 64;
const int LevelButtonWidth = 32;
const int LevelButtonHeight = 22;
const int LevelButtonGap = 3;
int DashEditingRow = -1;
string DashRowsStateKey = "";
//============================================================================
// SECTION 4.5: FORWARD DECLARATIONS
//============================================================================
void AppendModelTick(const double bid, const double ask);
double GetModelTickByIndex(const int index);
double GetModelAskByIndex(const int index);
void AddTickToGraph(const double bid);
double GetTickPriceByVisibleIndex(const int index);
int ProcessTickRowForRebuild(const int rowIndex, const double oldBid,
const double bid, const MqlTick &tick);
void FitInitialArrowHistory();
void RefreshGraph();
void UpdateSubwindowScale(const double bid);
void RenderGraph(const double bid);
bool EnsureCanvas();
int GetViewStartIndex();
int GetViewCount();
void DashRenderDashboard(const double bid);
void SyncTickVisualRowsFromDashboard();
void HandleHorizontalZoom(const int xCursor, const int delta);
void HandleHorizontalDrag(const int x);
void BeginVerticalPanDrag(const int y);
void HandleVerticalPanDrag(const int y);
void EndVerticalPanDrag();
void BeginVerticalScaleDrag(const int y);
void HandleVerticalScaleDrag(const int y);
void EndVerticalScaleDrag();
void HandleZoomButtonClick(const string name);
void ResetGraphToCurrentPrice();
bool IsPointInsideObject(const string name, const int x, const int y);
void UpdateMouseScrollTarget(const int y);
void ResetAllTickLevelRowStates();
void ResetTickLevelRowState(TickLevelRow &row);
//============================================================================
// SECTION 5: MODEL
//============================================================================
int FloorGridForStep(const double price, const double step)
{
if(step <= 0.0) return INVALID_GRID;
double position = (NormalizeDouble(price, _Digits) -
NormalizeDouble(StartPrice, _Digits)) / step;
return (int)MathFloor(position);
}
int CeilGridForStep(const double price, const double step)
{
if(step <= 0.0) return INVALID_GRID;
double position = (NormalizeDouble(price, _Digits) -
NormalizeDouble(StartPrice, _Digits)) / step;
return (int)MathCeil(position);
}
double RayPriceForStep(const int grid, const double step)
{
if(step <= 0.0) return 0.0;
return NormalizeDouble(StartPrice + (double)grid * step, _Digits);
}
bool IsValidVisualLevel(const int level)
{
return (level == 5) ||
(level >= VISUAL_LEVEL_MIN &&
level <= VISUAL_LEVEL_MAX &&
(level % VISUAL_LEVEL_STEP) == 0);
}
bool IsStrictVisualRows()
{
if(TickLevelRowCount < MIN_VISUAL_ROWS || TickLevelRowCount > MAX_VISUAL_ROWS)
return false;
for(int i = 0; i < TickLevelRowCount; i++)
{
if(!IsValidVisualLevel(TickLevelRows[i].level)) return false;
if(i > 0 && TickLevelRows[i].level <= TickLevelRows[i-1].level) return false;
}
return true;
}
void ResetTickLevelRowState(TickLevelRow &row)
{
row.direction = 0;
row.directionGrid = INVALID_GRID;
row.lastCrossedGrid = INVALID_GRID;
row.lastCrossingDirection = 0;
row.consecutiveCrossings = 0;
row.lastReversalPrice = 0.0;
row.reversalAtPrice = 0.0;
row.lastDown1Price = 0.0;
row.lastDown2Price = 0.0;
row.lastUp1Price = 0.0;
row.lastUp2Price = 0.0;
row.phaseMinBid = 0.0;
row.phaseMaxAsk = 0.0;
row.alertEnabled = false;
}
void ResetAllTickLevelRowStates()
{
for(int i = 0; i < TickLevelRowCount; i++)
ResetTickLevelRowState(TickLevelRows[i]);
}
int TickRowGrid(const int rowIndex, const double price)
{
if(rowIndex < 0 || rowIndex >= TickLevelRowCount) return INVALID_GRID;
double step = (double)TickLevelRows[rowIndex].level * _Point;
return FloorGridForStep(price, step);
}
double TickRowPrice(const int rowIndex, const int grid)
{
if(rowIndex < 0 || rowIndex >= TickLevelRowCount) return 0.0;
double step = (double)TickLevelRows[rowIndex].level * _Point;
return RayPriceForStep(grid, step);
}
void UpdateTickRowReversalAt(const int rowIndex)
{
if(rowIndex < 0 || rowIndex >= TickLevelRowCount) return;
if(TickLevelRows[rowIndex].direction == 0 ||
TickLevelRows[rowIndex].directionGrid == INVALID_GRID)
{
TickLevelRows[rowIndex].reversalAtPrice = 0.0;
return;
}
int reversalGrid = TickLevelRows[rowIndex].directionGrid -
TickLevelRows[rowIndex].direction;
TickLevelRows[rowIndex].reversalAtPrice = TickRowPrice(rowIndex, reversalGrid);
}
bool RegisterTickRowCrossing(const int rowIndex,
const int grid,
const int crossingDirection,
const MqlTick &tick,
const bool emitSignals)
{
if(rowIndex < 0 || rowIndex >= TickLevelRowCount) return false;
TickLevelRows[rowIndex].lastCrossedGrid = grid;
TickLevelRows[rowIndex].lastCrossingDirection = crossingDirection;
if(TickLevelRows[rowIndex].direction == 0)
{
TickLevelRows[rowIndex].direction = crossingDirection;
TickLevelRows[rowIndex].directionGrid = grid;
TickLevelRows[rowIndex].consecutiveCrossings = 1;
UpdateTickRowReversalAt(rowIndex);
if(crossingDirection < 0)
TickLevelRows[rowIndex].phaseMinBid = tick.bid;
else if(tick.ask > 0.0)
TickLevelRows[rowIndex].phaseMaxAsk = tick.ask;
return false;
}
if(crossingDirection == TickLevelRows[rowIndex].direction)
{
TickLevelRows[rowIndex].directionGrid = grid;
TickLevelRows[rowIndex].consecutiveCrossings++;
UpdateTickRowReversalAt(rowIndex);
return false;
}
int reversalGrid = TickLevelRows[rowIndex].directionGrid -
TickLevelRows[rowIndex].direction;
if(grid != reversalGrid) return false;
int oldDirection = TickLevelRows[rowIndex].direction;
TickLevelRows[rowIndex].direction = crossingDirection;
TickLevelRows[rowIndex].directionGrid = grid;
TickLevelRows[rowIndex].consecutiveCrossings = 1;
TickLevelRows[rowIndex].lastReversalPrice = TickRowPrice(rowIndex, grid);
UpdateTickRowReversalAt(rowIndex);
if(crossingDirection < 0)
{
TickLevelRows[rowIndex].lastDown2Price = TickLevelRows[rowIndex].lastDown1Price;
TickLevelRows[rowIndex].lastDown1Price = TickLevelRows[rowIndex].lastReversalPrice;
}
else
{
TickLevelRows[rowIndex].lastUp2Price = TickLevelRows[rowIndex].lastUp1Price;
TickLevelRows[rowIndex].lastUp1Price = TickLevelRows[rowIndex].lastReversalPrice;
}
if(oldDirection > 0)
TickLevelRows[rowIndex].phaseMaxAsk = 0.0;
else
TickLevelRows[rowIndex].phaseMinBid = 0.0;
//--- ALERT + уведомления
if(emitSignals && TickLevelRows[rowIndex].alertEnabled)
{
string dir = (crossingDirection > 0) ? "UP" : "DOWN";
string msg = StringFormat("[CodeLock] REVERSAL %s @ %s (%d pt)",
dir,
DoubleToString(TickLevelRows[rowIndex].lastReversalPrice, _Digits),
TickLevelRows[rowIndex].level);
if(EnableAlert) Alert(msg);
if(EnablePushNotification) SendNotification(msg);
if(EnableEmailNotification) SendMail("CodeLock Alert", msg);
if(EnableSoundNotification && NotificationSound != "")
PlaySound(NotificationSound);
for(int d = 0; d < DashVisualRowCount; d++)
{
if(DashVisualRows[d].level == TickLevelRows[rowIndex].level)
{
DashAlertActivityUntil[d] = (ulong)GetTickCount() + (ulong)AlertActivityMs;
break;
}
}
}
return true;
}
void ProcessTickRow(const int rowIndex,
const double oldBid,
const double bid,
const MqlTick &tick,
const bool emitSignals)
{
if(rowIndex < 0 || rowIndex >= TickLevelRowCount) return;
if(bid == oldBid) return;
double step = (double)TickLevelRows[rowIndex].level * _Point;
if(step <= 0.0) return;
double buffer = (double)MathMax(0, BufferPoints) * _Point;
if(bid > oldBid)
{
int first = FloorGridForStep(oldBid - buffer, step) - 1;
int last = FloorGridForStep(bid - buffer, step) + 1;
for(int grid = first; grid <= last; grid++)
{
double confirmPrice = NormalizeDouble(
RayPriceForStep(grid, step) + buffer, _Digits);
if(confirmPrice > oldBid && confirmPrice <= bid)
RegisterTickRowCrossing(rowIndex, grid, +1, tick, emitSignals);
}
}
else
{
int first = CeilGridForStep(oldBid + buffer, step) + 1;
int last = CeilGridForStep(bid + buffer, step) - 1;
for(int grid = first; grid >= last; grid--)
{
double confirmPrice = NormalizeDouble(
RayPriceForStep(grid, step) - buffer, _Digits);
if(confirmPrice < oldBid && confirmPrice >= bid)
RegisterTickRowCrossing(rowIndex, grid, -1, tick, emitSignals);
}
}
}
void UpdateTickRowPhaseExtremes(const MqlTick &tick)
{
if(tick.bid <= 0.0) return;
for(int row = 0; row < TickLevelRowCount; row++)
{
if(TickLevelRows[row].direction > 0 && tick.ask > 0.0)
{
if(TickLevelRows[row].phaseMaxAsk <= 0.0 ||
tick.ask > TickLevelRows[row].phaseMaxAsk)
TickLevelRows[row].phaseMaxAsk = tick.ask;
}
else if(TickLevelRows[row].direction < 0)
{
if(TickLevelRows[row].phaseMinBid <= 0.0 ||
tick.bid < TickLevelRows[row].phaseMinBid)
TickLevelRows[row].phaseMinBid = tick.bid;
}
}
}
void ProcessBidTick(const MqlTick &tick,
const bool emitSignals,
const bool drawGraph,
const bool storeHistory)
{
if(tick.bid <= 0.0) return;
double bid = NormalizeDouble(tick.bid, _Digits);
if(storeHistory)
AppendModelTick(bid, tick.ask);
TickSerial++;
if(!HavePreviousBid)
{
PreviousBid = bid;
HavePreviousBid = true;
if(drawGraph)
AddTickToGraph(bid);
UpdateTickRowPhaseExtremes(tick);
return;
}
double oldBid = PreviousBid;
if(drawGraph)
AddTickToGraph(bid);
if(bid != oldBid)
{
for(int row = 0; row < TickLevelRowCount; row++)
ProcessTickRow(row, oldBid, bid, tick, emitSignals);
PreviousBid = bid;
}
UpdateTickRowPhaseExtremes(tick);
}
//============================================================================
// SECTION 5.1: MODEL — tick arrays
//============================================================================
void AppendModelTick(const double bid, const double ask)
{
if(bid <= 0.0 || MaxModelHistoryTicks < 1) return;
if(ArraySize(ModelTickPrices) < MaxModelHistoryTicks)
ArrayResize(ModelTickPrices, MaxModelHistoryTicks, MaxModelHistoryTicks);
if(ArraySize(ModelTickAsks) < MaxModelHistoryTicks)
ArrayResize(ModelTickAsks, MaxModelHistoryTicks, MaxModelHistoryTicks);
if(ModelTickCount < MaxModelHistoryTicks)
{
int idx = (ModelTickHead + ModelTickCount) % MaxModelHistoryTicks;
ModelTickPrices[idx] = bid;
ModelTickAsks[idx] = (ask > 0.0 ? ask : 0.0);
ModelTickCount++;
}
else
{
ModelTickPrices[ModelTickHead] = bid;
ModelTickAsks[ModelTickHead] = (ask > 0.0 ? ask : 0.0);
ModelTickHead = (ModelTickHead + 1) % MaxModelHistoryTicks;
}
}
double GetModelTickByIndex(const int index)
{
if(index < 0 || index >= ModelTickCount) return 0.0;
return ModelTickPrices[(ModelTickHead + index) % MaxModelHistoryTicks];
}
double GetModelAskByIndex(const int index)
{
if(index < 0 || index >= ModelTickCount) return 0.0;
return ModelTickAsks[(ModelTickHead + index) % MaxModelHistoryTicks];
}
void AddTickToGraph(const double bid)
{
if(bid <= 0.0 || HistoryGraphTicks < 1) return;
if(ArraySize(TickPrices) < HistoryGraphTicks)
ArrayResize(TickPrices, HistoryGraphTicks, HistoryGraphTicks);
if(TickCount < HistoryGraphTicks)
{
int idx = (TickHead + TickCount) % HistoryGraphTicks;
TickPrices[idx] = bid;
TickCount++;
}
else
{
TickPrices[TickHead] = bid;
TickHead = (TickHead + 1) % HistoryGraphTicks;
}
}
double GetTickPriceByVisibleIndex(const int index)
{
if(index < 0 || index >= TickCount) return 0.0;
int physical = (TickHead + index) % HistoryGraphTicks;
return TickPrices[physical];
}
//============================================================================
// SECTION 6: HISTORY
//============================================================================
void AddReversalSignalMark(const double price, const bool up, const int level)
{
if(!DrawReversalArrows || ReversalArrowsHistory <= 0) return;
if(price <= 0.0 || level <= 0) return;
int size = ArraySize(SignalMarks);
ArrayResize(SignalMarks, size + 1);
long serial = (RebuildArrowSerialOverride >= 0)
? RebuildArrowSerialOverride
: TickSerial;
SignalMarks[size].serial = serial;
SignalMarks[size].price = NormalizeDouble(price, _Digits);
SignalMarks[size].level = level;
SignalMarks[size].up = up;
SignalMarks[size].reversal = true;
int keepCount = MathMin(20, MathMax(1, ReversalArrowsHistory));
int count = 0;
for(int i = 0; i < ArraySize(SignalMarks); i++)
if(SignalMarks[i].reversal &&
SignalMarks[i].up == up &&
SignalMarks[i].level == level)
count++;
if(count <= keepCount) return;
for(int i = 0; i < ArraySize(SignalMarks); i++)
{
if(!SignalMarks[i].reversal ||
SignalMarks[i].up != up ||
SignalMarks[i].level != level)
continue;
for(int j = i; j < ArraySize(SignalMarks) - 1; j++)
SignalMarks[j] = SignalMarks[j + 1];
ArrayResize(SignalMarks, ArraySize(SignalMarks) - 1);
break;
}
}
void RecordReversalArrow(const double price, const bool buy, const int level)
{
AddReversalSignalMark(price, buy, level);
}
void FinalizeTickRowsFromHistory()
{
if(TickLevelRowCount <= 0 || ModelTickCount < 2) return;
double lastBid = GetModelTickByIndex(ModelTickCount - 1);
double previousBid = GetModelTickByIndex(ModelTickCount - 2);
if(lastBid <= 0.0 || previousBid <= 0.0 || lastBid == previousBid) return;
int fallbackDirection = (lastBid > previousBid) ? +1 : -1;
for(int i = 0; i < TickLevelRowCount; i++)
{
if(TickLevelRows[i].direction != 0) continue;
double step = (double)TickLevelRows[i].level * _Point;
if(step <= 0.0) continue;
int grid = (fallbackDirection > 0)
? CeilGridForStep(lastBid, step)
: FloorGridForStep(lastBid, step);
if(grid == INVALID_GRID) continue;
TickLevelRows[i].direction = fallbackDirection;
TickLevelRows[i].directionGrid = grid;
TickLevelRows[i].lastCrossedGrid = grid;
TickLevelRows[i].lastCrossingDirection = fallbackDirection;
TickLevelRows[i].consecutiveCrossings = 1;
UpdateTickRowReversalAt(i);
}
}
bool HistoryDerivedStateComplete()
{
if(TickLevelRowCount <= 0 || ModelTickCount < 2) return false;
for(int i = 0; i < TickLevelRowCount; i++)
{
if(TickLevelRows[i].direction == 0) return false;
if(TickLevelRows[i].reversalAtPrice <= 0.0) return false;
}
return true;
}
void ResetSelectedCalculation()
{
PreviousBid = 0.0;
HavePreviousBid = false;
}
void ClearDerivedState()
{
TickCount = 0;
TickHead = 0;
TickSerial = 0;
ArrayResize(TickPrices, MathMax(100, HistoryGraphTicks),
MathMax(100, HistoryGraphTicks));
ArrayResize(SignalMarks, 0);
ResetSelectedCalculation();
ResetAllTickLevelRowStates();
}
void UpdateCursorFromArray(const MqlTick &ticks[], const int copied, const int startIndex)
{
if(copied <= 0) return;
long finalMsc = ticks[copied - 1].time_msc;
if(finalMsc == CursorMsc)
{
int processedAtFinal = 0;
for(int i = 0; i < copied; i++)
{
if(ticks[i].time_msc == finalMsc && i >= startIndex)
processedAtFinal++;
}
if(processedAtFinal > 0)
CursorSameMsc += processedAtFinal;
}
else
{
CursorMsc = finalMsc;
int finalCount = 0;
for(int i = copied - 1; i >= 0 && ticks[i].time_msc == finalMsc; i--)
finalCount++;
CursorSameMsc = finalCount;
}
}
int ProcessTickRowForRebuild(const int rowIndex,
const double oldBid,
const double bid,
const MqlTick &tick)
{
if(rowIndex < 0 || rowIndex >= TickLevelRowCount) return 0;
if(bid == oldBid) return 0;
double step = (double)TickLevelRows[rowIndex].level * _Point;
if(step <= 0.0) return 0;
double buffer = (double)MathMax(0, BufferPoints) * _Point;
int reversals = 0;
if(bid > oldBid)
{
int first = FloorGridForStep(oldBid - buffer, step) - 1;
int last = FloorGridForStep(bid - buffer, step) + 1;
for(int grid = first; grid <= last; grid++)
{
double confirmPrice = NormalizeDouble(
RayPriceForStep(grid, step) + buffer, _Digits);
if(confirmPrice > oldBid && confirmPrice <= bid)
{
if(RegisterTickRowCrossing(rowIndex, grid, +1, tick, false))
{
AddReversalSignalMark(TickLevelRows[rowIndex].lastReversalPrice,
true, TickLevelRows[rowIndex].level);
reversals++;
}
}
}
}
else
{
int first = CeilGridForStep(oldBid + buffer, step) + 1;
int last = CeilGridForStep(bid + buffer, step) - 1;
for(int grid = first; grid >= last; grid--)
{
double confirmPrice = NormalizeDouble(
RayPriceForStep(grid, step) - buffer, _Digits);
if(confirmPrice < oldBid && confirmPrice >= bid)
{
if(RegisterTickRowCrossing(rowIndex, grid, -1, tick, false))
{
AddReversalSignalMark(TickLevelRows[rowIndex].lastReversalPrice,
false, TickLevelRows[rowIndex].level);
reversals++;
}
}
}
}
return reversals;
}
bool BootstrapHistory()
{
int minimumTarget = MathMax(HistoryGraphTicks, HistoryBootstrapTicks);
minimumTarget = MathMax(minimumTarget, 100);
int maximumTarget = MathMax(minimumTarget, MathMax(100, MaxModelHistoryTicks));
if(HistoryBootstrapTargetTicks <= 0)
HistoryBootstrapTargetTicks = MathMin(minimumTarget, maximumTarget);
else
HistoryBootstrapTargetTicks = MathMax(minimumTarget,
MathMin(HistoryBootstrapTargetTicks, maximumTarget));
int targetTicks = HistoryBootstrapTargetTicks;
MqlTick ticks[];
ArrayResize(ticks, targetTicks);
int copied = -1;
int lastError = 0;
for(int attempt = 0; attempt < 3; attempt++)
{
ResetLastError();
copied = CopyTicks(_Symbol, ticks, COPY_TICKS_INFO, 0, (uint)targetTicks);
lastError = GetLastError();
if(copied < 0)
{
if(lastError == 4004)
{
targetTicks = MathMax(100, targetTicks / 2);
ArrayResize(ticks, targetTicks);
continue;
}
if(lastError == 4401 || lastError == 4403)
{
BootstrapAttempts++;
if(BootstrapAttempts < 50) return false;
Print("[CodeLock] Bootstrap: tick history sync timeout. Error=", lastError);
return false;
}
Print("[CodeLock] Bootstrap: CopyTicks failed. Error=", lastError);
return false;
}
break;
}
if(copied <= 0)
{
BootstrapAttempts++;
return false;
}
int lastAttach = -1;
for(int i = 0; i < copied; i++)
if(ticks[i].time_msc <= AttachMsc)
lastAttach = i;
if(lastAttach < 0)
{
BootstrapAttempts++;
if(BootstrapAttempts >= 3)
{
Print("[CodeLock] Bootstrap: no ticks up to attach boundary. Using available history.");
BootstrapAttempts = 0;
return false;
}
return false;
}
ArrayResize(ModelTickPrices, MathMax(100, MaxModelHistoryTicks),
MathMax(100, MaxModelHistoryTicks));
ArrayResize(ModelTickAsks, MathMax(100, MaxModelHistoryTicks),
MathMax(100, MaxModelHistoryTicks));
ModelTickCount = 0;
ModelTickHead = 0;
ClearDerivedState();
for(int i = 0; i <= lastAttach; i++)
{
if(ticks[i].bid > 0.0)
ProcessBidTick(ticks[i], false, true, true);
}
int attachCount = 0;
for(int i = lastAttach; i >= 0 && ticks[i].time_msc == AttachMsc; i--)
attachCount++;
CursorMsc = AttachMsc;
CursorSameMsc = attachCount;
FinalizeTickRowsFromHistory();
if(copied < targetTicks && targetTicks < maximumTarget && BootstrapAttempts < 3)
{
HistoryBootstrapTargetTicks = MathMin(maximumTarget,
MathMax(targetTicks + 1, targetTicks * 2));
BootstrapAttempts++;
BootstrapComplete = false;
LiveMode = false;
Print("[CodeLock] Tick history partial. Requested=", targetTicks,
" Copied=", copied, " Attempt=", BootstrapAttempts,
" Next=", HistoryBootstrapTargetTicks);
return false;
}
bool derivedComplete = HistoryDerivedStateComplete();
if(!derivedComplete && targetTicks < maximumTarget && BootstrapAttempts < 3)
{
HistoryBootstrapTargetTicks = MathMin(maximumTarget,
MathMax(targetTicks + 1, targetTicks * 2));
BootstrapAttempts++;
BootstrapComplete = false;
LiveMode = false;
Print("[CodeLock] Expanding history for LAST values. Attempt=", BootstrapAttempts,
" Next=", HistoryBootstrapTargetTicks);
return false;
}
BootstrapAttempts = 0;
BootstrapComplete = true;
LiveMode = true;
ViewSpan = MathMin(MathMax(InitialViewTicks, MinViewTicks),
MathMax(1, TickCount));
ViewEndOffset = 0;
//--- Пересборка стрелок
if(ModelTickCount >= 2)
{
ArrayResize(SignalMarks, 0);
RebuildArrowSerialOverride = 0;
long savedSerial = TickSerial;
for(int i = 1; i < ModelTickCount; i++)
{
double oldBid = GetModelTickByIndex(i - 1);
double bid = GetModelTickByIndex(i);
if(oldBid <= 0.0 || bid <= 0.0 || oldBid == bid) continue;
MqlTick syntheticTick;
ZeroMemory(syntheticTick);
syntheticTick.bid = bid;
syntheticTick.ask = GetModelAskByIndex(i);
syntheticTick.time_msc = 0;
RebuildArrowSerialOverride = savedSerial - ModelTickCount + i + 1;
for(int row = 0; row < TickLevelRowCount; row++)
ProcessTickRowForRebuild(row, oldBid, bid, syntheticTick);
}
RebuildArrowSerialOverride = -1;
TickSerial = savedSerial;
}
FitInitialArrowHistory();
InitialArrowHistoryScalePending = true;
Print("[CodeLock] Bootstrap complete. ModelTicks=", ModelTickCount,
" LevelRows=", TickLevelRowCount, " Arrows=", ArraySize(SignalMarks));
return true;
}
bool ProcessLiveTicks()
{
MqlTick ticks[5000];
int requestCount = MathMin(MathMax(HistoryChunkSize, 100), 5000);
for(int chunk = 0; chunk < 20; chunk++)
{
int copied = -1;
int requestTried = requestCount;
int lastError = 0;
for(int attempt = 0; attempt < 3; attempt++)
{
ResetLastError();
copied = CopyTicks(_Symbol, ticks, COPY_TICKS_INFO,
(ulong)MathMax(1, CursorMsc), (uint)requestTried);
lastError = GetLastError();
if(copied >= 0) break;
if(lastError != 4004)
{
Print("[CodeLock] Live CopyTicks failed. Error=", lastError);
return false;
}
requestTried = MathMax(100, requestTried / 2);
}
if(copied < 0 || copied == 0)
return (copied == 0);
int start = 0;
if(ticks[0].time_msc == CursorMsc)
start = MathMin(CursorSameMsc, copied);
int processed = copied - start;
for(int i = start; i < copied; i++)
ProcessBidTick(ticks[i], true, true, true);
UpdateCursorFromArray(ticks, copied, start);
if(copied < requestTried || processed == 0)
return true;
}
return true;
}
//============================================================================
// SECTION 7A: RENDER — Canvas + viewport + scale
//============================================================================
double GetViewportLevelStepPrice()
{
double minimum = 0.0;
for(int i = 0; i < TickLevelRowCount; i++)
{
double step = (double)TickLevelRows[i].level * _Point;
if(step <= 0.0) continue;
if(minimum <= 0.0 || step < minimum) minimum = step;
}
return minimum;
}
int FloorGridForViewport(const double price)
{
double step = GetViewportLevelStepPrice();
if(step <= 0.0) return INVALID_GRID;
double position = (NormalizeDouble(price, _Digits) -
NormalizeDouble(StartPrice, _Digits)) / step;
return (int)MathFloor(position + 1.0e-9);
}
int CeilGridForViewport(const double price)
{
double step = GetViewportLevelStepPrice();
if(step <= 0.0) return INVALID_GRID;
double position = (NormalizeDouble(price, _Digits) -
NormalizeDouble(StartPrice, _Digits)) / step;
return (int)MathCeil(position - 1.0e-9);
}
double ViewportRayPrice(const int grid)
{
double step = GetViewportLevelStepPrice();
if(step <= 0.0) return 0.0;
return NormalizeDouble(StartPrice + (double)grid * step, _Digits);
}
int GetGraphWidth()
{
return MathMax(1, CanvasWidth);
}
double GetGraphLevelStepPrice()
{
if(GraphLevelsPerSide < 5) return 0.0;
return (double)GraphLevelsPerSide * _Point;
}
int GraphPriceToY(const double price)
{
if(CanvasHeight <= 1 || GraphScaleMax <= GraphScaleMin)
return CanvasHeight / 2;
int top = 0;
int bottom = MathMax(0, CanvasHeight - 1);
int drawH = MathMax(1, bottom - top);
double ratio = (GraphScaleMax - price) / (GraphScaleMax - GraphScaleMin);
ratio = MathMax(0.0, MathMin(1.0, ratio));
return top + (int)MathRound(ratio * (double)drawH);
}
int PriceToY(const double price)
{
return GraphPriceToY(price);
}
bool IsGraphPriceVisible(const double price)
{
return GraphScaleMax > GraphScaleMin &&
price >= GraphScaleMin &&
price <= GraphScaleMax;
}
double GetGraphLevelSidePriceByOffset(const double bid, const int graphLevel,
const int side, const int offset)
{
if(bid <= 0.0 || graphLevel <= 0 || (side != 1 && side != -1) || offset < 1)
return 0.0;
double step = (double)graphLevel * _Point;
if(step <= 0.0) return 0.0;
double normalizedBid = NormalizeDouble(bid, _Digits);
double position = (normalizedBid - NormalizeDouble(StartPrice, _Digits)) / step;
int baseGrid = (side > 0)
? (int)MathCeil(position - 1.0e-9)
: (int)MathFloor(position + 1.0e-9);
double basePrice = NormalizeDouble(StartPrice + (double)baseGrid * step, _Digits);
while(side > 0 && basePrice <= normalizedBid)
{
baseGrid++;
basePrice = NormalizeDouble(StartPrice + (double)baseGrid * step, _Digits);
}
while(side < 0 && basePrice > normalizedBid)
{
baseGrid--;
basePrice = NormalizeDouble(StartPrice + (double)baseGrid * step, _Digits);
}
int grid = baseGrid + ((side > 0) ? (offset - 1) : -(offset - 1));
return NormalizeDouble(StartPrice + (double)grid * step, _Digits);
}
void UpdateCurrentLevelGrid(const double bid)
{
if(bid <= 0.0) return;
if(GetViewportLevelStepPrice() <= 0.0) return;
// Заглушка
}
int GetViewStartIndex()
{
if(TickCount <= 0) return 0;
int span = ViewSpan;
if(span <= 0) span = TickCount;
span = MathMax(1, MathMin(span, TickCount));
int maxOffset = MathMax(0, TickCount - span);
int offset = MathMax(0, MathMin(ViewEndOffset, maxOffset));
return TickCount - span - offset;
}
int GetViewCount()
{
if(TickCount <= 0) return 0;
int span = ViewSpan;
if(span <= 0) span = TickCount;
return MathMax(1, MathMin(span, TickCount));
}
void UpdateSubwindowScale(const double bid)
{
if(SubWindow < 0 || bid <= 0.0 || TickLevelRowCount <= 0) return;
UpdateCurrentLevelGrid(bid);
int viewStart = GetViewStartIndex();
int viewCount = GetViewCount();
double visibleMin = bid;
double visibleMax = bid;
for(int i = 0; i < viewCount; i++)
{
double price = GetTickPriceByVisibleIndex(viewStart + i);
if(price <= 0.0) continue;
visibleMin = MathMin(visibleMin, price);
visibleMax = MathMax(visibleMax, price);
}
if(InitialArrowHistoryScalePending)
{
for(int i = 0; i < ArraySize(SignalMarks); i++)
{
if(!SignalMarks[i].reversal) continue;
if(SignalMarks[i].level != GraphLevelsPerSide) continue;
visibleMin = MathMin(visibleMin, SignalMarks[i].price);
visibleMax = MathMax(visibleMax, SignalMarks[i].price);
}
}
if(!ScaleInitialized)
{
double historyCenter = (visibleMin + visibleMax) * 0.5;
ViewportCenterPrice = NormalizeDouble(historyCenter, _Digits);
ScaleCenterGrid = FloorGridForViewport(ViewportCenterPrice);
ScaleInitialized = true;
}
double minimumStep = GetGraphLevelStepPrice();
minimumStep = MathMax(minimumStep, _Point);
int graphLevel = GraphLevelsPerSide;
int graphPerSide = MathMax(1, GraphDisplayedLevelCount);
for(int side = -1; side <= 1; side += 2)
{
double levelPrice = GetGraphLevelSidePriceByOffset(bid, graphLevel, side, graphPerSide);
if(levelPrice <= 0.0) continue;
visibleMin = MathMin(visibleMin, levelPrice);
visibleMax = MathMax(visibleMax, levelPrice);
}
double viewportCenter = (ViewportCenterPrice > 0.0) ? ViewportCenterPrice : bid;
double autoHalfRange = MathMax(MathAbs(viewportCenter - visibleMin),
MathAbs(visibleMax - viewportCenter));
double minimumHalfRange = minimumStep * 3.0;
autoHalfRange = MathMax(autoHalfRange, minimumHalfRange);
double autoPadding = MathMax(autoHalfRange * 0.05, minimumStep * 0.10);
autoHalfRange += autoPadding;
if(!VerticalScaleManual && !AutoScaleInitialized)
{
VerticalScaleHalfRange = autoHalfRange;
AutoScaleInitialized = true;
}
double scaleHalfRange = MathMax(VerticalScaleHalfRange, minimumStep * 0.20);
//--- Автосдвиг viewport при подходе к краю
if(!VerticalScaleManual && ScaleInitialized && AutoScaleInitialized &&
scaleHalfRange > minimumStep)
{
double bidOffset = bid - viewportCenter;
double followTrigger = scaleHalfRange * 0.60;
double followTarget = scaleHalfRange * 0.35;
if(bidOffset > followTrigger)
viewportCenter = bid - followTarget;
else if(bidOffset < -followTrigger)
viewportCenter = bid + followTarget;
viewportCenter = NormalizeDouble(viewportCenter, _Digits);
ViewportCenterPrice = viewportCenter;
ScaleCenterGrid = FloorGridForViewport(ViewportCenterPrice);
}
//--- FIX: гарантируем, что bid всегда внутри видимого диапазона
// (даже после zoom / drag)
if(bid < viewportCenter - scaleHalfRange)
{
viewportCenter = bid + scaleHalfRange * 0.5;
ViewportCenterPrice = NormalizeDouble(viewportCenter, _Digits);
ScaleCenterGrid = FloorGridForViewport(ViewportCenterPrice);
}
else if(bid > viewportCenter + scaleHalfRange)
{
viewportCenter = bid - scaleHalfRange * 0.5;
ViewportCenterPrice = NormalizeDouble(viewportCenter, _Digits);
ScaleCenterGrid = FloorGridForViewport(ViewportCenterPrice);
}
GraphScaleMin = NormalizeDouble(viewportCenter - scaleHalfRange, _Digits);
GraphScaleMax = NormalizeDouble(viewportCenter + scaleHalfRange, _Digits);
if(GraphScaleMax <= GraphScaleMin)
{
GraphScaleMin = viewportCenter - minimumStep;
GraphScaleMax = viewportCenter + minimumStep;
}
IndicatorSetDouble(INDICATOR_MINIMUM, GraphScaleMin);
IndicatorSetDouble(INDICATOR_MAXIMUM, GraphScaleMax);
IndicatorSetInteger(INDICATOR_FIXED_MINIMUM, true);
IndicatorSetInteger(INDICATOR_FIXED_MAXIMUM, true);
if(CanvasReady)
CanvasHeight = (int)ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS, SubWindow);
}
void FitInitialArrowHistory()
{
if(TickCount <= 0) return;
const int targetPerDirection = MathMin(20, MathMax(1, ReversalArrowsHistory));
long firstGraphSerial = MathMax(1, TickSerial - TickCount + 1);
long oldestSerial = -1;
long newestSerial = -1;
for(int direction = 0; direction < 2; direction++)
{
long cutoff = 9223372036854775807;
for(int n = 0; n < targetPerDirection; n++)
{
long best = -1;
for(int k = 0; k < ArraySize(SignalMarks); k++)
{
if(!SignalMarks[k].reversal) continue;
if(SignalMarks[k].level != GraphLevelsPerSide) continue;
bool wanted = (direction == 1) ? SignalMarks[k].up : !SignalMarks[k].up;
if(!wanted) continue;
long serial = SignalMarks[k].serial;
if(serial < firstGraphSerial || serial > TickSerial || serial >= cutoff)
continue;
if(serial > best) best = serial;
}
if(best < 0) break;
oldestSerial = (oldestSerial < 0) ? best : MathMin(oldestSerial, best);
newestSerial = (newestSerial < 0) ? best : MathMax(newestSerial, best);
cutoff = best;
}
}
if(oldestSerial < 0 || newestSerial < 0)
{
ViewSpan = MathMin(MathMax(InitialViewTicks, MinViewTicks), TickCount);
ViewEndOffset = 0;
InitialViewLayoutActive = true;
return;
}
long spanLong = newestSerial - oldestSerial + 1;
int requiredSpan = (int)MathMin((long)TickCount, spanLong);
requiredSpan = MathMax(MinViewTicks, requiredSpan);
requiredSpan = MathMin(requiredSpan, TickCount);
ViewSpan = requiredSpan;
ViewEndOffset = 0;
InitialViewLayoutActive = true;
}
bool EnsureCanvas()
{
if(SubWindow < 0) return false;
if(CanvasReady && CanvasSubWindow != SubWindow)
{
TickCanvas.Destroy();
CanvasReady = false;
CanvasWidth = 0;
CanvasHeight = 0;
CanvasSubWindow = -1;
}
int chartWidth = (int)ChartGetInteger(0, CHART_WIDTH_IN_PIXELS, 0);
int chartHeight = (int)ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS, SubWindow);
int wantedWidth = MathMax(50, chartWidth - PriceScaleWidth);
if(wantedWidth < 50 || chartHeight < 20) return false;
if(CanvasReady && CanvasWidth == wantedWidth && CanvasHeight == chartHeight)
return true;
if(CanvasReady)
{
ResetLastError();
if(!TickCanvas.Resize(wantedWidth, chartHeight))
{
TickCanvas.Destroy();
CanvasReady = false;
CanvasWidth = 0;
CanvasHeight = 0;
CanvasSubWindow = -1;
ObjectDelete(0, PANEL_PREFIX + "PANEL");
}
else
{
CanvasWidth = wantedWidth;
CanvasHeight = chartHeight;
return true;
}
}
ResetLastError();
if(!TickCanvas.CreateBitmapLabel(0, SubWindow, PANEL_PREFIX + "PANEL",
0, 0, wantedWidth, chartHeight,
COLOR_FORMAT_ARGB_NORMALIZE))
{
Print("[CodeLock] Canvas creation failed. Error=", GetLastError());
return false;
}
CanvasWidth = wantedWidth;
CanvasHeight = chartHeight;
CanvasSubWindow = SubWindow;
CanvasReady = true;
ObjectSetInteger(0, PANEL_PREFIX + "PANEL", OBJPROP_BACK, true);
ObjectSetInteger(0, PANEL_PREFIX + "PANEL", OBJPROP_SELECTABLE, false);
ObjectSetInteger(0, PANEL_PREFIX + "PANEL", OBJPROP_SELECTED, false);
ObjectSetInteger(0, PANEL_PREFIX + "PANEL", OBJPROP_HIDDEN, true);
return true;
}
//============================================================================
// SECTION 7B: RENDER — слои отрисовки
//============================================================================
void DrawDottedHorizontal(const int y, const uint clr)
{
if(!CanvasReady || CanvasWidth <= 0) return;
int graphWidth = GetGraphWidth();
for(int x = 0; x < graphWidth; x += 8)
{
int x2 = MathMin(x + 4, graphWidth - 1);
TickCanvas.Line(x, y, x2, y, clr);
}
}
void DrawArrowMark(const int x, const int y, const bool up,
const bool reversal, const color clr)
{
if(!CanvasReady) return;
uint c = ColorToARGB(clr, 255);
int size = reversal ? 7 : 5;
//--- UP — вершина выше основания; DOWN — вершина ниже основания
if(up)
TickCanvas.FillTriangle(x, y - 2 * size, x - size, y, x + size, y, c);
else
TickCanvas.FillTriangle(x, y + 2 * size, x - size, y, x + size, y, c);
}
void DrawRayLayer(const double bid)
{
if(!CanvasReady || !DrawRayObjects) return;
if(GraphScaleMax <= GraphScaleMin || TickLevelRowCount <= 0) return;
if(bid <= 0.0) return;
if(GetGraphLevelStepPrice() <= 0.0) return;
int perSide = MathMax(1, GraphDisplayedLevelCount);
int graphLevel = GraphLevelsPerSide;
for(int offset = 1; offset <= perSide; offset++)
{
for(int side = -1; side <= 1; side += 2)
{
double price = GetGraphLevelSidePriceByOffset(bid, graphLevel, side, offset);
if(price > 0.0 && IsGraphPriceVisible(price))
DrawDottedHorizontal(GraphPriceToY(price), ColorToARGB(RayColor, 185));
}
}
}
void DrawTickLayer(const double currentBid)
{
if(!CanvasReady || TickCount <= 0 || currentBid <= 0.0) return;
int viewStart = GetViewStartIndex();
int viewCount = GetViewCount();
if(viewCount <= 0) return;
uint graphColor = ColorToARGB(TickGraphColor, 255);
int graphWidth = GetGraphWidth();
int leftMargin = 0;
int drawWidth = MathMax(1, graphWidth);
if(viewCount == 1)
{
int y = GraphPriceToY(currentBid);
int x = leftMargin;
TickCanvas.LineThick(x, y, MathMin(graphWidth - 1, x + 4), y,
graphColor, 2, STYLE_SOLID, LINE_END_ROUND);
return;
}
bool havePrev = false;
int prevX = 0;
int prevY = 0;
for(int i = 0; i < viewCount; i++)
{
int x = leftMargin + (int)MathRound(
(double)i * (double)(drawWidth - 1) / (double)(viewCount - 1));
double price = GetTickPriceByVisibleIndex(viewStart + i);
if(i == viewCount - 1)
price = currentBid;
if(!IsGraphPriceVisible(price))
{
havePrev = false;
continue;
}
int y = GraphPriceToY(price);
if(havePrev)
TickCanvas.LineThick(prevX, prevY, x, y,
graphColor, 2, STYLE_SOLID, LINE_END_ROUND);
prevX = x;
prevY = y;
havePrev = true;
}
}
void DrawSignalLayer(const double bid)
{
if(!CanvasReady || TickCount <= 0 || ArraySize(SignalMarks) == 0) return;
if(bid <= 0.0) return;
if(!DrawReversalArrows) return;
long firstSerial = TickSerial - TickCount + 1;
int viewStart = GetViewStartIndex();
int viewCount = GetViewCount();
int viewEnd = viewStart + viewCount - 1;
for(int i = 0; i < ArraySize(SignalMarks); i++)
{
if(!SignalMarks[i].reversal) continue;
if(SignalMarks[i].level != GraphLevelsPerSide) continue;
long serial = SignalMarks[i].serial;
if(serial < firstSerial || serial > TickSerial) continue;
int index = (int)(serial - firstSerial);
if(index < viewStart || index > viewEnd) continue;
int relative = index - viewStart;
int drawWidth = MathMax(1, GetGraphWidth());
int x = (viewCount == 1) ? 0
: (int)MathRound((double)relative * (double)(drawWidth - 1) /
(double)(viewCount - 1));
double signalPrice = SignalMarks[i].price;
if(!IsGraphPriceVisible(signalPrice)) continue;
int y = GraphPriceToY(signalPrice);
color clr = (SignalMarks[i].up ? UpCrossColor : DownCrossColor);
DrawArrowMark(x, y, SignalMarks[i].up, true, clr);
}
}
void DrawBidMarker(const double bid)
{
if(!CanvasReady || bid <= 0.0) return;
if(GraphScaleMax <= GraphScaleMin) return;
int graphWidth = GetGraphWidth();
int rightX = MathMax(0, graphWidth - 1);
int y;
bool outOfRange = false;
if(bid > GraphScaleMax)
{
y = 0; // прижат к верхнему краю
outOfRange = true;
}
else if(bid < GraphScaleMin)
{
y = CanvasHeight - 1; // прижат к нижнему краю
outOfRange = true;
}
else
{
y = GraphPriceToY(bid);
}
//--- Цвет: обычный, если в кадре; оранжевый, если вне кадра
color markerColor = outOfRange ? clrOrange : CurrentRayColor;
uint c = ColorToARGB(markerColor, 255);
//--- Горизонтальная линия-указатель
int markerWidth = MathMin(6, graphWidth);
int markerStart = MathMax(0, rightX - markerWidth + 1);
TickCanvas.Line(markerStart, y, rightX, y, c);
//--- Треугольник (направление: вверх, если bid выше; вниз, если ниже)
if(outOfRange && bid > GraphScaleMax)
{
//--- Bid выше видимой области → стрелка вверх
TickCanvas.FillTriangle(MathMax(2, rightX - 12), y + 6,
MathMax(2, rightX - 2), y + 6,
MathMax(2, rightX - 7), y,
c);
}
else if(outOfRange && bid < GraphScaleMin)
{
//--- Bid ниже видимой области → стрелка вниз
TickCanvas.FillTriangle(MathMax(2, rightX - 12), y - 6,
MathMax(2, rightX - 2), y - 6,
MathMax(2, rightX - 7), y,
c);
}
else
{
//--- Bid в кадре → обычный треугольник влево
TickCanvas.FillTriangle(MathMax(2, rightX - 12), y - 5,
MathMax(2, rightX - 2), y,
MathMax(2, rightX - 12), y + 5, c);
}
//--- Подпись с ценой, если вне кадра
if(outOfRange)
{
string priceText = DoubleToString(bid, _Digits);
uint textWidth = 0, textHeight = 0;
TextSetFont("Segoe UI", -10 * 10, FW_BOLD);
TextGetSize(priceText, textWidth, textHeight);
int tx = MathMax(2, rightX - (int)textWidth - 6);
int ty = (bid > GraphScaleMax) ? (y + 8) : (y - (int)textHeight - 8);
TickCanvas.FontSet("Segoe UI", -10 * 10, FW_BOLD);
TickCanvas.TextOut(tx, ty, priceText, ColorToARGB(clrOrange, 255));
}
}
void DrawCurrentTickMarker(const double currentBid)
{
if(!CanvasReady || currentBid <= 0.0) return;
int graphWidth = GetGraphWidth();
int x = MathMax(0, graphWidth - 1);
int y = GraphPriceToY(currentBid);
TickCanvas.FillCircle(x, y, 3, ColorToARGB(TickGraphColor, 255));
}
//============================================================================
// SECTION 7C: RENDER — RenderGraph, zoom, drag
//============================================================================
bool IsPointInsideObject(const string name, const int x, const int y)
{
if(ObjectFind(0, name) < 0 || SubWindow < 0) return false;
int bx = (int)ObjectGetInteger(0, name, OBJPROP_XDISTANCE);
int by = (int)ObjectGetInteger(0, name, OBJPROP_YDISTANCE);
int bw = (int)ObjectGetInteger(0, name, OBJPROP_XSIZE);
int bh = (int)ObjectGetInteger(0, name, OBJPROP_YSIZE);
ENUM_BASE_CORNER corner = (ENUM_BASE_CORNER)ObjectGetInteger(0, name, OBJPROP_CORNER);
int subwindowTop = (int)ChartGetInteger(0, CHART_WINDOW_YDISTANCE, SubWindow);
int localY = y - subwindowTop;
int localX = x;
int top = by;
int left = bx;
if(corner == CORNER_LEFT_LOWER)
top = CanvasHeight - by - bh;
else if(corner == CORNER_RIGHT_UPPER || corner == CORNER_RIGHT_LOWER)
left = CanvasWidth - bx - bw;
if(corner == CORNER_RIGHT_LOWER)
top = CanvasHeight - by - bh;
return localX >= left && localX < left + bw &&
localY >= top && localY < top + bh;
}
void EnsureZoomButton(const string name, const string textValue)
{
if(ObjectFind(0, name) < 0)
{
if(!ObjectCreate(0, name, OBJ_BUTTON, SubWindow, 0, 0))
{
Print("[CodeLock] Zoom button creation failed. Error=", GetLastError(),
" Name=", name);
return;
}
ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
ObjectSetInteger(0, name, OBJPROP_XSIZE, ZoomButtonWidth);
ObjectSetInteger(0, name, OBJPROP_YSIZE, ZoomButtonHeight);
ObjectSetString (0, name, OBJPROP_TEXT, textValue);
ObjectSetString (0, name, OBJPROP_FONT, "Arial");
ObjectSetInteger(0, name, OBJPROP_FONTSIZE, 12);
ObjectSetInteger(0, name, OBJPROP_COLOR, clrWhite);
ObjectSetInteger(0, name, OBJPROP_BGCOLOR, clrDimGray);
ObjectSetInteger(0, name, OBJPROP_BORDER_COLOR, clrGray);
ObjectSetInteger(0, name, OBJPROP_BACK, false);
ObjectSetInteger(0, name, OBJPROP_STATE, false);
ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
ObjectSetInteger(0, name, OBJPROP_SELECTED, false);
ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);
ObjectSetInteger(0, name, OBJPROP_ZORDER, 120);
}
}
void EnsureResetButton(const string name, const string textValue)
{
if(ObjectFind(0, name) < 0)
{
if(!ObjectCreate(0, name, OBJ_BUTTON, SubWindow, 0, 0))
{
Print("[CodeLock] Reset button creation failed. Error=", GetLastError(),
" Name=", name);
return;
}
ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
ObjectSetInteger(0, name, OBJPROP_XSIZE, ResetButtonWidth);
ObjectSetInteger(0, name, OBJPROP_YSIZE, ZoomButtonHeight);
ObjectSetString (0, name, OBJPROP_TEXT, textValue);
ObjectSetString (0, name, OBJPROP_FONT, "Arial");
ObjectSetInteger(0, name, OBJPROP_FONTSIZE, 10);
ObjectSetInteger(0, name, OBJPROP_COLOR, clrWhite);
ObjectSetInteger(0, name, OBJPROP_BGCOLOR, clrDimGray);
ObjectSetInteger(0, name, OBJPROP_BORDER_COLOR, clrGray);
ObjectSetInteger(0, name, OBJPROP_BACK, false);
ObjectSetInteger(0, name, OBJPROP_STATE, false);
ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
ObjectSetInteger(0, name, OBJPROP_SELECTED, false);
ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);
ObjectSetInteger(0, name, OBJPROP_ZORDER, 1000);
}
}
void EnsurePanelLabel(const string name, const string textValue)
{
if(ObjectFind(0, name) >= 0 && ObjectFind(0, name) != SubWindow)
ObjectDelete(0, name);
if(ObjectFind(0, name) < 0)
{
if(!ObjectCreate(0, name, OBJ_LABEL, SubWindow, 0, 0))
{
Print("[CodeLock] Panel label creation failed. Error=", GetLastError(),
" Name=", name);
return;
}
ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
ObjectSetString (0, name, OBJPROP_FONT, "Arial");
ObjectSetInteger(0, name, OBJPROP_FONTSIZE, 9);
ObjectSetInteger(0, name, OBJPROP_COLOR, clrWhite);
ObjectSetInteger(0, name, OBJPROP_BACK, false);
ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
ObjectSetInteger(0, name, OBJPROP_SELECTED, false);
ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);
ObjectSetInteger(0, name, OBJPROP_ZORDER, 500);
}
ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
ObjectSetString (0, name, OBJPROP_TEXT, textValue);
}
void UpdateZoomButtonsLayout()
{
if(SubWindow < 0 || CanvasWidth <= 0 || CanvasHeight <= 0) return;
string minusName = PANEL_PREFIX + "ZOOM_MINUS";
string plusName = PANEL_PREFIX + "ZOOM_PLUS";
string resetName = PANEL_PREFIX + "RESET_CURRENT";
string labelName = PANEL_PREFIX + "ZOOM_LABEL";
EnsureZoomButton(minusName, "-");
EnsureZoomButton(plusName, "+");
EnsureResetButton(resetName, "RESET");
EnsurePanelLabel(labelName, "ZOOM");
int x = 8;
int y = 34;
int x1 = x;
int x2 = x + ZoomButtonWidth + ZoomButtonGap;
int x3 = x + 2 * (ZoomButtonWidth + ZoomButtonGap);
ObjectSetInteger(0, minusName, OBJPROP_XDISTANCE, x1);
ObjectSetInteger(0, minusName, OBJPROP_YDISTANCE, y);
ObjectSetInteger(0, plusName, OBJPROP_XDISTANCE, x2);
ObjectSetInteger(0, plusName, OBJPROP_YDISTANCE, y);
ObjectSetInteger(0, resetName, OBJPROP_XDISTANCE, x3);
ObjectSetInteger(0, resetName, OBJPROP_YDISTANCE, y);
ObjectSetInteger(0, resetName, OBJPROP_STATE, ResetButtonHeld);
ObjectSetInteger(0, labelName, OBJPROP_XDISTANCE,
x3 + ResetButtonWidth + ZoomButtonGap);
ObjectSetInteger(0, labelName, OBJPROP_YDISTANCE, y + 4);
}
void HandleHorizontalZoom(const int xCursor, const int delta)
{
if(TickCount <= 1 || GetGraphWidth() <= 1 || delta == 0) return;
int oldSpan = GetViewCount();
int oldStart = GetViewStartIndex();
int newSpan = oldSpan;
if(delta > 0)
newSpan = MathMax(MinViewTicks, oldSpan / 2);
else
newSpan = MathMin(MathMin(HistoryGraphTicks, TickCount),
MathMax(MinViewTicks, oldSpan * 2));
newSpan = MathMax(1, MathMin(newSpan, TickCount));
int graphWidth = GetGraphWidth();
double ratio = (double)MathMax(0, MathMin(xCursor, graphWidth - 1)) /
(double)MathMax(1, graphWidth - 1);
int anchorOffset = (int)MathRound(ratio * (double)MathMax(0, oldSpan - 1));
int anchorIndex = oldStart + anchorOffset;
ViewSpan = newSpan;
int newAnchorOffset = (int)MathRound(ratio * (double)MathMax(0, newSpan - 1));
int newStart = anchorIndex - newAnchorOffset;
newStart = MathMax(0, MathMin(newStart, TickCount - newSpan));
ViewEndOffset = TickCount - newSpan - newStart;
ViewEndOffset = MathMax(0, MathMin(ViewEndOffset, TickCount - newSpan));
}
void HandleHorizontalDrag(const int x)
{
if(!DragActive || TickCount <= 1 || GetGraphWidth() <= 1) return;
InitialViewLayoutActive = false;
int span = GetViewCount();
int dx = x - DragStartX;
int shift = (int)MathRound((double)dx * (double)span / (double)GetGraphWidth());
int maxOffset = MathMax(0, TickCount - span);
ViewEndOffset = DragStartOffset + shift;
ViewEndOffset = MathMax(0, MathMin(ViewEndOffset, maxOffset));
}
bool IsCursorInTickSubwindow(const int y)
{
if(SubWindow <= 0) return false;
int top = (int)ChartGetInteger(0, CHART_WINDOW_YDISTANCE, SubWindow);
int height = (int)ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS, SubWindow);
return height > 0 && y >= top && y < top + height;
}
void UpdateMouseScrollTarget(const int y)
{
bool inTickWindow = IsCursorInTickSubwindow(y);
if(inTickWindow != MouseInTickSubwindow)
{
MouseInTickSubwindow = inTickWindow;
ChartSetInteger(0, CHART_MOUSE_SCROLL, (long)(!inTickWindow));
}
}
bool IsCursorOnVerticalScaleHandle(const int x, const int y)
{
if(!MouseInTickSubwindow || CanvasWidth <= 0 || CanvasHeight <= 0) return false;
int chartWidth = (int)ChartGetInteger(0, CHART_WIDTH_IN_PIXELS, 0);
if(chartWidth <= CanvasWidth) return false;
return x >= CanvasWidth && x < chartWidth;
}
void BeginVerticalPanDrag(const int y)
{
VerticalPanDragActive = true;
VerticalScaleManual = true;
VerticalPanDragStartY = y;
VerticalPanDragStartCenterPrice = (ViewportCenterPrice > 0.0)
? ViewportCenterPrice
: ViewportRayPrice(ScaleCenterGrid);
}
void HandleVerticalPanDrag(const int y)
{
if(!VerticalPanDragActive || CanvasHeight <= 1) return;
if(GraphScaleMax <= GraphScaleMin) return;
int deltaY = y - VerticalPanDragStartY;
double pricePerPixel = (GraphScaleMax - GraphScaleMin) /
(double)MathMax(1, CanvasHeight - 1);
ViewportCenterPrice = NormalizeDouble(
VerticalPanDragStartCenterPrice + (double)deltaY * pricePerPixel, _Digits);
ScaleCenterGrid = FloorGridForViewport(ViewportCenterPrice);
VerticalPanDragStartY = y;
VerticalPanDragStartCenterPrice = ViewportCenterPrice;
VerticalPanDragActive = true;
RefreshGraph();
}
void EndVerticalPanDrag()
{
VerticalPanDragActive = false;
}
void BeginVerticalScaleDrag(const int y)
{
VerticalScaleDragActive = true;
VerticalScaleDragStartY = y;
VerticalScaleDragStartHalfRange = MathMax(VerticalScaleHalfRange,
GetViewportLevelStepPrice() * 0.20);
VerticalScaleManual = true;
}
void HandleVerticalScaleDrag(const int y)
{
if(!VerticalScaleDragActive) return;
double totalDeltaY = (double)(y - VerticalScaleDragStartY);
double factor = MathExp(totalDeltaY * VerticalScaleDragSensitivity);
double newHalfRange = VerticalScaleDragStartHalfRange * factor;
int upCount = MathMax(1, TickLevelRowCount / 2);
int downCount = MathMax(1, TickLevelRowCount - (TickLevelRowCount / 2));
double minimumHalfRange = GetViewportLevelStepPrice() *
MathMax(1, MathMax(upCount, downCount));
minimumHalfRange += GetViewportLevelStepPrice() * 0.10;
double maximumHalfRange = MathMax(minimumHalfRange * 2.0,
GetViewportLevelStepPrice() * 2000.0);
VerticalScaleHalfRange = MathMax(minimumHalfRange,
MathMin(maximumHalfRange, newHalfRange));
RefreshGraph();
}
void EndVerticalScaleDrag()
{
VerticalScaleDragActive = false;
}
void HandleZoomButtonClick(const string name)
{
if(name == PANEL_PREFIX + "ZOOM_MINUS" ||
name == PANEL_PREFIX + "ZOOM_PLUS")
{
InitialViewLayoutActive = false;
int delta = (name == PANEL_PREFIX + "ZOOM_PLUS") ? 1 : -1;
HandleHorizontalZoom(GetGraphWidth() / 2, delta);
RefreshGraph();
return;
}
if(name == PANEL_PREFIX + "RESET_CURRENT")
{
ResetGraphToCurrentPrice();
ResetButtonHeld = false;
RefreshGraph();
}
}
void ResetGraphToCurrentPrice()
{
if(TickCount <= 0) return;
ViewSpan = MathMin(MathMax(InitialViewTicks, MinViewTicks), TickCount);
ViewEndOffset = 0;
InitialViewLayoutActive = true;
FitInitialArrowHistory();
VerticalScaleManual = false;
VerticalScaleDragActive = false;
VerticalPanDragActive = false;
VerticalScaleHalfRange = 0.0;
AutoScaleInitialized = false;
InitialArrowHistoryScalePending = true;
MqlTick current;
if(SymbolInfoTick(_Symbol, current) && current.bid > 0.0 &&
GetViewportLevelStepPrice() > 0.0)
{
double bid = NormalizeDouble(current.bid, _Digits);
ScaleCenterGrid = FloorGridForViewport(bid);
ViewportCenterPrice = ViewportRayPrice(ScaleCenterGrid);
ScaleInitialized = true;
}
ResetButtonHeld = false;
}
void RenderGraph(const double bid)
{
if(!BootstrapComplete) return;
if(!EnsureCanvas()) return;
color background = (color)ChartGetInteger(0, CHART_COLOR_BACKGROUND, 0);
TickCanvas.Erase(ColorToARGB(background, 255));
DrawRayLayer(bid);
DrawTickLayer(bid);
DrawSignalLayer(bid);
DrawBidMarker(bid);
DrawCurrentTickMarker(bid);
TickCanvas.Update(true);
UpdateZoomButtonsLayout();
}
void RefreshGraph()
{
if(SubWindow < 0 || !BootstrapComplete) return;
MqlTick current;
if(!SymbolInfoTick(_Symbol, current) || current.bid <= 0.0) return;
if(!EnsureCanvas()) return;
UpdateSubwindowScale(current.bid);
RenderGraph(current.bid);
InitialArrowHistoryScalePending = false;
ChartRedraw(0);
}
//============================================================================
// SECTION 8A: DASHBOARD — persistence + Visual ROWS
//============================================================================
bool DashIsValidVisualLevel(const int level)
{
return (level == 5) ||
(level >= VISUAL_LEVEL_MIN &&
level <= VISUAL_LEVEL_MAX &&
(level % VISUAL_LEVEL_STEP) == 0);
}
bool DashIsStrictVisualRows()
{
if(DashVisualRowCount < MIN_VISUAL_ROWS ||
DashVisualRowCount > MAX_VISUAL_ROWS)
return false;
for(int i = 0; i < DashVisualRowCount; i++)
{
if(!DashIsValidVisualLevel(DashVisualRows[i].level)) return false;
if(i > 0 && DashVisualRows[i].level <= DashVisualRows[i-1].level) return false;
}
return true;
}
string DashVisualRowsKeyBase()
{
if(DashRowsStateKey == "")
DashRowsStateKey = STORAGE_DASH_PREFIX +
IntegerToString(ChartID()) + "_" + _Symbol;
return DashRowsStateKey;
}
void DashSaveVisualRows()
{
string base = DashVisualRowsKeyBase();
GlobalVariableSet(base + "_COUNT", (double)DashVisualRowCount);
for(int i = 0; i < DashVisualRowCount; i++)
GlobalVariableSet(base + "_R" + IntegerToString(i),
(double)DashVisualRows[i].level);
for(int i = DashVisualRowCount; i < MAX_VISUAL_ROWS; i++)
GlobalVariableDel(base + "_R" + IntegerToString(i));
//--- Сохраняем состояние ALERT (L2-fix)
for(int i = 0; i < DashVisualRowCount; i++)
GlobalVariableSet(base + "_A" + IntegerToString(i),
DashAlertEnabled[i] ? 1.0 : 0.0);
}
bool DashLoadVisualRowsFromKey(const string base)
{
if(!GlobalVariableCheck(base + "_COUNT")) return false;
int count = (int)MathRound(GlobalVariableGet(base + "_COUNT"));
if(count < 1 || count > MAX_VISUAL_ROWS) return false;
DashVisualRowCount = 0;
for(int i = 0; i < count; i++)
{
string key = base + "_R" + IntegerToString(i);
if(!GlobalVariableCheck(key)) return false;
int level = (int)MathRound(GlobalVariableGet(key));
if(!DashIsValidVisualLevel(level)) return false;
if(i > 0 && level <= DashVisualRows[i-1].level) return false;
DashVisualRows[i].level = level;
DashVisualRowCount++;
}
//--- Восстановление ALERT (L2-fix)
for(int i = 0; i < DashVisualRowCount; i++)
{
string alertKey = base + "_A" + IntegerToString(i);
DashAlertEnabled[i] = GlobalVariableCheck(alertKey)
? (GlobalVariableGet(alertKey) > 0.5)
: false;
}
return DashIsStrictVisualRows();
}
bool DashParseVisualRows(const string source)
{
string parts[];
int count = StringSplit(source, ',', parts);
if(count < MIN_VISUAL_ROWS || count > MAX_VISUAL_ROWS) return false;
DashVisualRowCount = 0;
for(int i = 0; i < count; i++)
{
string token = parts[i];
StringTrimLeft(token);
StringTrimRight(token);
if(token == "") return false;
for(int k = 0; k < StringLen(token); k++)
{
ushort ch = StringGetCharacter(token, k);
if(ch < '0' || ch > '9') return false;
}
int level = (int)StringToInteger(token);
if(!DashIsValidVisualLevel(level)) return false;
if(i > 0 && level <= DashVisualRows[i-1].level) return false;
DashVisualRows[DashVisualRowCount].level = level;
DashVisualRowCount++;
}
return DashIsStrictVisualRows();
}
bool DashEnsureFivePointVisualRow()
{
for(int i = 0; i < DashVisualRowCount; i++)
if(DashVisualRows[i].level == 5) return false;
if(DashVisualRowCount >= MAX_VISUAL_ROWS)
{
int removedLevel = DashVisualRows[DashVisualRowCount - 1].level;
DashVisualRowCount--;
Print("[CodeLock] Mandatory ROW 5pt added; highest ROW ", removedLevel,
" pt removed.");
}
for(int i = DashVisualRowCount; i > 0; i--)
DashVisualRows[i] = DashVisualRows[i-1];
DashVisualRows[0].level = 5;
DashVisualRowCount++;
return true;
}
void DashLoadVisualRows()
{
if(!DashLoadVisualRowsFromKey(DashVisualRowsKeyBase()))
{
if(!DashParseVisualRows(InitialVisualRows))
{
if(!DashParseVisualRows(DEFAULT_VISUAL_ROWS))
{
Print("[CodeLock] Failed to load Visual ROWS");
return;
}
Print("[CodeLock] InitialVisualRows invalid; using default");
}
}
if(DashEnsureFivePointVisualRow())
DashSaveVisualRows();
}
void SyncTickVisualRowsFromDashboard()
{
if(DashVisualRowCount < MIN_VISUAL_ROWS ||
DashVisualRowCount > MAX_VISUAL_ROWS)
return;
bool changed = (TickLevelRowCount != DashVisualRowCount);
if(!changed)
{
for(int i = 0; i < DashVisualRowCount; i++)
{
if(TickLevelRows[i].level != DashVisualRows[i].level)
{
changed = true;
break;
}
}
}
if(!changed) return;
bool savedAlert[MAX_VISUAL_ROWS];
int savedMax = MathMax(TickLevelRowCount, DashVisualRowCount);
for(int i = 0; i < savedMax && i < MAX_VISUAL_ROWS; i++)
savedAlert[i] = DashAlertEnabled[i];
ArrayResize(TickLevelRows, DashVisualRowCount);
TickLevelRowCount = DashVisualRowCount;
for(int i = 0; i < DashVisualRowCount; i++)
{
TickLevelRows[i].level = DashVisualRows[i].level;
ResetTickLevelRowState(TickLevelRows[i]);
}
for(int i = 0; i < TickLevelRowCount; i++)
{
if(i < savedMax)
{
DashAlertEnabled[i] = savedAlert[i];
TickLevelRows[i].alertEnabled = savedAlert[i];
}
}
if(ModelTickCount >= 2)
{
HistoryBootstrapTargetTicks = MathMax(HistoryBootstrapTargetTicks, ModelTickCount);
BootstrapComplete = false;
LiveMode = false;
}
}
//============================================================================
// SECTION 8B: DASHBOARD — GUI таблицы
//============================================================================
int DashColLevelX = 12;
int DashColStatusX = 0;
int DashColTriggerX = 0;
int DashColAlertX = 0;
int DashColGraphicX = 0;
int DashColLastDown2X = 0;
int DashColLastDown1X = 0;
int DashColLastUp2X = 0;
int DashColLastUp1X = 0;
int DashAutoPanelWidth = 0;
int DashLevelButtonWidth = 72;
int DashRowsButtonWidth = 27;
int DashRowsValueWidth = 48;
int DashMeasureTextWidth(const string text)
{
static bool fontReady = false;
if(!fontReady)
{
TextSetFont("Segoe UI", -DashboardFontSize * 10, FW_NORMAL);
fontReady = true;
}
uint width = 0, height = 0;
if(!TextGetSize(text, width, height))
return MathMax(1, StringLen(text) * DashboardFontSize);
return (int)width;
}
void DashCalculateAutoLayout()
{
int levelWidth = DashMeasureTextWidth("100000 pt");
int statusWidth = DashMeasureTextWidth("DIRECTION");
int triggerWidth = DashMeasureTextWidth("REVERSAL AT");
int alertWidth = DashMeasureTextWidth("ALERT") + 16;
int graphicWidth = DashMeasureTextWidth("GRAPHIC") + 16;
int lastWidth = DashMeasureTextWidth("LAST-DOWN-2");
lastWidth = MathMax(lastWidth, DashMeasureTextWidth("00000.00000"));
lastWidth = MathMax(lastWidth, DashMeasureTextWidth("LAST-UP-1"));
int gap = 5;
DashColLevelX = 12;
DashLevelButtonWidth = MathMax(66, levelWidth + 12);
DashColStatusX = DashColLevelX + DashLevelButtonWidth + gap;
DashColTriggerX = DashColStatusX + statusWidth + gap;
DashColAlertX = DashColTriggerX + triggerWidth + gap;
DashColGraphicX = DashColAlertX + alertWidth + gap;
DashColLastDown2X = DashColGraphicX + graphicWidth + gap;
DashColLastDown1X = DashColLastDown2X + lastWidth + gap;
DashColLastUp2X = DashColLastDown1X + lastWidth + gap;
DashColLastUp1X = DashColLastUp2X + lastWidth + gap;
DashAutoPanelWidth = DashColLastUp1X + lastWidth + 24;
}
void DashEnsureRect(const string name, const int x, const int y,
const int width, const int height,
const color background, const color border)
{
if(ObjectFind(0, name) < 0)
{
if(!ObjectCreate(0, name, OBJ_RECTANGLE_LABEL, 0, 0, 0))
{
Print("[CodeLock] Dashboard rect creation failed. Error=", GetLastError(),
" Name=", name);
return;
}
ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
ObjectSetInteger(0, name, OBJPROP_SELECTED, false);
ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);
ObjectSetInteger(0, name, OBJPROP_BACK, false);
}
ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x);
ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y);
ObjectSetInteger(0, name, OBJPROP_XSIZE, width);
ObjectSetInteger(0, name, OBJPROP_YSIZE, height);
ObjectSetInteger(0, name, OBJPROP_BGCOLOR, background);
ObjectSetInteger(0, name, OBJPROP_COLOR, border);
ObjectSetInteger(0, name, OBJPROP_BORDER_TYPE, BORDER_FLAT);
ObjectSetInteger(0, name, OBJPROP_ZORDER, 100);
}
void DashEnsureLabel(const string name, const int x, const int y,
const int fontSize, const color textColor,
const string textValue)
{
if(ObjectFind(0, name) < 0)
{
if(!ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0))
{
Print("[CodeLock] Dashboard label creation failed. Error=", GetLastError(),
" Name=", name);
return;
}
ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
ObjectSetString (0, name, OBJPROP_FONT, "Segoe UI");
ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
ObjectSetInteger(0, name, OBJPROP_SELECTED, false);
ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);
ObjectSetInteger(0, name, OBJPROP_ZORDER, 110);
}
ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x);
ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y);
ObjectSetInteger(0, name, OBJPROP_FONTSIZE, fontSize);
ObjectSetInteger(0, name, OBJPROP_COLOR, textColor);
ObjectSetString (0, name, OBJPROP_TEXT, textValue);
}
void DashEnsureButton(const string name, const int x, const int y,
const int width, const int height,
const string textValue,
const color background, const color border,
const color textColor, const long zorder = 150)
{
if(ObjectFind(0, name) < 0)
{
if(!ObjectCreate(0, name, OBJ_BUTTON, 0, 0, 0))
{
Print("[CodeLock] Dashboard button creation failed. Error=", GetLastError(),
" Name=", name);
return;
}
ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
ObjectSetInteger(0, name, OBJPROP_SELECTED, false);
ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);
ObjectSetInteger(0, name, OBJPROP_ZORDER, zorder);
ObjectSetString (0, name, OBJPROP_FONT, "Segoe UI");
}
ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x);
ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y);
ObjectSetInteger(0, name, OBJPROP_XSIZE, width);
ObjectSetInteger(0, name, OBJPROP_YSIZE, height);
ObjectSetInteger(0, name, OBJPROP_FONTSIZE, DashboardFontSize);
ObjectSetInteger(0, name, OBJPROP_BGCOLOR, background);
ObjectSetInteger(0, name, OBJPROP_BORDER_COLOR, border);
ObjectSetInteger(0, name, OBJPROP_COLOR, textColor);
ObjectSetString (0, name, OBJPROP_TEXT, textValue);
}
void DashDeleteHiddenRows(const int visibleCount)
{
for(int i = visibleCount; i < MAX_VISUAL_ROWS; i++)
{
string sfx = IntegerToString(i);
ObjectDelete(0, DASH_PREFIX + "ROW_" + sfx);
ObjectDelete(0, DASH_PREFIX + "STATEBAR_" + sfx);
ObjectDelete(0, DASH_PREFIX + "LEVEL_" + sfx);
ObjectDelete(0, DASH_PREFIX + "STATE_" + sfx);
ObjectDelete(0, DASH_PREFIX + "TRIGGER_" + sfx);
ObjectDelete(0, DASH_PREFIX + "ALERT_" + sfx);
ObjectDelete(0, DASH_PREFIX + "GRAPHIC_" + sfx);
ObjectDelete(0, DASH_PREFIX + "LAST_DOWN_2_" + sfx);
ObjectDelete(0, DASH_PREFIX + "LAST_DOWN_1_" + sfx);
ObjectDelete(0, DASH_PREFIX + "LAST_UP_2_" + sfx);
ObjectDelete(0, DASH_PREFIX + "LAST_UP_1_" + sfx);
ObjectDelete(0, DASH_PREFIX + "EDIT_" + sfx);
}
}
color DashStatusColor(const int direction)
{
if(direction > 0) return UpColor;
if(direction < 0) return DownColor;
return WaitColor;
}
string DashStatusText(const int direction)
{
if(direction > 0) return "UP";
if(direction < 0) return "DOWN";
return "WAIT";
}
void DashSetAlertButtonState(const int index)
{
if(index < 0 || index >= MAX_VISUAL_ROWS) return;
string name = DASH_PREFIX + "ALERT_" + IntegerToString(index);
if(ObjectFind(0, name) < 0) return;
bool enabled = DashAlertEnabled[index];
ulong now = (ulong)GetTickCount();
bool activity = (DashAlertActivityUntil[index] > now);
color buttonColor = activity ? AlertActivityColor
: (enabled ? AlertOnColor : AlertOffColor);
ObjectSetInteger(0, name, OBJPROP_BGCOLOR, buttonColor);
ObjectSetInteger(0, name, OBJPROP_COLOR, AlertTextColor);
ObjectSetInteger(0, name, OBJPROP_BORDER_COLOR,
activity ? AlertActivityColor
: (enabled ? AlertOnColor : BorderColor));
ObjectSetString (0, name, OBJPROP_TEXT, "ALERT");
ObjectSetInteger(0, name, OBJPROP_STATE, enabled);
}
void DashUpdateAlertButton(const int index, const int x, const int y,
const int width, const int height)
{
string name = DASH_PREFIX + "ALERT_" + IntegerToString(index);
if(ObjectFind(0, name) < 0)
{
if(!ObjectCreate(0, name, OBJ_BUTTON, 0, 0, 0))
{
Print("[CodeLock] Alert button creation failed. Error=", GetLastError(),
" Name=", name);
return;
}
ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
ObjectSetInteger(0, name, OBJPROP_SELECTED, false);
ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);
ObjectSetInteger(0, name, OBJPROP_ZORDER, 140);
ObjectSetString (0, name, OBJPROP_FONT, "Segoe UI");
}
ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x);
ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y);
ObjectSetInteger(0, name, OBJPROP_XSIZE, width);
ObjectSetInteger(0, name, OBJPROP_YSIZE, height);
ObjectSetInteger(0, name, OBJPROP_FONTSIZE, DashboardFontSize);
DashSetAlertButtonState(index);
}
void DashUpdateGraphicButton(const int index, const int x, const int y,
const int width, const int height)
{
string name = DASH_PREFIX + "GRAPHIC_" + IntegerToString(index);
if(ObjectFind(0, name) < 0)
{
if(!ObjectCreate(0, name, OBJ_BUTTON, 0, 0, 0))
{
Print("[CodeLock] Graphic button creation failed. Error=", GetLastError(),
" Name=", name);
return;
}
ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
ObjectSetInteger(0, name, OBJPROP_SELECTED, false);
ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);
ObjectSetInteger(0, name, OBJPROP_ZORDER, 140);
ObjectSetString (0, name, OBJPROP_FONT, "Segoe UI");
}
bool selected = (index < DashVisualRowCount &&
DashVisualRows[index].level == GraphLevelsPerSide);
ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x);
ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y);
ObjectSetInteger(0, name, OBJPROP_XSIZE, width);
ObjectSetInteger(0, name, OBJPROP_YSIZE, height);
ObjectSetInteger(0, name, OBJPROP_FONTSIZE, DashboardFontSize);
ObjectSetInteger(0, name, OBJPROP_BGCOLOR, selected ? HeaderColor : C'42,50,64');
ObjectSetInteger(0, name, OBJPROP_BORDER_COLOR, selected ? HeaderColor : BorderColor);
ObjectSetInteger(0, name, OBJPROP_COLOR, TextColor);
ObjectSetString (0, name, OBJPROP_TEXT, "GRAPHIC");
ObjectSetInteger(0, name, OBJPROP_STATE, selected);
}
void DashRenderDashboard(const double bid)
{
if(DashVisualRowCount < 1) return;
int levelCount = DashVisualRowCount;
DashCalculateAutoLayout();
int panelHeight = HeaderHeight + 8 + levelCount * RowHeight + 12;
int panelX = MathMax(4, PanelLeftMargin);
int panelY = MathMax(4, PanelTopMargin);
DashEnsureRect(DASH_PREFIX + "BG", panelX, panelY,
DashAutoPanelWidth, panelHeight,
PanelBackground, BorderColor);
DashEnsureRect(DASH_PREFIX + "HEADER", panelX + 2, panelY + 2,
DashAutoPanelWidth - 4, HeaderHeight - 4,
PanelBackground, PanelBackground);
int titleWidth = DashMeasureTextWidth("DASHBOARD");
int titleX = panelX + (DashAutoPanelWidth - titleWidth) / 2;
DashEnsureLabel(DASH_PREFIX + "TITLE", titleX, panelY + 6,
DashboardFontSize, TextColor, "DASHBOARD");
int bidWidth = DashMeasureTextWidth("BID " + DoubleToString(bid, _Digits));
DashEnsureLabel(DASH_PREFIX + "BID",
panelX + DashAutoPanelWidth - bidWidth - 16, panelY + 8,
DashboardFontSize, HeaderColor,
"BID " + DoubleToString(bid, _Digits));
int headerY = panelY + HeaderHeight - 20;
DashEnsureLabel(DASH_PREFIX + "COL_LEVEL", panelX + DashColLevelX, headerY,
DashboardFontSize, MutedTextColor, "LEVEL");
DashEnsureLabel(DASH_PREFIX + "COL_STATUS", panelX + DashColStatusX, headerY,
DashboardFontSize, MutedTextColor, "DIRECTION");
DashEnsureLabel(DASH_PREFIX + "COL_TRIGGER", panelX + DashColTriggerX, headerY,
DashboardFontSize, MutedTextColor, "REVERSAL AT");
DashEnsureLabel(DASH_PREFIX + "COL_ALERT", panelX + DashColAlertX, headerY,
DashboardFontSize, MutedTextColor, "ALERT");
DashEnsureLabel(DASH_PREFIX + "COL_GRAPHIC", panelX + DashColGraphicX, headerY,
DashboardFontSize, MutedTextColor, "GRAPHIC");
DashEnsureLabel(DASH_PREFIX + "COL_LAST_DOWN_2", panelX + DashColLastDown2X, headerY,
DashboardFontSize, MutedTextColor, "LAST-DOWN-2");
DashEnsureLabel(DASH_PREFIX + "COL_LAST_DOWN_1", panelX + DashColLastDown1X, headerY,
DashboardFontSize, MutedTextColor, "LAST-DOWN-1");
DashEnsureLabel(DASH_PREFIX + "COL_LAST_UP_2", panelX + DashColLastUp2X, headerY,
DashboardFontSize, MutedTextColor, "LAST-UP-2");
DashEnsureLabel(DASH_PREFIX + "COL_LAST_UP_1", panelX + DashColLastUp1X, headerY,
DashboardFontSize, MutedTextColor, "LAST-UP-1");
for(int row = 0; row < levelCount; row++)
{
int index = levelCount - 1 - row;
int y = panelY + HeaderHeight + 8 + row * RowHeight;
string sfx = IntegerToString(index);
int direction = TickLevelRows[index].direction;
DashEnsureRect(DASH_PREFIX + "ROW_" + sfx, panelX + 2, y,
DashAutoPanelWidth - 4, RowHeight - 1,
(row % 2 == 0) ? RowBackground : RowBackgroundAlt,
BorderColor);
DashEnsureRect(DASH_PREFIX + "STATEBAR_" + sfx, panelX + 3, y + 2,
5, RowHeight - 5,
DashStatusColor(direction), DashStatusColor(direction));
DashEnsureButton(DASH_PREFIX + "LEVEL_" + sfx,
panelX + DashColLevelX, y + 1,
DashLevelButtonWidth, RowHeight - 3,
IntegerToString(TickLevelRows[index].level) + " pt",
RowBackground, BorderColor,
DashStatusColor(direction), 1100);
DashEnsureLabel(DASH_PREFIX + "STATE_" + sfx,
panelX + DashColStatusX, y + 3,
DashboardFontSize, DashStatusColor(direction),
DashStatusText(direction));
string reversalAtText = (TickLevelRows[index].direction != 0 &&
TickLevelRows[index].reversalAtPrice > 0.0)
? DoubleToString(TickLevelRows[index].reversalAtPrice, _Digits)
: "";
int reversalDir = (direction != 0) ? -direction : 0;
DashEnsureLabel(DASH_PREFIX + "TRIGGER_" + sfx,
panelX + DashColTriggerX, y + 3,
DashboardFontSize, DashStatusColor(reversalDir),
reversalAtText);
DashUpdateAlertButton(index, panelX + DashColAlertX, y + 1,
DashMeasureTextWidth("ALERT") + 16, RowHeight - 3);
DashUpdateGraphicButton(index, panelX + DashColGraphicX, y + 1,
DashMeasureTextWidth("GRAPHIC") + 16, RowHeight - 3);
string ld2 = (TickLevelRows[index].lastDown2Price > 0.0)
? DoubleToString(TickLevelRows[index].lastDown2Price, _Digits) : "";
string ld1 = (TickLevelRows[index].lastDown1Price > 0.0)
? DoubleToString(TickLevelRows[index].lastDown1Price, _Digits) : "";
string lu2 = (TickLevelRows[index].lastUp2Price > 0.0)
? DoubleToString(TickLevelRows[index].lastUp2Price, _Digits) : "";
string lu1 = (TickLevelRows[index].lastUp1Price > 0.0)
? DoubleToString(TickLevelRows[index].lastUp1Price, _Digits) : "";
DashEnsureLabel(DASH_PREFIX + "LAST_DOWN_2_" + sfx,
panelX + DashColLastDown2X, y + 3,
DashboardFontSize, DownColor, ld2);
DashEnsureLabel(DASH_PREFIX + "LAST_DOWN_1_" + sfx,
panelX + DashColLastDown1X, y + 3,
DashboardFontSize, DownColor, ld1);
DashEnsureLabel(DASH_PREFIX + "LAST_UP_2_" + sfx,
panelX + DashColLastUp2X, y + 3,
DashboardFontSize, UpColor, lu2);
DashEnsureLabel(DASH_PREFIX + "LAST_UP_1_" + sfx,
panelX + DashColLastUp1X, y + 3,
DashboardFontSize, UpColor, lu1);
}
DashDeleteHiddenRows(levelCount);
}
//============================================================================
// SECTION 8C: DASHBOARD — обработчики кликов
//============================================================================
bool DashIsAlertButtonName(const string name, int &stateIndex)
{
string prefix = DASH_PREFIX + "ALERT_";
if(StringFind(name, prefix) != 0) return false;
string sfx = StringSubstr(name, StringLen(prefix));
if(sfx == "") return false;
int index = (int)StringToInteger(sfx);
if(index < 0 || index >= MAX_VISUAL_ROWS) return false;
stateIndex = index;
return true;
}
bool DashIsGraphicButtonName(const string name, int &stateIndex)
{
string prefix = DASH_PREFIX + "GRAPHIC_";
if(StringFind(name, prefix) != 0) return false;
string sfx = StringSubstr(name, StringLen(prefix));
if(sfx == "") return false;
int index = (int)StringToInteger(sfx);
if(index < 0 || index >= MAX_VISUAL_ROWS) return false;
stateIndex = index;
return true;
}
void DashToggleAlert(const int index)
{
if(index < 0 || index >= MAX_VISUAL_ROWS) return;
DashAlertEnabled[index] = !DashAlertEnabled[index];
if(index < TickLevelRowCount)
TickLevelRows[index].alertEnabled = DashAlertEnabled[index];
DashAlertActivityUntil[index] = 0;
Print("[CodeLock] ALERT ", TickLevelRows[index].level, " pt ",
(DashAlertEnabled[index] ? "ON" : "OFF"));
//--- Сохраняем состояние ALERT
DashSaveVisualRows();
DashSetAlertButtonState(index);
ChartRedraw(0);
}
void DashSelectGraphicLevel(const int index)
{
if(index < 0 || index >= DashVisualRowCount) return;
int selectedLevel = DashVisualRows[index].level;
if(selectedLevel < 5) return;
//--- FIX: используем точное значение selectedLevel
GraphLevelsPerSide = MathMax(5, selectedLevel);
//--- Добавляем уровень в DashVisualRows, если его там нет
bool exists = false;
for(int i = 0; i < DashVisualRowCount; i++)
{
if(DashVisualRows[i].level == GraphLevelsPerSide)
{
exists = true;
break;
}
}
if(!exists && DashVisualRowCount < MAX_VISUAL_ROWS)
{
DashVisualRows[DashVisualRowCount].level = GraphLevelsPerSide;
DashVisualRowCount++;
//--- сортировка не нужна: GraphLevelsPerSide уже существует в таблице
// (индекс — это строка, по которой кликнули)
}
//--- Пересобираем TickLevelRows из DashVisualRows
ArrayResize(TickLevelRows, DashVisualRowCount);
TickLevelRowCount = DashVisualRowCount;
for(int i = 0; i < DashVisualRowCount; i++)
{
TickLevelRows[i].level = DashVisualRows[i].level;
ResetTickLevelRowState(TickLevelRows[i]);
if(i < MAX_VISUAL_ROWS)
TickLevelRows[i].alertEnabled = DashAlertEnabled[i];
}
if(ModelTickCount >= 2)
{
HistoryBootstrapTargetTicks = MathMax(HistoryBootstrapTargetTicks, ModelTickCount);
BootstrapComplete = false;
LiveMode = false;
}
ResetGraphToCurrentPrice();
RefreshGraph();
DashRenderDashboard(SymbolInfoDouble(_Symbol, SYMBOL_BID));
}
void DashBeginLevelEdit(const int index, const int x, const int y,
const int width, const int height)
{
if(index < 0 || index >= DashVisualRowCount) return;
if(DashEditingRow >= 0 && DashEditingRow != index)
ObjectDelete(0, DASH_PREFIX + "EDIT_" + IntegerToString(DashEditingRow));
string name = DASH_PREFIX + "EDIT_" + IntegerToString(index);
if(ObjectFind(0, name) < 0)
{
if(!ObjectCreate(0, name, OBJ_EDIT, 0, 0, 0))
{
Print("[CodeLock] Level edit creation failed. Error=", GetLastError());
return;
}
ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);
ObjectSetInteger(0, name, OBJPROP_ZORDER, 180);
ObjectSetString (0, name, OBJPROP_FONT, "Segoe UI");
ObjectSetInteger(0, name, OBJPROP_ALIGN, ALIGN_CENTER);
ObjectSetInteger(0, name, OBJPROP_READONLY, false);
}
ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x);
ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y);
ObjectSetInteger(0, name, OBJPROP_XSIZE, width);
ObjectSetInteger(0, name, OBJPROP_YSIZE, height);
ObjectSetInteger(0, name, OBJPROP_FONTSIZE, DashboardFontSize);
ObjectSetInteger(0, name, OBJPROP_COLOR, TextColor);
ObjectSetInteger(0, name, OBJPROP_BGCOLOR, PanelBackground);
ObjectSetInteger(0, name, OBJPROP_BORDER_COLOR, HeaderColor);
ObjectSetString (0, name, OBJPROP_TEXT, IntegerToString(DashVisualRows[index].level));
DashEditingRow = index;
ChartRedraw(0);
}
void DashCancelLevelEdit()
{
if(DashEditingRow < 0) return;
ObjectDelete(0, DASH_PREFIX + "EDIT_" + IntegerToString(DashEditingRow));
DashEditingRow = -1;
ChartRedraw(0);
}
bool DashValidateEditedLevel(const int index, const int newLevel)
{
if(index < 0 || index >= DashVisualRowCount) return false;
if(!DashIsValidVisualLevel(newLevel)) return false;
if(index > 0 && newLevel <= DashVisualRows[index-1].level) return false;
if(index + 1 < DashVisualRowCount && newLevel >= DashVisualRows[index+1].level) return false;
return true;
}
void DashCommitEditedLevel(const int index, const string text)
{
if(index < 0 || index >= DashVisualRowCount)
{
DashCancelLevelEdit();
return;
}
if(text == "")
{
Print("[CodeLock] LEVEL edit rejected: empty value");
DashCancelLevelEdit();
return;
}
for(int k = 0; k < StringLen(text); k++)
{
ushort ch = StringGetCharacter(text, k);
if(ch < '0' || ch > '9')
{
Print("[CodeLock] LEVEL edit rejected: use 5 or 10..2000 step 10");
DashCancelLevelEdit();
return;
}
}
int newLevel = (int)StringToInteger(text);
if(!DashValidateEditedLevel(index, newLevel))
{
Print("[CodeLock] LEVEL edit rejected: ", text,
" (strict order violated)");
DashCancelLevelEdit();
return;
}
DashVisualRows[index].level = newLevel;
DashSaveVisualRows();
DashCancelLevelEdit();
SyncTickVisualRowsFromDashboard();
Print("[CodeLock] Visual ROW ", index, " LEVEL = ", newLevel, " pt");
}
bool DashAddVisualRow(const int index)
{
if(index < 0 || index >= DashVisualRowCount ||
DashVisualRowCount >= MAX_VISUAL_ROWS) return false;
int current = DashVisualRows[index].level;
int upper = (index + 1 < DashVisualRowCount)
? DashVisualRows[index + 1].level
: (VISUAL_LEVEL_MAX + VISUAL_LEVEL_STEP);
//--- FIX: шаг +10, выравнивание по VISUAL_LEVEL_STEP
int candidate = current + VISUAL_LEVEL_STEP;
if(candidate < VISUAL_LEVEL_MIN && current >= 5)
candidate = VISUAL_LEVEL_MIN;
if(candidate % VISUAL_LEVEL_STEP != 0)
candidate = ((candidate / VISUAL_LEVEL_STEP) + 1) * VISUAL_LEVEL_STEP;
while(candidate < upper && candidate > current)
{
bool free = true;
for(int i = 0; i < DashVisualRowCount; i++)
if(DashVisualRows[i].level == candidate) { free = false; break; }
if(free)
{
for(int i = DashVisualRowCount; i > index + 1; i--)
DashVisualRows[i] = DashVisualRows[i-1];
DashVisualRows[index + 1].level = candidate;
DashVisualRowCount++;
DashSaveVisualRows();
SyncTickVisualRowsFromDashboard();
Print("[CodeLock] Added ROW ", candidate, " pt");
return true;
}
candidate += VISUAL_LEVEL_STEP;
}
Print("[CodeLock] Cannot add ROW after ", current, " pt");
return false;
}
bool DashDeleteVisualRow(const int index)
{
if(index < 0 || index >= DashVisualRowCount) return false;
if(DashVisualRows[index].level == 5)
{
Print("[CodeLock] Cannot delete mandatory ROW 5 pt");
return false;
}
if(DashVisualRowCount <= MIN_VISUAL_ROWS)
{
Print("[CodeLock] At least ", MIN_VISUAL_ROWS, " ROWS required");
return false;
}
int removed = DashVisualRows[index].level;
for(int i = index; i < DashVisualRowCount - 1; i++)
DashVisualRows[i] = DashVisualRows[i+1];
DashVisualRowCount--;
DashSaveVisualRows();
SyncTickVisualRowsFromDashboard();
Print("[CodeLock] Deleted ROW ", removed, " pt");
return true;
}
void DashChartEvent(const int id, const long &lparam, const double &dparam,
const string &sparam)
{
if(id == CHARTEVENT_KEYDOWN && DashEditingRow >= 0 && lparam == KEY_ESCAPE_CODE)
{
DashCancelLevelEdit();
return;
}
if(id == CHARTEVENT_OBJECT_ENDEDIT)
{
string editPrefix = DASH_PREFIX + "EDIT_";
if(StringFind(sparam, editPrefix) == 0)
{
int index = (int)StringToInteger(StringSubstr(sparam, StringLen(editPrefix)));
string textValue = "";
if(ObjectGetString(0, sparam, OBJPROP_TEXT, 0, textValue))
DashCommitEditedLevel(index, textValue);
else
DashCancelLevelEdit();
return;
}
}
if(id != CHARTEVENT_OBJECT_CLICK) return;
if(StringFind(sparam, DASH_PREFIX) != 0) return;
int graphicIndex = -1;
if(DashIsGraphicButtonName(sparam, graphicIndex))
{
DashSelectGraphicLevel(graphicIndex);
return;
}
int alertIndex = -1;
if(DashIsAlertButtonName(sparam, alertIndex))
{
DashToggleAlert(alertIndex);
return;
}
string levelPrefix = DASH_PREFIX + "LEVEL_";
if(StringFind(sparam, levelPrefix) == 0)
{
int index = (int)StringToInteger(StringSubstr(sparam, StringLen(levelPrefix)));
if(index >= 0 && index < DashVisualRowCount)
{
string rowName = DASH_PREFIX + "ROW_" + IntegerToString(index);
int y = (ObjectFind(0, rowName) >= 0)
? (int)ObjectGetInteger(0, rowName, OBJPROP_YDISTANCE)
: PanelTopMargin + HeaderHeight + 8;
DashBeginLevelEdit(index,
(int)ObjectGetInteger(0, sparam, OBJPROP_XDISTANCE),
y + 1, DashLevelButtonWidth, RowHeight - 3);
}
return;
}
}
//============================================================================
// SECTION 9: MAIN — OnInit / OnDeinit / OnCalculate / OnTimer / OnChartEvent
//============================================================================
int OnInit()
{
GraphLevelsPerSide = InpGraphLevelsPerSide;
GraphDisplayedLevelCount = InpGraphDisplayedLevelCount;
if(StartPrice <= 0.0 || BufferPoints < 0)
{
Print("[CodeLock] Invalid StartPrice or BufferPoints");
return INIT_PARAMETERS_INCORRECT;
}
if(ReversalArrowsHistory < 0 || ReversalArrowsHistory > 20)
{
Print("[CodeLock] ReversalArrowsHistory 0..20");
return INIT_PARAMETERS_INCORRECT;
}
if(MaxModelHistoryTicks < 100 || HistoryGraphTicks < 100 || HistoryBootstrapTicks < 100)
{
Print("[CodeLock] History parameters must be >= 100");
return INIT_PARAMETERS_INCORRECT;
}
//--- FIX: инициализация SubWindow ДО любых операций с Canvas
SubWindow = ChartWindowFind(0, "CodeLock");
if(SubWindow < 0)
{
//--- fallback: используем 0 (главное окно), Canvas создастся в главном
SubWindow = 0;
Print("[CodeLock] Warning: subwindow not found, using main window");
}
//--- Загружаем Visual ROWS (Dashboard)
DashLoadVisualRows();
if(!DashIsStrictVisualRows())
{
Print("[CodeLock] Invalid DashVisualRows");
return INIT_PARAMETERS_INCORRECT;
}
//--- Синхронизируем TickLevelRows с DashVisualRows
TickLevelRowCount = DashVisualRowCount;
ArrayResize(TickLevelRows, TickLevelRowCount);
for(int i = 0; i < TickLevelRowCount; i++)
{
TickLevelRows[i].level = DashVisualRows[i].level;
ResetTickLevelRowState(TickLevelRows[i]);
TickLevelRows[i].alertEnabled = DashAlertEnabled[i];
}
//--- Прикрепляемся к рынку
MqlTick attachTick;
if(!SymbolInfoTick(_Symbol, attachTick) || attachTick.bid <= 0.0)
{
Print("[CodeLock] Cannot get initial tick");
return INIT_FAILED;
}
AttachMsc = attachTick.time_msc;
CursorMsc = AttachMsc;
CursorSameMsc = 0;
//--- Подготовка массивов
ArrayResize(TickPrices, MathMax(100, HistoryGraphTicks), MathMax(100, HistoryGraphTicks));
ArrayResize(ModelTickPrices, MathMax(100, MaxModelHistoryTicks), MathMax(100, MaxModelHistoryTicks));
ArrayResize(ModelTickAsks, MathMax(100, MaxModelHistoryTicks), MathMax(100, MaxModelHistoryTicks));
ArrayResize(SignalMarks, 0);
ModelTickCount = 0;
ModelTickHead = 0;
TickCount = 0;
TickHead = 0;
TickSerial = 0;
HavePreviousBid = false;
PreviousBid = 0.0;
BootstrapComplete = false;
LiveMode = false;
//--- Viewport
ScaleInitialized = false;
AutoScaleInitialized = false;
VerticalScaleManual = false;
VerticalScaleHalfRange = 0.0;
ViewSpan = MathMin(MathMax(InitialViewTicks, MinViewTicks), HistoryGraphTicks);
ViewEndOffset = 0;
InitialViewLayoutActive = true;
InitialArrowHistoryScalePending = true;
DragActive = false;
DragStartX = 0;
DragStartOffset = 0;
MouseInTickSubwindow = false;
ResetButtonHeld = false;
//--- Мышь
PreviousChartMouseScroll = (bool)ChartGetInteger(0, CHART_MOUSE_SCROLL);
ChartSetInteger(0, CHART_MOUSE_SCROLL, true);
ChartSetInteger(0, CHART_EVENT_MOUSE_MOVE, true);
ChartSetInteger(0, CHART_EVENT_MOUSE_WHEEL, true);
//--- Таймер
int timerMs = MathMax(10, MathMin(2000, UpdateIntervalMs));
if(!EventSetMillisecondTimer(timerMs))
{
Print("[CodeLock] EventSetMillisecondTimer failed. Error=", GetLastError());
return INIT_FAILED;
}
Print("[CodeLock] Init OK. Rows=", TickLevelRowCount,
" GraphLevel=", GraphLevelsPerSide,
" GraphPerSide=", GraphDisplayedLevelCount,
" SubWindow=", SubWindow);
return INIT_SUCCEEDED;
}
void OnDeinit(const int reason)
{
Print("[CodeLock] Deinit. Reason=", reason);
EventKillTimer();
ChartSetInteger(0, CHART_MOUSE_SCROLL, (long)PreviousChartMouseScroll);
if(CanvasReady)
{
TickCanvas.Destroy();
CanvasReady = false;
}
ObjectsDeleteAll(0, DASH_PREFIX);
ObjectsDeleteAll(0, PANEL_PREFIX);
}
int OnCalculate(const int rates_total,
const int prev_calculated,
const datetime &time[],
const double &open[],
const double &high[],
const double &low[],
const double &close[],
const long &tick_volume[],
const long &volume[],
const int &spread[])
{
if(rates_total < 10) return rates_total;
if(!BootstrapComplete)
{
if(!BootstrapHistory())
return rates_total;
}
else
{
if(!ProcessLiveTicks())
return rates_total;
}
MqlTick current;
if(SymbolInfoTick(_Symbol, current) && current.bid > 0.0)
{
if(EnsureCanvas())
{
UpdateSubwindowScale(current.bid);
RenderGraph(current.bid);
InitialArrowHistoryScalePending = false;
}
}
ChartRedraw(0);
return rates_total;
}
void OnTimer()
{
if(SubWindow < 0)
{
SubWindow = ChartWindowFind(0, "CodeLock");
if(SubWindow < 0) return;
}
SyncTickVisualRowsFromDashboard();
if(!BootstrapComplete)
{
if(!BootstrapHistory())
return;
}
else
{
if(!ProcessLiveTicks())
return;
}
MqlTick current;
if(!SymbolInfoTick(_Symbol, current) || current.bid <= 0.0) return;
if(EnsureCanvas())
{
UpdateSubwindowScale(current.bid);
RenderGraph(current.bid);
InitialArrowHistoryScalePending = false;
}
DashRenderDashboard(current.bid);
ChartRedraw(0);
}
void OnChartEvent(const int id,
const long &lparam,
const double &dparam,
const string &sparam)
{
DashChartEvent(id, lparam, dparam, sparam);
if(id == CHARTEVENT_OBJECT_CLICK)
{
if(sparam == PANEL_PREFIX + "ZOOM_MINUS" ||
sparam == PANEL_PREFIX + "ZOOM_PLUS" ||
sparam == PANEL_PREFIX + "RESET_CURRENT")
{
HandleZoomButtonClick(sparam);
return;
}
}
if(id == CHARTEVENT_MOUSE_WHEEL)
{
int flags = (int)(lparam >> 32);
int xCur = (int)(short)lparam;
int yCur = (int)(short)(lparam >> 16);
UpdateMouseScrollTarget(yCur);
if(!MouseInTickSubwindow) return;
InitialViewLayoutActive = false;
if((flags & 0x0004) != 0)
{
int span = GetViewCount();
int step = MathMax(1, span / 10);
int maxOffset = MathMax(0, TickCount - span);
ViewEndOffset += (dparam > 0.0 ? -step : step);
ViewEndOffset = MathMax(0, MathMin(ViewEndOffset, maxOffset));
}
else
{
HandleHorizontalZoom(xCur, (int)dparam);
}
RefreshGraph();
return;
}
if(id == CHARTEVENT_MOUSE_MOVE)
{
int x = (int)lparam;
int y = (int)dparam;
int state = (int)StringToInteger(sparam);
bool leftDown = ((state & 1) != 0);
UpdateMouseScrollTarget(y);
if(!MouseInTickSubwindow)
DragActive = false;
if(VerticalScaleDragActive)
{
if(leftDown)
{
ChartSetInteger(0, CHART_MOUSE_SCROLL, false);
HandleVerticalScaleDrag(y);
DragActive = false;
VerticalPanDragActive = false;
return;
}
EndVerticalScaleDrag();
UpdateMouseScrollTarget(y);
}
else if(VerticalPanDragActive)
{
if(leftDown)
{
ChartSetInteger(0, CHART_MOUSE_SCROLL, false);
HandleVerticalPanDrag(y);
DragActive = false;
return;
}
EndVerticalPanDrag();
UpdateMouseScrollTarget(y);
}
if(leftDown && MouseInTickSubwindow &&
IsCursorOnVerticalScaleHandle(x, y))
{
BeginVerticalScaleDrag(y);
HandleVerticalScaleDrag(y);
DragActive = false;
VerticalPanDragActive = false;
return;
}
if(leftDown && MouseInTickSubwindow &&
IsPointInsideObject(PANEL_PREFIX + "RESET_CURRENT", x, y))
{
ResetButtonHeld = true;
ObjectSetInteger(0, PANEL_PREFIX + "RESET_CURRENT", OBJPROP_STATE, true);
}
else if(!leftDown)
{
ResetButtonHeld = false;
if(ObjectFind(0, PANEL_PREFIX + "RESET_CURRENT") >= 0)
ObjectSetInteger(0, PANEL_PREFIX + "RESET_CURRENT", OBJPROP_STATE, false);
}
if(leftDown && MouseInTickSubwindow && !ResetButtonHeld)
{
if(!DragActive && !VerticalPanDragActive)
{
if(!PointerDragTracking)
{
PointerDragTracking = true;
DragStartX = x;
DragStartOffset = ViewEndOffset;
VerticalPanDragStartY = y;
}
int dx = x - DragStartX;
int dy = y - VerticalPanDragStartY;
if(MathAbs((double)dy) > MathAbs((double)dx) && MathAbs(dy) >= 4)
{
BeginVerticalPanDrag(y);
DragActive = false;
HandleVerticalPanDrag(y);
return;
}
if(MathAbs(dx) >= 4)
DragActive = true;
}
if(VerticalPanDragActive)
{
HandleVerticalPanDrag(y);
return;
}
if(DragActive)
{
HandleHorizontalDrag(x);
RefreshGraph();
}
}
else if(!leftDown || !MouseInTickSubwindow)
{
DragActive = false;
PointerDragTracking = false;
EndVerticalPanDrag();
}
return;
}
if(id == CHARTEVENT_CHART_CHANGE)
{
static int lastPeriod = (int)_Period;
bool periodChanged = ((int)_Period != lastPeriod);
lastPeriod = (int)_Period;
int currentSubWindow = ChartWindowFind(0, "CodeLock");
if(currentSubWindow >= 0)
SubWindow = currentSubWindow;
else
return;
if(periodChanged)
{
ViewSpan = MathMin(MathMax(InitialViewTicks, MinViewTicks),
MathMax(1, TickCount));
ViewEndOffset = 0;
InitialViewLayoutActive = true;
FitInitialArrowHistory();
}
if(!BootstrapComplete) return;
MqlTick current;
if(SymbolInfoTick(_Symbol, current) && current.bid > 0.0)
{
if(EnsureCanvas())
{
UpdateSubwindowScale(current.bid);
RenderGraph(current.bid);
InitialArrowHistoryScalePending = false;
}
}
ChartRedraw(0);
}
}
//+------------------------------------------------------------------+
Reference in a new issueCopy permalink