# SetIndexVisibility

Sets the visibility of a buffer **programmatically** based on custom indicator logic.

## Syntax

```typescript
SetIndexVisibility(index: number, isVisible: boolean): void
```

## Parameters

* `index` - A number representing the index of the buffer.
* `isVisible` - A boolean indicating whether the buffer should be visible.

## Return Value

This method does not return a value.

## Description

The `SetIndexVisibility` method allows your indicator to **programmatically control** buffer visibility based on custom logic, calculations, or indicator states. This is **NOT** for basic user preferences (users already have built-in checkboxes for that), but for **algorithmic decisions** where the indicator itself determines what should be displayed.

## When to Use SetIndexVisibility

### ✅ Use SetIndexVisibility For:

* **State-based indicators** - show different buffers for different market states
* **Conditional logic** - only show certain buffers when specific conditions are met
* **Mutually exclusive displays** - show one buffer OR another, never both
* **Data-driven visibility** - hide buffers when data is invalid or insufficient
* **Dynamic switching** - change what's visible based on calculations

### ❌ Don't Use SetIndexVisibility For:

* **Basic user preferences** - users have built-in checkboxes for this
* **Simple on/off toggles** - the built-in visibility controls handle this
* **Initial visibility setup** in [`Init()`](/fto-indicators-docs/indicators/indicator-structure/init.md) (use [`SetIndexStyle`](/fto-indicators-docs/configure_indicator/set-index-style.md) instead)

## SetIndexVisibility vs Built-in Controls

### Built-in User Controls (Checkboxes)

Users can already control basic visibility:

* ✅ "Show/Hide Main Line"
* ✅ "Show/Hide Signal Line"
* ✅ Basic on/off toggles

### SetIndexVisibility (Custom Logic)

Use for intelligent, condition-based visibility:

* ✅ Show uptrend buffer OR downtrend buffer (never both)
* ✅ Hide signal when market is ranging
* ✅ Show different buffers for different timeframes
* ✅ Display warning buffer only when conditions are dangerous

## Practical Examples

### Example 1: State-Based Indicator (Trend vs Range)

```typescript
export default class TrendRangeIndicator extends IndicatorImplementation {
  public trendBuffer!: TIndexBuffer;
  public rangeBuffer!: TIndexBuffer;
  private isInTrend: boolean = false;

  public Calculate(index: number): void {
    // Determine market state
    this.isInTrend = this.calculateTrendState(index);

    if (this.isInTrend) {
      // Show trend buffer, hide range buffer
      this.api.SetIndexVisibility(0, true); // Trend buffer
      this.api.SetIndexVisibility(1, false); // Range buffer

      this.trendBuffer.setValue(index, this.calculateTrendValue(index));
    } else {
      // Show range buffer, hide trend buffer
      this.api.SetIndexVisibility(0, false); // Trend buffer
      this.api.SetIndexVisibility(1, true); // Range buffer

      this.rangeBuffer.setValue(index, this.calculateRangeValue(index));
    }
  }
}
```

### Example 2: Conditional Signal Display

```typescript
export default class SmartSignalIndicator extends IndicatorImplementation {
  public mainBuffer!: TIndexBuffer;
  public warningBuffer!: TIndexBuffer;
  public signalBuffer!: TIndexBuffer;

  public Calculate(index: number): void {
    const mainValue = this.calculateMainValue(index);
    this.mainBuffer.setValue(index, mainValue);

    // Only show warning when market is volatile
    const volatility = this.calculateVolatility(index);
    if (volatility > 2.0) {
      this.api.SetIndexVisibility(1, true); // Show warning
      this.warningBuffer.setValue(index, mainValue);
    } else {
      this.api.SetIndexVisibility(1, false); // Hide warning
    }

    // Only show signals when conditions are optimal
    const signalStrength = this.calculateSignalStrength(index);
    if (signalStrength > 0.8 && volatility < 1.5) {
      this.api.SetIndexVisibility(2, true); // Show signal
      this.signalBuffer.setValue(index, this.generateSignal(index));
    } else {
      this.api.SetIndexVisibility(2, false); // Hide signal
    }
  }
}
```

### Example 3: Timeframe-Dependent Display

```typescript
export default class MultiTimeframeIndicator extends IndicatorImplementation {
  public shortTermBuffer!: TIndexBuffer;
  public longTermBuffer!: TIndexBuffer;

  public OnParamsChange(): void {
    const currentTimeframe = this.api.Timeframe();

    if (currentTimeframe <= 60) {
      // 1 hour or less
      // Show short-term analysis
      this.api.SetIndexVisibility(0, true); // Short-term buffer
      this.api.SetIndexVisibility(1, false); // Long-term buffer
    } else {
      // Show long-term analysis
      this.api.SetIndexVisibility(0, false); // Short-term buffer
      this.api.SetIndexVisibility(1, true); // Long-term buffer
    }
  }
}
```

### Example 4: Data Quality Control

```typescript
export default class QualityControlIndicator extends IndicatorImplementation {
  public reliableBuffer!: TIndexBuffer;
  public unreliableBuffer!: TIndexBuffer;

  public Calculate(index: number): void {
    const dataQuality = this.assessDataQuality(index);
    const calculatedValue = this.performCalculation(index);

    if (dataQuality > 0.9) {
      // High quality data - show reliable buffer
      this.api.SetIndexVisibility(0, true); // Reliable buffer
      this.api.SetIndexVisibility(1, false); // Unreliable buffer
      this.reliableBuffer.setValue(index, calculatedValue);
    } else {
      // Low quality data - show unreliable buffer with warning style
      this.api.SetIndexVisibility(0, false); // Reliable buffer
      this.api.SetIndexVisibility(1, true); // Unreliable buffer
      this.unreliableBuffer.setValue(index, calculatedValue);
    }
  }
}
```

## Common Use Cases

1. **Mutually Exclusive States**: Show buffer A OR buffer B, never both
2. **Conditional Signals**: Only display signals when market conditions are suitable
3. **Quality Control**: Hide unreliable data, show only when confidence is high
4. **Mode Switching**: Different displays for different market modes (trend/range/volatile)
5. **Error Handling**: Hide buffers when calculations are invalid or insufficient data
6. **Performance Optimization**: Hide complex buffers during high-frequency updates

## Key Rules

1. **SetIndexVisibility** = Algorithmic decisions by the indicator
2. **Built-in checkboxes** = User preferences and basic on/off controls
3. **Use for intelligent logic**, not simple user toggles
4. **Perfect for state machines** and conditional displays
5. **Great for data quality control** and error handling


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://fto-2.gitbook.io/fto-indicators-docs/configure_indicator/set-index-visibility.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.