Repository navigation
Expand file tree
/
Copy path_backend_tk.py
More file actions
1012 lines (858 loc) · 38.6 KB
/
Copy path_backend_tk.py
File metadata and controls
1012 lines (858 loc) · 38.6 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
import uuid
from contextlib import contextmanager
import logging
import math
import os.path
import sys
import tkinter as tk
import tkinter.filedialog
import tkinter.font
import tkinter.messagebox
from tkinter.simpledialog import SimpleDialog
import numpy as np
from PIL import Image, ImageTk
import matplotlib as mpl
from matplotlib import _api, backend_tools, cbook, _c_internal_utils
from matplotlib.backend_bases import (
_Backend, FigureCanvasBase, FigureManagerBase, NavigationToolbar2,
TimerBase, ToolContainerBase, cursors, _Mode)
from matplotlib._pylab_helpers import Gcf
from . import _tkagg
_log = logging.getLogger(__name__)
backend_version = tk.TkVersion
cursord = {
cursors.MOVE: "fleur",
cursors.HAND: "hand2",
cursors.POINTER: "arrow",
cursors.SELECT_REGION: "tcross",
cursors.WAIT: "watch",
cursors.RESIZE_HORIZONTAL: "sb_h_double_arrow",
cursors.RESIZE_VERTICAL: "sb_v_double_arrow",
}
@contextmanager
def _restore_foreground_window_at_end():
foreground = _c_internal_utils.Win32_GetForegroundWindow()
try:
yield
finally:
if mpl.rcParams['tk.window_focus']:
_c_internal_utils.Win32_SetForegroundWindow(foreground)
_blit_args = {}
# Initialize to a non-empty string that is not a Tcl command
_blit_tcl_name = "mpl_blit_" + uuid.uuid4().hex
TK_PHOTO_COMPOSITE_OVERLAY = 0 # apply transparency rules pixel-wise
TK_PHOTO_COMPOSITE_SET = 1 # set image buffer directly
def _blit(argsid):
"""
Thin wrapper to blit called via tkapp.call.
*argsid* is a unique string identifier to fetch the correct arguments from
the ``_blit_args`` dict, since arguments cannot be passed directly.
"""
photoimage, dataptr, offsets, bboxptr, comp_rule = _blit_args.pop(argsid)
_tkagg.blit(photoimage.tk.interpaddr(), str(photoimage), dataptr,
comp_rule, offsets, bboxptr)
def blit(photoimage, aggimage, offsets, bbox=None):
"""
Blit *aggimage* to *photoimage*.
*offsets* is a tuple describing how to fill the ``offset`` field of the
``Tk_PhotoImageBlock`` struct: it should be (0, 1, 2, 3) for RGBA8888 data,
(2, 1, 0, 3) for little-endian ARBG32 (i.e. GBRA8888) data and (1, 2, 3, 0)
for big-endian ARGB32 (i.e. ARGB8888) data.
If *bbox* is passed, it defines the region that gets blitted. That region
will be composed with the previous data according to the alpha channel.
Blitting will be clipped to pixels inside the canvas, including silently
doing nothing if the *bbox* region is entirely outside the canvas.
Tcl events must be dispatched to trigger a blit from a non-Tcl thread.
"""
data = np.asarray(aggimage)
height, width = data.shape[:2]
dataptr = (height, width, data.ctypes.data)
if bbox is not None:
(x1, y1), (x2, y2) = bbox.__array__()
x1 = max(math.floor(x1), 0)
x2 = min(math.ceil(x2), width)
y1 = max(math.floor(y1), 0)
y2 = min(math.ceil(y2), height)
if (x1 > x2) or (y1 > y2):
return
bboxptr = (x1, x2, y1, y2)
comp_rule = TK_PHOTO_COMPOSITE_OVERLAY
else:
bboxptr = (0, width, 0, height)
comp_rule = TK_PHOTO_COMPOSITE_SET
# NOTE: _tkagg.blit is thread unsafe and will crash the process if called
# from a thread (GH#13293). Instead of blanking and blitting here,
# use tkapp.call to post a cross-thread event if this function is called
# from a non-Tcl thread.
# tkapp.call coerces all arguments to strings, so to avoid string parsing
# within _blit, pack up the arguments into a global data structure.
args = photoimage, dataptr, offsets, bboxptr, comp_rule
# Need a unique key to avoid thread races.
# Again, make the key a string to avoid string parsing in _blit.
argsid = str(id(args))
_blit_args[argsid] = args
try:
photoimage.tk.call(_blit_tcl_name, argsid)
except tk.TclError as e:
if "invalid command name" not in str(e):
raise
photoimage.tk.createcommand(_blit_tcl_name, _blit)
photoimage.tk.call(_blit_tcl_name, argsid)
class TimerTk(TimerBase):
"""Subclass of `backend_bases.TimerBase` using Tk timer events."""
def __init__(self, parent, *args, **kwargs):
self._timer = None
super().__init__(*args, **kwargs)
self.parent = parent
def _timer_start(self):
self._timer_stop()
self._timer = self.parent.after(self._interval, self._on_timer)
def _timer_stop(self):
if self._timer is not None:
self.parent.after_cancel(self._timer)
self._timer = None
def _on_timer(self):
super()._on_timer()
# Tk after() is only a single shot, so we need to add code here to
# reset the timer if we're not operating in single shot mode. However,
# if _timer is None, this means that _timer_stop has been called; so
# don't recreate the timer in that case.
if not self._single and self._timer:
if self._interval > 0:
self._timer = self.parent.after(self._interval, self._on_timer)
else:
# Edge case: Tcl after 0 *prepends* events to the queue
# so a 0 interval does not allow any other events to run.
# This incantation is cancellable and runs as fast as possible
# while also allowing events and drawing every frame. GH#18236
self._timer = self.parent.after_idle(
lambda: self.parent.after(self._interval, self._on_timer)
)
else:
self._timer = None
class FigureCanvasTk(FigureCanvasBase):
required_interactive_framework = "tk"
def __init__(self, figure=None, master=None):
super().__init__(figure)
self._idle_draw_id = None
self._event_loop_id = None
w, h = self.get_width_height(physical=True)
self._tkcanvas = tk.Canvas(
master=master, background="white",
width=w, height=h, borderwidth=0, highlightthickness=0)
self._tkphoto = tk.PhotoImage(
master=self._tkcanvas, width=w, height=h)
self._tkcanvas.create_image(w//2, h//2, image=self._tkphoto)
self._tkcanvas.bind("<Configure>", self.resize)
self._tkcanvas.bind("<Map>", self._update_device_pixel_ratio)
self._tkcanvas.bind("<Key>", self.key_press)
self._tkcanvas.bind("<Motion>", self.motion_notify_event)
self._tkcanvas.bind("<Enter>", self.enter_notify_event)
self._tkcanvas.bind("<Leave>", self.leave_notify_event)
self._tkcanvas.bind("<KeyRelease>", self.key_release)
for name in ["<Button-1>", "<Button-2>", "<Button-3>"]:
self._tkcanvas.bind(name, self.button_press_event)
for name in [
"<Double-Button-1>", "<Double-Button-2>", "<Double-Button-3>"]:
self._tkcanvas.bind(name, self.button_dblclick_event)
for name in [
"<ButtonRelease-1>", "<ButtonRelease-2>", "<ButtonRelease-3>"]:
self._tkcanvas.bind(name, self.button_release_event)
# Mouse wheel on Linux generates button 4/5 events
for name in "<Button-4>", "<Button-5>":
self._tkcanvas.bind(name, self.scroll_event)
# Mouse wheel for windows goes to the window with the focus.
# Since the canvas won't usually have the focus, bind the
# event to the window containing the canvas instead.
# See https://wiki.tcl-lang.org/3893 (mousewheel) for details
root = self._tkcanvas.winfo_toplevel()
root.bind("<MouseWheel>", self.scroll_event_windows, "+")
# Can't get destroy events by binding to _tkcanvas. Therefore, bind
# to the window and filter.
def filter_destroy(event):
if event.widget is self._tkcanvas:
self.close_event()
root.bind("<Destroy>", filter_destroy, "+")
self._tkcanvas.focus_set()
self._rubberband_rect = None
def _update_device_pixel_ratio(self, event=None):
# Tk gives scaling with respect to 72 DPI, but most (all?) screens are
# scaled vs 96 dpi, and pixel ratio settings are given in whole
# percentages, so round to 2 digits.
ratio = round(self._tkcanvas.tk.call('tk', 'scaling') / (96 / 72), 2)
if self._set_device_pixel_ratio(ratio):
# The easiest way to resize the canvas is to resize the canvas
# widget itself, since we implement all the logic for resizing the
# canvas backing store on that event.
w, h = self.get_width_height(physical=True)
self._tkcanvas.configure(width=w, height=h)
def resize(self, event):
width, height = event.width, event.height
# compute desired figure size in inches
dpival = self.figure.dpi
winch = width / dpival
hinch = height / dpival
self.figure.set_size_inches(winch, hinch, forward=False)
self._tkcanvas.delete(self._tkphoto)
self._tkphoto = tk.PhotoImage(
master=self._tkcanvas, width=int(width), height=int(height))
self._tkcanvas.create_image(
int(width / 2), int(height / 2), image=self._tkphoto)
self.resize_event()
def draw_idle(self):
# docstring inherited
if self._idle_draw_id:
return
def idle_draw(*args):
try:
self.draw()
finally:
self._idle_draw_id = None
self._idle_draw_id = self._tkcanvas.after_idle(idle_draw)
def get_tk_widget(self):
"""
Return the Tk widget used to implement FigureCanvasTkAgg.
Although the initial implementation uses a Tk canvas, this routine
is intended to hide that fact.
"""
return self._tkcanvas
def _event_mpl_coords(self, event):
# calling canvasx/canvasy allows taking scrollbars into account (i.e.
# the top of the widget may have been scrolled out of view).
return (self._tkcanvas.canvasx(event.x),
# flipy so y=0 is bottom of canvas
self.figure.bbox.height - self._tkcanvas.canvasy(event.y))
def motion_notify_event(self, event):
super().motion_notify_event(
*self._event_mpl_coords(event), guiEvent=event)
def enter_notify_event(self, event):
super().enter_notify_event(
guiEvent=event, xy=self._event_mpl_coords(event))
def button_press_event(self, event, dblclick=False):
# set focus to the canvas so that it can receive keyboard events
self._tkcanvas.focus_set()
num = getattr(event, 'num', None)
if sys.platform == 'darwin': # 2 and 3 are reversed.
num = {2: 3, 3: 2}.get(num, num)
super().button_press_event(
*self._event_mpl_coords(event), num, dblclick=dblclick,
guiEvent=event)
def button_dblclick_event(self, event):
self.button_press_event(event, dblclick=True)
def button_release_event(self, event):
num = getattr(event, 'num', None)
if sys.platform == 'darwin': # 2 and 3 are reversed.
num = {2: 3, 3: 2}.get(num, num)
super().button_release_event(
*self._event_mpl_coords(event), num, guiEvent=event)
def scroll_event(self, event):
num = getattr(event, 'num', None)
step = 1 if num == 4 else -1 if num == 5 else 0
super().scroll_event(
*self._event_mpl_coords(event), step, guiEvent=event)
def scroll_event_windows(self, event):
"""MouseWheel event processor"""
# need to find the window that contains the mouse
w = event.widget.winfo_containing(event.x_root, event.y_root)
if w == self._tkcanvas:
x = self._tkcanvas.canvasx(event.x_root - w.winfo_rootx())
y = (self.figure.bbox.height
- self._tkcanvas.canvasy(event.y_root - w.winfo_rooty()))
step = event.delta/120.
FigureCanvasBase.scroll_event(self, x, y, step, guiEvent=event)
def _get_key(self, event):
unikey = event.char
key = cbook._unikey_or_keysym_to_mplkey(unikey, event.keysym)
# add modifier keys to the key string. Bit details originate from
# http://effbot.org/tkinterbook/tkinter-events-and-bindings.htm
# BIT_SHIFT = 0x001; BIT_CAPSLOCK = 0x002; BIT_CONTROL = 0x004;
# BIT_LEFT_ALT = 0x008; BIT_NUMLOCK = 0x010; BIT_RIGHT_ALT = 0x080;
# BIT_MB_1 = 0x100; BIT_MB_2 = 0x200; BIT_MB_3 = 0x400;
# In general, the modifier key is excluded from the modifier flag,
# however this is not the case on "darwin", so double check that
# we aren't adding repeat modifier flags to a modifier key.
if sys.platform == 'win32':
modifiers = [(2, 'ctrl', 'control'),
(17, 'alt', 'alt'),
(0, 'shift', 'shift'),
]
elif sys.platform == 'darwin':
modifiers = [(2, 'ctrl', 'control'),
(4, 'alt', 'alt'),
(0, 'shift', 'shift'),
(3, 'super', 'super'),
]
else:
modifiers = [(2, 'ctrl', 'control'),
(3, 'alt', 'alt'),
(0, 'shift', 'shift'),
(6, 'super', 'super'),
]
if key is not None:
# shift is not added to the keys as this is already accounted for
for bitmask, prefix, key_name in modifiers:
if event.state & (1 << bitmask) and key_name not in key:
if not (prefix == 'shift' and unikey):
key = '{0}+{1}'.format(prefix, key)
return key
def key_press(self, event):
key = self._get_key(event)
FigureCanvasBase.key_press_event(self, key, guiEvent=event)
def key_release(self, event):
key = self._get_key(event)
FigureCanvasBase.key_release_event(self, key, guiEvent=event)
def new_timer(self, *args, **kwargs):
# docstring inherited
return TimerTk(self._tkcanvas, *args, **kwargs)
def flush_events(self):
# docstring inherited
self._tkcanvas.update()
def start_event_loop(self, timeout=0):
# docstring inherited
if timeout > 0:
milliseconds = int(1000 * timeout)
if milliseconds > 0:
self._event_loop_id = self._tkcanvas.after(
milliseconds, self.stop_event_loop)
else:
self._event_loop_id = self._tkcanvas.after_idle(
self.stop_event_loop)
self._tkcanvas.mainloop()
def stop_event_loop(self):
# docstring inherited
if self._event_loop_id:
self._tkcanvas.after_cancel(self._event_loop_id)
self._event_loop_id = None
self._tkcanvas.quit()
def set_cursor(self, cursor):
try:
self._tkcanvas.configure(cursor=cursord[cursor])
except tkinter.TclError:
pass
class FigureManagerTk(FigureManagerBase):
"""
Attributes
----------
canvas : `FigureCanvas`
The FigureCanvas instance
num : int or str
The Figure number
toolbar : tk.Toolbar
The tk.Toolbar
window : tk.Window
The tk.Window
"""
_owns_mainloop = False
def __init__(self, canvas, num, window):
self.window = window
super().__init__(canvas, num)
self.window.withdraw()
# packing toolbar first, because if space is getting low, last packed
# widget is getting shrunk first (-> the canvas)
self.canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=1)
# If the window has per-monitor DPI awareness, then setup a Tk variable
# to store the DPI, which will be updated by the C code, and the trace
# will handle it on the Python side.
window_frame = int(window.wm_frame(), 16)
window_dpi = tk.IntVar(master=window, value=96,
name=f'window_dpi{window_frame}')
if _tkagg.enable_dpi_awareness(window_frame, window.tk.interpaddr()):
self._window_dpi = window_dpi # Prevent garbage collection.
window_dpi.trace_add('write', self._update_window_dpi)
self._shown = False
def _update_window_dpi(self, *args):
newdpi = self._window_dpi.get()
self.window.call('tk', 'scaling', newdpi / 72)
if self.toolbar and hasattr(self.toolbar, '_rescale'):
self.toolbar._rescale()
self.canvas._update_device_pixel_ratio()
def resize(self, width, height):
max_size = 1_400_000 # the measured max on xorg 1.20.8 was 1_409_023
if (width > max_size or height > max_size) and sys.platform == 'linux':
raise ValueError(
'You have requested to resize the '
f'Tk window to ({width}, {height}), one of which '
f'is bigger than {max_size}. At larger sizes xorg will '
'either exit with an error on newer versions (~1.20) or '
'cause corruption on older version (~1.19). We '
'do not expect a window over a million pixel wide or tall '
'to be intended behavior.')
self.canvas._tkcanvas.configure(width=width, height=height)
def show(self):
with _restore_foreground_window_at_end():
if not self._shown:
def destroy(*args):
Gcf.destroy(self)
self.window.protocol("WM_DELETE_WINDOW", destroy)
self.window.deiconify()
self.canvas._tkcanvas.focus_set()
else:
self.canvas.draw_idle()
if mpl.rcParams['figure.raise_window']:
self.canvas.manager.window.attributes('-topmost', 1)
self.canvas.manager.window.attributes('-topmost', 0)
self._shown = True
def destroy(self, *args):
if self.canvas._idle_draw_id:
self.canvas._tkcanvas.after_cancel(self.canvas._idle_draw_id)
if self.canvas._event_loop_id:
self.canvas._tkcanvas.after_cancel(self.canvas._event_loop_id)
# NOTE: events need to be flushed before issuing destroy (GH #9956),
# however, self.window.update() can break user code. An async callback
# is the safest way to achieve a complete draining of the event queue,
# but it leaks if no tk event loop is running. Therefore we explicitly
# check for an event loop and choose our best guess.
def delayed_destroy():
self.window.destroy()
if self._owns_mainloop and not Gcf.get_num_fig_managers():
self.window.quit()
if cbook._get_running_interactive_framework() == "tk":
# "after idle after 0" avoids Tcl error/race (GH #19940)
self.window.after_idle(self.window.after, 0, delayed_destroy)
else:
self.window.update()
delayed_destroy()
def get_window_title(self):
return self.window.wm_title()
def set_window_title(self, title):
self.window.wm_title(title)
def full_screen_toggle(self):
is_fullscreen = bool(self.window.attributes('-fullscreen'))
self.window.attributes('-fullscreen', not is_fullscreen)
class NavigationToolbar2Tk(NavigationToolbar2, tk.Frame):
window = _api.deprecated("3.6", alternative="self.master")(
property(lambda self: self.master))
def __init__(self, canvas, window=None, *, pack_toolbar=True):
"""
Parameters
----------
canvas : `FigureCanvas`
The figure canvas on which to operate.
window : tk.Window
The tk.Window which owns this toolbar.
pack_toolbar : bool, default: True
If True, add the toolbar to the parent's pack manager's packing
list during initialization with ``side="bottom"`` and ``fill="x"``.
If you want to use the toolbar with a different layout manager, use
``pack_toolbar=False``.
"""
if window is None:
window = canvas.get_tk_widget().master
tk.Frame.__init__(self, master=window, borderwidth=2,
width=int(canvas.figure.bbox.width), height=50)
self._buttons = {}
for text, tooltip_text, image_file, callback in self.toolitems:
if text is None:
# Add a spacer; return value is unused.
self._Spacer()
else:
self._buttons[text] = button = self._Button(
text,
str(cbook._get_data_path(f"images/{image_file}.png")),
toggle=callback in ["zoom", "pan"],
command=getattr(self, callback),
)
if tooltip_text is not None:
ToolTip.createToolTip(button, tooltip_text)
self._label_font = tkinter.font.Font(root=window, size=10)
# This filler item ensures the toolbar is always at least two text
# lines high. Otherwise the canvas gets redrawn as the mouse hovers
# over images because those use two-line messages which resize the
# toolbar.
label = tk.Label(master=self, font=self._label_font,
text='\N{NO-BREAK SPACE}\n\N{NO-BREAK SPACE}')
label.pack(side=tk.RIGHT)
self.message = tk.StringVar(master=self)
self._message_label = tk.Label(master=self, font=self._label_font,
textvariable=self.message,
justify=tk.RIGHT)
self._message_label.pack(side=tk.RIGHT)
NavigationToolbar2.__init__(self, canvas)
if pack_toolbar:
self.pack(side=tk.BOTTOM, fill=tk.X)
def _rescale(self):
"""
Scale all children of the toolbar to current DPI setting.
Before this is called, the Tk scaling setting will have been updated to
match the new DPI. Tk widgets do not update for changes to scaling, but
all measurements made after the change will match the new scaling. Thus
this function re-applies all the same sizes in points, which Tk will
scale correctly to pixels.
"""
for widget in self.winfo_children():
if isinstance(widget, (tk.Button, tk.Checkbutton)):
if hasattr(widget, '_image_file'):
# Explicit class because ToolbarTk calls _rescale.
NavigationToolbar2Tk._set_image_for_button(self, widget)
else:
# Text-only button is handled by the font setting instead.
pass
elif isinstance(widget, tk.Frame):
widget.configure(height='22p', pady='1p')
widget.pack_configure(padx='4p')
elif isinstance(widget, tk.Label):
pass # Text is handled by the font setting instead.
else:
_log.warning('Unknown child class %s', widget.winfo_class)
self._label_font.configure(size=10)
def _update_buttons_checked(self):
# sync button checkstates to match active mode
for text, mode in [('Zoom', _Mode.ZOOM), ('Pan', _Mode.PAN)]:
if text in self._buttons:
if self.mode == mode:
self._buttons[text].select() # NOT .invoke()
else:
self._buttons[text].deselect()
def pan(self, *args):
super().pan(*args)
self._update_buttons_checked()
def zoom(self, *args):
super().zoom(*args)
self._update_buttons_checked()
def set_message(self, s):
self.message.set(s)
def draw_rubberband(self, event, x0, y0, x1, y1):
# Block copied from remove_rubberband for backend_tools convenience.
if self.canvas._rubberband_rect:
self.canvas._tkcanvas.delete(self.canvas._rubberband_rect)
height = self.canvas.figure.bbox.height
y0 = height - y0
y1 = height - y1
self.canvas._rubberband_rect = self.canvas._tkcanvas.create_rectangle(
x0, y0, x1, y1)
def remove_rubberband(self):
if self.canvas._rubberband_rect:
self.canvas._tkcanvas.delete(self.canvas._rubberband_rect)
self.canvas._rubberband_rect = None
lastrect = _api.deprecated("3.6")(
property(lambda self: self.canvas._rubberband_rect))
def _set_image_for_button(self, button):
"""
Set the image for a button based on its pixel size.
The pixel size is determined by the DPI scaling of the window.
"""
if button._image_file is None:
return
# Allow _image_file to be relative to Matplotlib's "images" data
# directory.
path_regular = cbook._get_data_path('images', button._image_file)
path_large = path_regular.with_name(
path_regular.name.replace('.png', '_large.png'))
size = button.winfo_pixels('18p')
# Nested functions because ToolbarTk calls _Button.
def _get_color(color_name):
# `winfo_rgb` returns an (r, g, b) tuple in the range 0-65535
return button.winfo_rgb(button.cget(color_name))
def _is_dark(color):
if isinstance(color, str):
color = _get_color(color)
return max(color) < 65535 / 2
def _recolor_icon(image, color):
image_data = np.asarray(image).copy()
black_mask = (image_data[..., :3] == 0).all(axis=-1)
image_data[black_mask, :3] = color
return Image.fromarray(image_data, mode="RGBA")
# Use the high-resolution (48x48 px) icon if it exists and is needed
with Image.open(path_large if (size > 24 and path_large.exists())
else path_regular) as im:
image = ImageTk.PhotoImage(im.resize((size, size)), master=self)
button._ntimage = image
# create a version of the icon with the button's text color
foreground = (255 / 65535) * np.array(
button.winfo_rgb(button.cget("foreground")))
im_alt = _recolor_icon(im, foreground)
image_alt = ImageTk.PhotoImage(
im_alt.resize((size, size)), master=self)
button._ntimage_alt = image_alt
if _is_dark("background"):
button.configure(image=image_alt)
else:
button.configure(image=image)
# Checkbuttons may switch the background to `selectcolor` in the
# checked state, so check separately which image it needs to use in
# that state to still ensure enough contrast with the background.
if (
isinstance(button, tk.Checkbutton)
and button.cget("selectcolor") != ""
):
if self._windowingsystem != "x11":
selectcolor = "selectcolor"
else:
# On X11, selectcolor isn't used directly for indicator-less
# buttons. See `::tk::CheckEnter` in the Tk button.tcl source
# code for details.
r1, g1, b1 = _get_color("selectcolor")
r2, g2, b2 = _get_color("activebackground")
selectcolor = ((r1+r2)/2, (g1+g2)/2, (b1+b2)/2)
if _is_dark(selectcolor):
button.configure(selectimage=image_alt)
else:
button.configure(selectimage=image)
button.configure(height='18p', width='18p')
def _Button(self, text, image_file, toggle, command):
if not toggle:
b = tk.Button(
master=self, text=text, command=command,
relief="flat", overrelief="groove", borderwidth=1,
)
else:
# There is a bug in tkinter included in some python 3.6 versions
# that without this variable, produces a "visual" toggling of
# other near checkbuttons
# https://bugs.python.org/issue29402
# https://bugs.python.org/issue25684
var = tk.IntVar(master=self)
b = tk.Checkbutton(
master=self, text=text, command=command, indicatoron=False,
variable=var, offrelief="flat", overrelief="groove",
borderwidth=1
)
b.var = var
b._image_file = image_file
if image_file is not None:
# Explicit class because ToolbarTk calls _Button.
NavigationToolbar2Tk._set_image_for_button(self, b)
else:
b.configure(font=self._label_font)
b.pack(side=tk.LEFT)
return b
def _Spacer(self):
# Buttons are also 18pt high.
s = tk.Frame(master=self, height='18p', relief=tk.RIDGE, bg='DarkGray')
s.pack(side=tk.LEFT, padx='3p')
return s
def save_figure(self, *args):
filetypes = self.canvas.get_supported_filetypes().copy()
default_filetype = self.canvas.get_default_filetype()
# Tk doesn't provide a way to choose a default filetype,
# so we just have to put it first
default_filetype_name = filetypes.pop(default_filetype)
sorted_filetypes = ([(default_filetype, default_filetype_name)]
+ sorted(filetypes.items()))
tk_filetypes = [(name, '*.%s' % ext) for ext, name in sorted_filetypes]
# adding a default extension seems to break the
# asksaveasfilename dialog when you choose various save types
# from the dropdown. Passing in the empty string seems to
# work - JDH!
# defaultextension = self.canvas.get_default_filetype()
defaultextension = ''
initialdir = os.path.expanduser(mpl.rcParams['savefig.directory'])
initialfile = self.canvas.get_default_filename()
fname = tkinter.filedialog.asksaveasfilename(
master=self.canvas.get_tk_widget().master,
title='Save the figure',
filetypes=tk_filetypes,
defaultextension=defaultextension,
initialdir=initialdir,
initialfile=initialfile,
)
if fname in ["", ()]:
return
# Save dir for next time, unless empty str (i.e., use cwd).
if initialdir != "":
mpl.rcParams['savefig.directory'] = (
os.path.dirname(str(fname)))
try:
# This method will handle the delegation to the correct type
self.canvas.figure.savefig(fname)
except Exception as e:
tkinter.messagebox.showerror("Error saving file", str(e))
def set_history_buttons(self):
state_map = {True: tk.NORMAL, False: tk.DISABLED}
can_back = self._nav_stack._pos > 0
can_forward = self._nav_stack._pos < len(self._nav_stack._elements) - 1
if "Back" in self._buttons:
self._buttons['Back']['state'] = state_map[can_back]
if "Forward" in self._buttons:
self._buttons['Forward']['state'] = state_map[can_forward]
class ToolTip:
"""
Tooltip recipe from
http://www.voidspace.org.uk/python/weblog/arch_d7_2006_07_01.shtml#e387
"""
@staticmethod
def createToolTip(widget, text):
toolTip = ToolTip(widget)
def enter(event):
toolTip.showtip(text)
def leave(event):
toolTip.hidetip()
widget.bind('<Enter>', enter)
widget.bind('<Leave>', leave)
def __init__(self, widget):
self.widget = widget
self.tipwindow = None
self.id = None
self.x = self.y = 0
def showtip(self, text):
"""Display text in tooltip window."""
self.text = text
if self.tipwindow or not self.text:
return
x, y, _, _ = self.widget.bbox("insert")
x = x + self.widget.winfo_rootx() + self.widget.winfo_width()
y = y + self.widget.winfo_rooty()
self.tipwindow = tw = tk.Toplevel(self.widget)
tw.wm_overrideredirect(1)
tw.wm_geometry("+%d+%d" % (x, y))
try:
# For Mac OS
tw.tk.call("::tk::unsupported::MacWindowStyle",
"style", tw._w,
"help", "noActivates")
except tk.TclError:
pass
label = tk.Label(tw, text=self.text, justify=tk.LEFT,
relief=tk.SOLID, borderwidth=1)
label.pack(ipadx=1)
def hidetip(self):
tw = self.tipwindow
self.tipwindow = None
if tw:
tw.destroy()
@backend_tools._register_tool_class(FigureCanvasTk)
class RubberbandTk(backend_tools.RubberbandBase):
def draw_rubberband(self, x0, y0, x1, y1):
NavigationToolbar2Tk.draw_rubberband(
self._make_classic_style_pseudo_toolbar(), None, x0, y0, x1, y1)
def remove_rubberband(self):
NavigationToolbar2Tk.remove_rubberband(
self._make_classic_style_pseudo_toolbar())
lastrect = _api.deprecated("3.6")(
property(lambda self: self.figure.canvas._rubberband_rect))
@_api.deprecated("3.5", alternative="ToolSetCursor")
class SetCursorTk(backend_tools.SetCursorBase):
def set_cursor(self, cursor):
NavigationToolbar2Tk.set_cursor(
self._make_classic_style_pseudo_toolbar(), cursor)
class ToolbarTk(ToolContainerBase, tk.Frame):
def __init__(self, toolmanager, window=None):
ToolContainerBase.__init__(self, toolmanager)
if window is None:
window = self.toolmanager.canvas.get_tk_widget().master
xmin, xmax = self.toolmanager.canvas.figure.bbox.intervalx
height, width = 50, xmax - xmin
tk.Frame.__init__(self, master=window,
width=int(width), height=int(height),
borderwidth=2)
self._label_font = tkinter.font.Font(size=10)
self._message = tk.StringVar(master=self)
self._message_label = tk.Label(master=self, font=self._label_font,
textvariable=self._message)
self._message_label.pack(side=tk.RIGHT)
self._toolitems = {}
self.pack(side=tk.TOP, fill=tk.X)
self._groups = {}
def _rescale(self):
return NavigationToolbar2Tk._rescale(self)
def add_toolitem(
self, name, group, position, image_file, description, toggle):
frame = self._get_groupframe(group)
buttons = frame.pack_slaves()
if position >= len(buttons) or position < 0:
before = None
else:
before = buttons[position]
button = NavigationToolbar2Tk._Button(frame, name, image_file, toggle,
lambda: self._button_click(name))
button.pack_configure(before=before)
if description is not None:
ToolTip.createToolTip(button, description)
self._toolitems.setdefault(name, [])
self._toolitems[name].append(button)
def _get_groupframe(self, group):
if group not in self._groups:
if self._groups:
self._add_separator()
frame = tk.Frame(master=self, borderwidth=0)
frame.pack(side=tk.LEFT, fill=tk.Y)
frame._label_font = self._label_font
self._groups[group] = frame
return self._groups[group]
def _add_separator(self):
return NavigationToolbar2Tk._Spacer(self)
def _button_click(self, name):
self.trigger_tool(name)
def toggle_toolitem(self, name, toggled):
if name not in self._toolitems:
return
for toolitem in self._toolitems[name]:
if toggled:
toolitem.select()
else:
toolitem.deselect()
def remove_toolitem(self, name):
for toolitem in self._toolitems[name]:
toolitem.pack_forget()
del self._toolitems[name]
def set_message(self, s):
self._message.set(s)
@backend_tools._register_tool_class(FigureCanvasTk)
class SaveFigureTk(backend_tools.SaveFigureBase):
def trigger(self, *args):
NavigationToolbar2Tk.save_figure(
self._make_classic_style_pseudo_toolbar())
@backend_tools._register_tool_class(FigureCanvasTk)
class ConfigureSubplotsTk(backend_tools.ConfigureSubplotsBase):
def trigger(self, *args):
NavigationToolbar2Tk.configure_subplots(self)
@backend_tools._register_tool_class(FigureCanvasTk)
class HelpTk(backend_tools.ToolHelpBase):
def trigger(self, *args):
dialog = SimpleDialog(
self.figure.canvas._tkcanvas, self._get_help_text(), ["OK"])
dialog.done = lambda num: dialog.frame.master.withdraw()
Toolbar = ToolbarTk
FigureManagerTk._toolbar2_class = NavigationToolbar2Tk
FigureManagerTk._toolmanager_toolbar_class = ToolbarTk
@_Backend.export
class _BackendTk(_Backend):
FigureManager = FigureManagerTk
@classmethod
def new_figure_manager_given_figure(cls, num, figure):
"""
Create a new figure manager instance for the given figure.
"""
with _restore_foreground_window_at_end():
if cbook._get_running_interactive_framework() is None:
cbook._setup_new_guiapp()
_c_internal_utils.Win32_SetProcessDpiAwareness_max()
window = tk.Tk(className="matplotlib")
window.withdraw()
# Put a Matplotlib icon on the window rather than the default tk
# icon. See https://www.tcl.tk/man/tcl/TkCmd/wm.html#M50
#
# `ImageTk` can be replaced with `tk` whenever the minimum
# supported Tk version is increased to 8.6, as Tk 8.6+ natively
# supports PNG images.
icon_fname = str(cbook._get_data_path(
'images/matplotlib.png'))
icon_img = ImageTk.PhotoImage(file=icon_fname, master=window)
icon_fname_large = str(cbook._get_data_path(
'images/matplotlib_large.png'))
icon_img_large = ImageTk.PhotoImage(
file=icon_fname_large, master=window)
try:
window.iconphoto(False, icon_img_large, icon_img)
except Exception as exc:
# log the failure (due e.g. to Tk version), but carry on
_log.info('Could not load matplotlib icon: %s', exc)
canvas = cls.FigureCanvas(figure, master=window)
manager = cls.FigureManager(canvas, num, window)
if mpl.is_interactive():
manager.show()
canvas.draw_idle()
return manager
@staticmethod