# 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()`](https://fto-2.gitbook.io/fto-indicators-docs/indicators/indicator-structure/init) (use [`SetIndexStyle`](https://fto-2.gitbook.io/fto-indicators-docs/configure_indicator/set-index-style) 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