bec-widgets 0.99.1__py3-none-any.whl → 0.99.9__py3-none-any.whl

docs/user/customisation.md

@@ -1,123 +0,0 @@
-(user.customisation)=
-# Customisation
-
-## Leveraging BEC Widgets in custom GUI applications
-
-BEC Widgets can be used to compose a complete Qt graphical application, along with
-other QWidgets. The only requirement is to connect to BEC servers in order to get
-data, or to interact with BEC components. This role is devoted to the BECDispatcher,
-a singleton object which has to be instantiated **after the QApplication is created**.
-
-A typical BEC Widgets custom application "main" entry point should follow the template
-below: 
-
-```
-import argparse
-import sys
-
-from bec_widgets.utils.bec_dispatcher import BECDispatcher
-from qtpy.QtWidgets import QApplication
-
-# optional command line arguments processing
-parser = argparse.ArgumentParser(description="...")
-parser.add_argument( ...)
-...
-args = parser.parse_args()
-
-# creation of the Qt application
-app = QApplication([])
-
-# creation of BEC Dispatcher
-# /!\ important: after the QApplication has been instantiated
-bec_dispatcher = BECDispatcher()
-client = bec_dispatcher.client
-client.start()
-
-# (optional) processing of command line args,
-# creation of a main window depending on the command line arguments (or not)
-if args.xxx == "...":
-    window = ...
- 
-# display of the main window and start of Qt event loop
-window.show()
-sys.exit(app.exec())
-```
-
-The main "window" object presents the layout of widgets to the user and allows
-users to interact. BEC Widgets must be placed in the window:
-
-```
-from qtpy.QWidgets import QMainWindow
-from bec_widgets.widgets.figure import BECFigure
-
-window = QMainWindow()
-bec_figure = BECFigure(gui_id="my_gui_app_id")
-window.setCentralWidget(bec_figure)
-
-# prepare to plot samx motor vs bpm4i value
-bec_figure.plot(x_name="samx", y_name="bpm4i")
-```
-
-In the example just above, the resulting application will show a plot of samx
-positions on the horizontal axis, and beam intensity on the vertical axis
-(when the next scan will be started).
-
-It is important to ensure proper cleanup of the resources is done when application
-quits:
-
-```
-def final_cleanup():
-    bec_figure.clear_all()
-    bec_figure.client.shutdown()
-
-window.aboutToQuit.connect(final_cleanup)
-```
-
-Final example:
-
-```
-import sys
-from qtpy.QtWidgets import QMainWindow, QApplication
-from bec_widgets.widgets.figure import BECFigure
-from bec_widgets.utils.bec_dispatcher import BECDispatcher
-
-# creation of the Qt application
-app = QApplication([])
-
-# creation of BEC Dispatcher
-bec_dispatcher = BECDispatcher()
-client = bec_dispatcher.client
-client.start()
-
-# creation of main window
-window = QMainWindow()
-
-# inserting BEC Widgets
-bec_figure = BECFigure(parent=window, gui_id="my_gui_app_id")
-window.setCentralWidget(bec_figure)
-
-bec_figure.plot(x_name="samx", y_name="bpm4i")
-
-# ensuring proper cleanup
-def final_cleanup():
-    bec_figure.clear_all()
-    bec_figure.client.shutdown()
-
-app.aboutToQuit.connect(final_cleanup)
-
-# execution
-window.show()
-sys.exit(app.exec())
-```
-
-## Writing applications using Qt Designer
-
-BEC Widgets are designed to be used with QtDesigner to quickly design GUI.
-
-## Example of promoting widgets in Qt Designer
-
-_Work in progress_
-
-## Implementation of plugins into Qt Designer
-
-_Work in progress_

docs/user/getting_started/auto_updates.md

