vtkSMViewLayoutProxy.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkSMViewLayoutProxy_h
#define vtkSMViewLayoutProxy_h

#include "vtkRemotingViewsModule.h" //needed for exports
#include "vtkSMProxy.h"
#include "vtkVector.h" // needed for vtkVector2i
#include <vector>      // needed for std::vector.

class vtkSMViewProxy;
class vtkImageData;

class VTKREMOTINGVIEWS_EXPORT vtkSMViewLayoutProxy : public vtkSMProxy
{
public:
  static vtkSMViewLayoutProxy* New();
  vtkTypeMacro(vtkSMViewLayoutProxy, vtkSMProxy);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  enum Direction
  {
    NONE,
    VERTICAL,
    HORIZONTAL
  };

  int Split(int location, int direction, double fraction);
  int SplitVertical(int location, double fraction)
  {
    return this->Split(location, VERTICAL, fraction);
  }
  int SplitHorizontal(int location, double fraction)
  {
    return this->Split(location, HORIZONTAL, fraction);
  }

  bool AssignView(int location, vtkSMViewProxy* view);

  int AssignViewToAnyCell(vtkSMViewProxy* view, int location_hint);


  int RemoveView(vtkSMViewProxy* view);
  bool RemoveView(int index);

  bool Collapse(int location);

  bool SwapCells(int location1, int location2);

  bool SetSplitFraction(int location, double fraction);

  bool EqualizeViews();

  bool EqualizeViews(Direction direction);

  bool MaximizeCell(int location);

  void RestoreMaximizedState();


  vtkGetMacro(MaximizedCell, int);

  bool IsSplitCell(int location);

  Direction GetSplitDirection(int location);

  double GetSplitFraction(int location);

  static int GetFirstChild(int location) { return 2 * location + 1; }

  static int GetSecondChild(int location) { return 2 * location + 2; }

  static int GetParent(int location) { return (location > 0 ? ((location - 1) / 2) : -1); }

  vtkSMViewProxy* GetView(int location);

  int GetViewLocation(vtkSMViewProxy*);


  bool ContainsView(vtkSMViewProxy* view) { return this->GetViewLocation(view) != -1; }
  bool ContainsView(vtkSMProxy* view);

  void UpdateViewPositions();

  void ShowViewsOnTileDisplay();


  vtkImageData* CaptureWindow(int magnification)
  {
    return this->CaptureWindow(magnification, magnification);
  }
  vtkImageData* CaptureWindow(int magnificationX, int magnificationY);

  vtkPVXMLElement* SaveXMLState(vtkPVXMLElement* root) override
  {
    return this->Superclass::SaveXMLState(root);
  }
  vtkPVXMLElement* SaveXMLState(vtkPVXMLElement* root, vtkSMPropertyIterator* iter) override;

  int LoadXMLState(vtkPVXMLElement* element, vtkSMProxyLocator* locator) override;

  void Reset();

  void GetLayoutExtent(int extent[4]);


  void SetSize(const int size[2]);
  void SetSize(int width, int height)
  {
    const int size[] = { width, height };
    this->SetSize(size);
  }

  vtkVector2i GetSize()
  {
    int extent[4];
    this->GetLayoutExtent(extent);
    return vtkVector2i(extent[1] - extent[0] + 1, extent[3] - extent[2] + 1);
  }

  static vtkSMViewLayoutProxy* FindLayout(vtkSMViewProxy*, const char* reggroup = "layouts");

  std::vector<vtkSMViewProxy*> GetViews();


  void SaveAsPNG(int rank, const char* fname);

protected:
  vtkSMViewLayoutProxy();
  ~vtkSMViewLayoutProxy() override;

  void LoadState(const vtkSMMessage* message, vtkSMProxyLocator* locator) override;

  virtual void UpdateState();

  int GetEmptyCell(int root);

  int GetSplittableCell(int root, Direction& suggested_direction);

  int ComputeSteadySplitFraction(int location, Direction direction);

  int MaximizedCell;

private:
  vtkSMViewLayoutProxy(const vtkSMViewLayoutProxy&) = delete;
  void operator=(const vtkSMViewLayoutProxy&) = delete;

  class vtkInternals;
  vtkInternals* Internals;

  bool SetBlockUpdate(bool new_value)
  {
    bool temp = this->BlockUpdate;
    this->BlockUpdate = new_value;
    return temp;
  }

  bool BlockUpdate;

  bool SetBlockUpdateViewPositions(bool val)
  {
    bool temp = this->BlockUpdateViewPositions;
    this->BlockUpdateViewPositions = val;
    return temp;
  }
  bool BlockUpdateViewPositions;
};

#endif