Toolbar for tiled figure in interactive mode is raw MPL toolbar, not the Plopp one

[nvaytet]

When making a tiled figure in interactive mode (%matplotlib widget), the toolbar on the resulting figure is the raw MPL toolbar, not the plopp one that has extra buttons such as log scaling etc.

Would be nice to get that toolbar instead.
However, if you have both a 1d and a 2d plot in the tiled, then the toolbar should have both logx and logy buttons, plus the log button for the norm.
I guess the toolbar should then act on all plots.

Should we make a new toolbar which triggers calls on the underlying (and not displayed) toolbars?
We then need to keep track of all the toolbars... sounds annoying.

Note that the alternative (and probably recommended) way for making tiled plots with interactive figures is using container widgets.
Should we disable making tiled plots with interactive figures? -> This sounds like it would annoy users...

[nvaytet]

More thoughts:

I guess the toolbar should then act on all plots.

This sounds like a bad idea actually: if you have a 1d next to a 2d plot, clicking the logy button would change the scale of the vertical axis on both plots (values for 1d plot, and spatial dimension for 2d plot)

We should use a single MPL figure instead of switching to container widget if interactive backend is active

I believe that making a single mpl figure with subplots is the way to go, for both static and interactive figs. Users will want to use things like tweaking the layout with tight_layout, they will want to have the axes nicely aligned, and most of all, they will want to save their plot to file (which we cannot do when simply displaying the figs in container widgets).

Confusing double views in show_graph

When making a tiled figure, it currently makes a copy of the figure, attaching the input data nodes to a new figure.
This means that if someone is making an interactive interface with nodes, and then use tiled to place plots side by side, they are seeing double views in show_graph which is confusing.

We should find another method for copying the data onto the new axes. I believe keeping the original figure intact is essential. If you do f = data.plot(), it should not matter if you then add f to a tiled figure, f should still exist and be displayable as it originally was.
Maybe copying should be manually done on the MPL level, not using Plopp nodes etc..

Toolbar buttons

If the only annoying part above is the logx/y/c buttons in the toolbar, maybe we can think of an alternative way to set the log-scale on the axes, which would be specific to each plot?
One idea is that instead of having buttons in the toolbar, we could have a callback on the figure that toggles the scale if you double-click on the axes.

Here is a MWE:

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0.1, 10, 200)
y = np.exp(x)

fig, ax = plt.subplots()
ax.plot(x, y)

def toggle_scale(event):
    if (not event.dblclick) or (event.inaxes is not None):
        return

    renderer = fig.canvas.get_renderer()
    viewport = ax.patch.get_window_extent(renderer)
    xmin = viewport.bounds[0]
    ymin = viewport.bounds[1]
    if ((event.x > xmin) and (event.y > ymin)):
        return

    if event.x > event.y:
        ax.set_xscale('log' if ax.get_xscale() == 'linear' else 'linear')
    else:
        ax.set_yscale('log' if ax.get_yscale() == 'linear' else 'linear')
        
    # ax.figure.canvas.draw_idle()

fig.canvas.mpl_connect('button_press_event', toggle_scale)

We could also imagine double-clicking the colorbar to toggle log color scale.
Note that this would also have to work for 3d plots, that are currently just making an image of the colorbar.
We would have to make the colorbar next to 3d plots an interactive matplotlib colorbar, but this is difficult because it would require the %matplotlib widget to be enabled, and the user may not have done so.
We can't enable it programmatically because disabling it after it's been activated is either buggy or not possible (it seems to deactivate all existing interactive figs, and flushes all previous figures to the output, etc..)

[nvaytet]

To answer the last part of the previous post, it is possible to make a clickable colorbar using ipycanvas:

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.colors import Normalize
from matplotlib.colorbar import ColorbarBase
from matplotlib import cm

from io import BytesIO
from PIL import Image
from ipycanvas import Canvas

# 1. Create a matplotlib colorbar and save as PNG
fig, ax = plt.subplots(figsize=(0.3, 4))
norm = Normalize(vmin=0, vmax=1)
cbar = ColorbarBase(ax, cmap=cm.viridis, norm=norm, orientation='vertical')
# ax.set_title('Value')
buf = BytesIO()
plt.savefig(buf, format='png', bbox_inches='tight', dpi=100)
plt.close(fig)

# 2. Load PNG with Pillow and draw to ipycanvas
buf.seek(0)
img = Image.open(buf)
img_arr = np.array(img)

canvas = Canvas(width=img_arr.shape[1], height=img_arr.shape[0],
                layout=ipw.Layout(width=f'{img_arr.shape[1]}px', height=f'{img_arr.shape[0]}px'))
# canvas = Canvas(width=50, height=500)

# Draw RGB image on canvas
canvas.put_image_data(img_arr, 0, 0)


import time
last_click_time = 0

def handle_mouse_down(x, y):
    now = time.time()
    global last_click_time
    # If the time between clicks is less than ~0.3 seconds, treat as double-click
    if (now - last_click_time) < 0.3:
        print("Double click detected!")
        # Call your colorbar toggle here
    last_click_time = now

canvas.on_mouse_down(handle_mouse_down)
canvas