@@ -1,82 +0,0 @@
-(user.auto_updates)=
-# Auto updates
-BEC Widgets provides a simple way to update the entire GUI configuration based on events. These events can be of different types, such as a new scan being started or completed, a button being pressed, a device reporting an error or the existence of a specific metadata key. This allows the users to streamline the experience of the GUI and to focus on the data and the analysis, rather than on the GUI itself.
-
-The default auto update only takes control over a single `BECFigure` widget, which is automatically added to the GUI instance. The update instance is accessible via the `bec.gui.auto_updates` object. The user can disable / enable the auto updates by setting the `enabled` attribute of the `bec.gui.auto_updates` object, e.g. 
-
-```python
-bec.gui.auto_updates.enabled = False
-```
-
-Without further customization, the auto update will automatically update the `BECFigure` widget based on the currently performed scan. The behaviour is determined by the `handler` method of the `AutoUpdate` class: 
-
-````{dropdown} Auto Updates Handler
-:icon: code-square
-:animate: fade-in-slide-down
-:open: 
-```{literalinclude} ../../../bec_widgets/cli/auto_updates.py
-:pyobject: AutoUpdates.handler
-```
-````
-
-As shown, the default handler switches between different scan names and updates the `BECFigure` widget accordingly. If the scan is a line scan, the `simple_line_scan` update method is executed. 
-
-````{dropdown} Auto Updates Simple Line Scan
-:icon: code-square
-:animate: fade-in-slide-down
-:open: 
-```{literalinclude} ../../../bec_widgets/cli/auto_updates.py
-:pyobject: AutoUpdates.simple_line_scan
-```
-````
-
-As it can be seen from the above snippet, the update method gets the default figure by calling the `get_default_figure` method. If the figure is not found, maybe because the user has deleted or closed it, no update is performed. If the figure is found, the scan info is used to extract the first reported device for the x axis and the first device of the monitored devices for the y axis. The y axis can also be set by the user using the `selected_device` attribute:
-
-```python
-bec.gui.auto_updates.selected_device = 'bpm4i'
-```
-
-
-````{dropdown} Auto Updates Code
-:icon: code-square
-:animate: fade-in-slide-down
-```{literalinclude} ../../../bec_widgets/cli/auto_updates.py
-```
-````
-
-## Custom Auto Updates
-The beamline can customize their default behaviour through customized auto update classes. This can be achieved by modifying the class located in the beamline plugin repository: `<beamline_plugin>/bec_widgets/auto_updates.py`. The class should inherit from the `AutoUpdates` class and overwrite the `handler` method. 
-
-```python
-from bec_widgets.cli.auto_updates import AutoUpdates, ScanInfo
-
-
-class PlotUpdate(AutoUpdates):
-    create_default_dock = True
-    enabled = True
-
-    # def simple_line_scan(self, info: ScanInfo) -> None:
-    #     """
-    #     Simple line scan.
-    #     """
-    #     fig = self.get_default_figure()
-    #     if not fig:
-    #         return
-    #     dev_x = info.scan_report_devices[0]
-    #     dev_y = self.get_selected_device(info.monitored_devices, self.gui.selected_device)
-    #     if not dev_y:
-    #         return
-    #     fig.clear_all()
-    #     plt = fig.plot(x_name=dev_x, y_name=dev_y)
-    #     plt.set(title=f"Custom Plot {info.scan_number}", x_label=dev_x, y_label=dev_y)
-
-    def handler(self, info: ScanInfo) -> None:
-        # EXAMPLES:
-        # if info.scan_name == "line_scan" and info.scan_report_devices:
-        #     self.simple_line_scan(info)
-        #     return
-        # if info.scan_name == "grid_scan" and info.scan_report_devices:
-        #     self.run_grid_scan_update(info)
-        #     return
-        super().handler(info)
-```

docs/user/getting_started/getting_started.md

@@ -1,15 +0,0 @@
-(user.getting_started)=
-# Getting Started
-This section provides a comprehensive guide to getting started with BEC Widgets. Whether you are new to BEC Widgets or looking to refresh your knowledge, this guide will help you set up and navigate the framework with ease.
-
-```{toctree}
----
-maxdepth: 2
-hidden: true
----
-
-installation/
-quick_start/
-auto_updates/
-video_tutorials/
-```

docs/user/getting_started/installation.md

