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