@@ -1,33 +0,0 @@
-(user.installation)=
-# Installation
-**Prerequisites**
-
-Before installing BEC Widgets, please ensure the following requirements are met:
-
-1. **Python Version:** BEC Widgets requires Python version 3.10 or higher. Verify your Python version to ensure compatibility.
-2. **BEC Installation:** BEC Widgets works in conjunction with BEC. While BEC is a dependency and will be installed automatically, you can find more information about BEC and its installation process in the [BEC documentation](https://beamline-experiment-control.readthedocs.io/en/latest/).
-
-**Standard Installation**
-
-To install BEC Widgets using the pip package manager, execute the following command in your terminal for getting the default PyQT6 version into your python environment for BEC:
-
-
-```bash
-pip install 'bec_widgets[pyqt6]'
-```
-
-In case you want to use Pyside6, you can install it by using the following command:
-
-```bash
-pip install 'bec_widgets[pyside6]'
-```
-
-**Troubleshooting**
-
-If you encounter issues during installation, particularly with PyQt, try purging the pip cache:
-
-```bash
-pip cache purge
-```
-
-This can resolve conflicts or issues with package installations.

docs/user/getting_started/quick_start.md

@@ -1,110 +0,0 @@
-(user.command_line_introduction)=
-# Quick start
-In order to use BEC Widgets as a plotting tool for BEC, it needs to be [installed](#user.installation) in the same Python environment as the BEC IPython client (please refer to the [BEC documentation](https://bec.readthedocs.io/en/latest/user/command_line_interface.html#start-up) for more details). Upon startup, the client will automatically launch a GUI and store it as a `bec.gui` object in the client. The GUI backend will also be automatically connect to the BEC server, giving access to all information on the server and allowing the user to visualize the data in real-time.
-
-## BECDockArea
-The `bec.gui` object is your entry point to BEC Widgets. It is a [`BECDockArea`](/api_reference/_autosummary/bec_widgets.cli.client.BECDockArea) instance that can be composed of multiple [`BECDock`](/api_reference/_autosummary/bec_widgets.cli.client.BECDock)s that can be attached / detached to the main area. These docks allow users to freely arrange and customize the widgets they add to the gui, providing a flexible and customizable interface to visualize data. 
-
-**Schema of the BECDockArea**
-
-![BECDockArea.png](BECDockArea.png)
-
-## Widgets
-Widgets are the building blocks of the BEC Widgets framework. They are the visual components that allow users to interact with the data and control the behavior of the application. Each dock can contain multiple widgets, albeit we recommend for most use cases a single widget per dock. BEC Widgets provides a set of core widgets (cf. [widgets](#user.widgets)). More widgets can be added by the users, and we invite you to explore the [developer documentation](developer.widgets) to learn how to create custom widgets.
-For the introduction given here, we will focus on the `BECFigure` widget, as it is the most commonly used widget for visualizing data from BEC. The same access pattern can be used for all other widgets.
-
-**BECFigure**
-
-The [`BECFigure`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure) widget is one of the core widgets developed for BEC and can be used to visualize different plot types, such as [1D waveforms](user.widgets.waveform_1d), [2D scatter plots](user.widgets.scatter_2d), [position maps](user.widgets.motor_map) and [2D images](user.widgets.image_2d). 
-If BEC Widgets is installed, the default behaviour of BEC is to automatically add a BECFigure Widget to the existing GUI instance. This widget is directly accessible via the `fig` object from the client. Moreover, a best-effort attempt is made to automatically determine the best plot type based on the currently performed scan. This behaviour can be changed or disabled by the user. For more details, please refer to the [auto update](user.auto_updates) section.
-
-<!-- We also provide two methods [`plot()`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.plot), [`image()`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.image) and [`motor_map()`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.motor_map) as shortcuts to add a plot, image or motor map to the BECFigure. -->
-
-**Waveform Plot** 
-
- The [`BECWaveForm`](/api_reference/_autosummary/bec_widgets.cli.client.BECWaveform) is a widget that can be used to visualize 1D waveform data, i.e. to plot data of a monitor against a motor position. The method [`plot()`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.plot) of BECFigure adds a BECWaveForm widget to the figure, and returns the plot object. 
-
-```python
-plt = fig.plot(x_name='samx', y_name='bpm4i')
-```
-Here, we create a new plot with a subscription to the devices `samx` and `bpm4i` and assign the plot to the object `plt`. We can now use this object to further customize the plot, e.g. changing the title ([`set_title()`](/api_reference/_autosummary/bec_widgets.cli.client.BECWaveform.rst#bec_widgets.cli.client.BECWaveform.set_title)), axis labels ([`set_x_label()`](/api_reference/_autosummary/bec_widgets.cli.client.BECWaveform.rst#bec_widgets.cli.client.BECWaveform.set_x_label)) or limits ([`set_x_lim()`](/api_reference/_autosummary/bec_widgets.cli.client.BECWaveform.rst#bec_widgets.cli.client.BECWaveform.set_x_lim)). We invite you to explore the API of the BECWaveForm in the [documentation](user.widgets.waveform_1d) or directly in the command line.
-
-To plot custom data, i.e. data that is not directly available through a scan in BEC, we can use the same method, but provide the data directly to the plot. 
-
-```python
-plt = fig.plot([1,2,3,4], [1,4,9,16])
-# or 
-plt = fig.plot(x=[1,2,3,4], y=[1,4,9,16])
-# or 
-plt = fig.plot(x=np.array([1,2,3,4]), y=np.array([1,4,9,16]))
-# or 
-plt = fig.plot(np.random.rand(10,2))
-```
-
-**Scatter Plot**
-
-The [`BECWaveForm`](/api_reference/_autosummary/bec_widgets.cli.client.BECWaveForm) widget can also be used to visualize 2D scatter plots. More details on setting up the scatter plot are available in the widget documentation of the [scatter plot](user.widgets.scatter_2d).
-
-**Motor Map**
-
-The [`BECMotorMap`](/api_reference/_autosummary/bec_widgets.cli.client.BECMotorMap) widget can be used to visualize the position of motors. It's focused on tracking and visualizing the position of motors, crucial for precise alignment and movement tracking during scans. More details on setting up the motor map are available in the widget documentation of the [motor map](user.widgets.motor_map).
-
-**Image Plot**
-
-The [`BECImageItem`](/api_reference/_autosummary/bec_widgets.cli.client.BECImageItem) widget can be used to visualize 2D image data for example a camera. More details on setting up the image plot are available in the widget documentation of the [image plot](user.widgets.image).
-
-### Useful Commands
-We recommend users to explore the API of the widgets by themselves since we assume that the user interface is supposed to be intuitive and self-explanatory. We appreciate feedback from user in order to constantly improve the experience and allow easy access to the gui, widgets and their functionality. We recommend checking the [API documentation](user.api_reference), but also by using BEC Widgets, exploring the available functions and check their dockstrings.
-```python
-gui.add_dock? # shows the dockstring of the add_dock method
-```
-
-In addition, we list below a few useful commands that can be used to interface with the widgets:
-
-```python
-gui.panels # returns a dictionary of all docks in the gui
-gui.add_dock() # adds a new dock to the gui
-
-dock = gui.panels['dock_2']
-dock.add_widget('BECFigure') # adds a new widget of BECFigure to the dock
-dock.widget_list # returns a list of all widgets in the dock
-
-figure = dock.widget_list[0] # assigns the created BECFigure to figure
-plt = figure.plot(x_name='samx', y_name='bpm4i') # adds a BECWaveForm plot to the figure
-plt.curves # returns a list of all curves in the plot
-```
-
-We note that commands can also be chained. For example, `gui.add_dock().add_widget('BECFigure')` will add a new dock to the gui and add a new widget of `BECFigure` to the dock. 
-
-## Composing a larger GUI
-The example given above introduces BEC Widgets with its different components, and provides an overview of how to interact with the widgets. Nevertheless, another power aspect of BEC Widgets lies in the ability to compose a larger GUI with multiple docks and widgets. This section aims to provide a tutorial like guide on how to compose a more complex GUI that (A) live-plots a 1D waveform, (B) plots data from a camera, and (C) tracks the positions of two motors.
-Let's assume BEC was just started and the `gui` object is available in the client. A single dock is already attached together with a BEC Figure. Let's add the 1D waveform to this dock, change the color of the line to white and add the title *1D Waveform* to the plot.
-
-```python
-plt = fig.plot(x_name='samx', y_name='bpm4i')
-plt.curves[0].set_color(color="white")
-plt.set_title('1D Waveform')
-```
-
-Next, we add 2 new docks to the gui, one to plot the data of a camera and one to track the positions of two motors. 
-```ipython
-cam_widget= gui.add_dock(name="cam_dock").add_widget('BECFigure').image("eiger")
-motor_widget = gui.add_dock(name="mot_dock").add_widget('BECFigure').motor_map("samx", "samy")
-```
-Note, we chain commands here which is possible since the `add_dock` and `add_widget` methods return the dock and the widget respectively. We can now further customize the widgets by changing the title, axis labels, etc.
-
-```python
-cam_widget.set_title("Camera Image Eiger")
-cam_widget.set_vrange(vmin=0, vmax=100)
-```
-As a final step, we can now add also a RingProgressBar to a new dock, and perform a grid_scan with the motors *samx* and *samy*.
-As you see in the example below, all docks are arranged below each other. This is the default behavior of the `add_dock` method. However, the docks can be freely arranged by drag and drop as desired by the user. We invite you to explore this by yourself following the example in the video, and build your custom GUI with BEC Widgets.
-
-```python
-prog_bar = gui.add_dock(name="prog_dock").add_widget('RingProgressBar')
-prog_bar.set_line_widths(15)
-scans.grid_scan(dev.samy, -2, 2, 10, dev.samx, -5, 5, 10, exp_time=0.1, relative=False)
-```
-
-![gui_complex_gui](./gui_complex_gui.gif)
-

docs/user/getting_started/video_tutorials.md

@@ -1,17 +0,0 @@
-(user.video_tutorials)=
-
-# Video Tutorials
-
-This section includes video tutorials that demonstrate various use cases of `bec-widgets`, including video tutorials,
-presentations, and conference talks.
-
-## BSEG Meeting 24th July 2024
-
-This video is a presentation of the BEC Widgets project at the BSEG meeting on the 24th July 2024. The presentation
-covers the basic interactions, including visualization of live data acquisition and how to steer experiments using
-user-friendly tools. Learn how BEC Widgets can enhance your experimental control projects with its intuitive interface
-and powerful features.
-
-Used version of BEC Widgets: 0.91.0
-
-<iframe width="560" height="315" src="https://www.youtube.com/embed/qZ8fWXRAdHE" frameborder="0" allowfullscreen></iframe>

docs/user/user.md

@@ -1,71 +0,0 @@
-(user)=
-# User
-Welcome to the User section of the BEC Widgets documentation! BEC Widgets is a versatile GUI framework tailored for beamline scientists, enabling efficient and intuitive interaction with beamline experiments. This section is designed to guide both new and experienced users through the essential aspects of utilizing BEC Widgets.
-
-```{toctree}
----
-maxdepth: 2
-hidden: true
----
-
-getting_started/getting_started.md
-applications/applications.md
-widgets/widgets.md
-api_reference/api_reference.md
-```
-
-
-***
-
-````{grid} 2
-:gutter: 5
-
-```{grid-item-card}
-:link: user.getting_started
-:link-type: ref
-:img-top: /assets/rocket_launch_48dp.svg
-:text-align: center
-:class-item: index-card
-
-## Getting Started
-
-Learn how to install BEC Widgets and get started with the framework.
-```
-
-```{grid-item-card}
-:link: user.applications
-:link-type: ref
-:img-top: /assets/display_settings_48dp.svg
-:text-align: center
-:class-item: index-card
-
-## Applications
-
-Learn how to use BEC Widgets Applications, to modify and create new applications.
-
-```
-
-```{grid-item-card}
-:link: user.widgets
-:link-type: ref
-:img-top: /assets/apps_48dp.svg
-:text-align: center
-:class-item: index-card
-
-## Widgets
-
-Learn about the building blocks of larger applications: widgets.
-```
-
-```{grid-item-card} 
-:link: user.api_reference
-:link-type: ref
-:img-top: /assets/index_api.svg
-:text-align: center
-:class-item: index-card
-
-## API reference
-
-Comprehensive reference of all user-facing classes, functions, and methods.
-```
-````

docs/user/widgets/bec_figure/bec_figure.md

@@ -1,105 +0,0 @@
-(user.widgets.bec_figure)=
-# BECFigure
-
-````{tab} Overview
-
-[`BECFigure`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure) is a robust framework that provides a fast, flexible plotting environment, similar to the Matplotlib figure. With BECFigure, users can dynamically change layouts, add or remove subplots, and customize their plotting environment in real-time. This flexibility makes BECFigure an ideal tool for both rapid prototyping and detailed data visualization.
-
-- **Dynamic Layout Management**: Easily add, remove, and rearrange subplots within `BECFigure`, enabling tailored visualization setups.
-- **Widget Integration**: Incorporate various specialized widgets like [`WaveformWidget`](user.widgets.waveform_widget), [`ImageWidget`](user.widgets.image_widget) , and [`MotorMapWidget`](user.widgets.motor_map) into `BECFigure`. Note that these widgets can also be used individually. For more details, please refer to the documentation for each individual widget.
-- **Interactive Controls**: Provides interactive tools for zooming, panning, and adjusting plots on the fly, streamlining the data exploration process.
-
-**Schema of the BECFigure components**
-
-![BECFigure.png](BECFigure.png)
-
-````
-
-````{tab} Examples - CLI
-In the following examples, we will use `BECIPythonClient` with a predefined `BECDockArea` as the `gui` object. These tutorials focus on how to work with the `BECFigure` framework, such as changing layouts, adding new elements, and accessing them. For more detailed examples of each individual component, please refer to the example sections of each individual widget: [`WaveformWidget`](user.widgets.waveform_widget), [`MotorMapWidget`](user.widgets.motor_map), [`ImageWidget`](user.widgets.image_widget).
-
-## Example 1 - Adding subplots to BECFigure
-
-In this example, we will demonstrate how to add different subplots to a single `BECFigure` widget.
-
-```python
-# Add a new dock with BECFigure widget
-fig = gui.add_dock().add_widget('BECFigure')
-
-# Add a WaveformWidget to the BECFigure
-plt1 = fig.plot(x_name='samx', y_name='bpm4i')
-
-# Add a second WaveformWidget to the BECFigure, specifying new=True to add it as a new subplot
-plt2 = fig.plot(x_name='samx', y_name='bpm3i', new=True)
-
-# Add a MotorMapWidget to the BECFigure
-mm = fig.motor_map(motor_x='samx', motor_y='samy')
-
-# Add an ImageWidget to the BECFigure
-img = fig.image('eiger')
-```
-```{note}
-By default, the [`.plot`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.plot), [`.image`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.image), and [`.motor_map`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.motor_map) methods always find the first widget of that type in the layout and interact with it. If you want to add a new subplot of the same type, you must either specify the coordinates of the new subplot or use the `new=True` keyword argument, as shown above when adding the second WaveformWidget. Additionally, you can directly add a subplot to a specific, unoccupied position in the layout by specifying the `row` and `col` arguments, such as `fig.plot(x_name='samx', y_name='bpm4i', row=1, col=1)`.
-```
-
-## Example 2 - Changing the layout of BECFigure
-
-The previous example added four subplots into a single `BECFigure` widget. By default, new widgets are always added to the bottom of the BECFigure. However, you can change the layout of the BECFigure by using the [`change_layout`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.change_layout) method, specifying the number of rows and/or columns.
-
-```python
-# Change the layout of the BECFigure to have 4 columns -> 4x1 matrix layout
-fig.change_layout(max_columns=4) 
-
-# Change the layout of the BECFigure to have 2 rows -> 2x2 matrix layout
-fig.change_layout(max_rows=2) 
-```
-
-## Example 3 - Accessing Subplots in BECFigure
-
-The subplots in BECFigure can be accessed in a similar way to Matplotlib figures using the [`axes`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.axes) property. Each subplot can be accessed by its index coordinates within the layout, specified by the row and column index (starting at 0). In following example, we will access the subplots and modify their titles. The layout is a 2x2 matrix, so the subplots are indexed as follows:
-
-```python
-# Access the first subplot in the first row and first column (0, 0)
-subplot1 = fig.axes(0, 0)
-
-# Access the second subplot in the first row and second column (0, 1)
-subplot2 = fig.axes(0, 1)
-
-# Access the first subplot in the second row and first column (1, 0)
-subplot3 = fig.axes(1, 0)
-
-# Example: Set title for the first subplot
-subplot1.set_title("Waveform 1")
-
-# Example: Set title for the second subplot
-subplot2.set_title("Waveform 2")
-
-# Example: Set title for the third subplot
-subplot3.set_title("Motor Map")
-```
-
-In this example, we accessed three different subplots based on their row and column positions and modified their titles.
-
-## Example 4 - Removing Subplots from BECFigure
-
-You may want to remove certain subplots from the `BECFigure`. This can be done using the [`remove`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.remove) method, which takes the row and column index of the subplot you want to remove. The [`remove`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.remove) method could be also called on the subplot itself.
-
-```python
-
-# Remove the subplot in the second row and second column (1, 1)
-fig.remove(1, 1)
-
-# Remove the subplot in the first row and first column (0, 0)
-fig.remove(0, 0)
-
-# Remove previously accessed subplot plt2 from Example 1
-plt2.remove()
-```
-
-````
-
-````{tab} API
-```{eval-rst} 
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst
-```
-````

docs/user/widgets/bec_status_box/bec_status_box.md

@@ -1,38 +0,0 @@
-(user.widgets.bec_status_box)=
-# BEC Status Box
-
-````{tab} Overview
-
-The [`BEC Status Box`](/api_reference/_autosummary/bec_widgets.cli.client.BECStatusBox) widget is designed to monitor the status and health of all running BEC processes. This widget provides a real-time overview of the BEC core services, including DeviceServer, ScanServer, SciHub, ScanBundler, and FileWriter. The top-level display indicates the overall state of the BEC services, while the collapsed view allows users to delve into the status of each individual process. By double-clicking on a specific process, users can access a detailed popup window with live updates of the metrics for that process.
-
-## Key Features:
-- **Comprehensive Service Monitoring**: Track the state of individual BEC services, including real-time updates on their health and status.
-- **Automatic Service Tracking**: Automatically detects and monitors additional clients connecting to the BEC services.
-- **Detailed Metrics**: Provides live updates of the metrics for each process, accessible through an interactive popup window.
-
-![BECStatus](./bec_status_box.gif)
-````
-
-````{tab} Examples
-
-The `BECStatusBox` widget can be integrated within a [`BECDockArea`](user.widgets.bec_dock_area) or used as an individual component in your application through `QtDesigner`. Below are examples demonstrating how to create and use the `BECStatusBox` widget.
-
-## Example 1 - Adding BEC Status Box to BECDockArea
-
-In this example, we demonstrate how to add a `BECStatusBox` widget to a `BECDockArea`, allowing users to monitor the status of BEC processes directly from the GUI.
-
-```python
-# Add a new dock with a BECStatusBox widget
-bec_status_box = gui.add_dock().add_widget("BECStatusBox")
-```
-
-```{hint}
-Once the `BECStatusBox` is added, users can interact with it to view the status of individual processes. By expanding the view, you can see the status of each BEC service in detail.
-```
-````
-
-````{tab} API
-```{eval-rst} 
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.BECStatusBox.rst
-```
-````