tkwebui 0.3.2__py3-none-any.whl

tkwebui/popups.py

@@ -0,0 +1,173 @@
+"""Rounded context menus and ComboBox popups, retaining original widget APIs."""
+import tkinter as tk
+from tkinter import ttk, font as tkfont
+from .core import Card, ScrollArea, Modal, PALETTE
+from .tcl_bridge import unbind
+
+class ChoicePopup(tk.Toplevel):
+    def __init__(self,owner,items,x,y,*,width=180,selected=0,above=None):
+        self.owner=owner
+        self.host=owner.winfo_toplevel()
+        existing=getattr(self.host,'_choice_popup',None)
+        if existing is not None:existing.close()
+        self.previous_focus=owner.focus_get()
+        self.previous_grab=owner.grab_current()
+        super().__init__(self.host)
+        self.withdraw();self.overrideredirect(True);self.transient(self.host)
+        self.configure(background=PALETTE['bg'])
+        self.scale=owner.winfo_fpixels('1i')/96
+        self.corner_radius=5
+        self._closed=False;self._region_size=None;self._focus_job=None
+        self.host._choice_popup=self
+        self.items=items;self.rows=[];self.cursor=None
+        shell=Card(self,padding=6,border_color='#CCD1DC')
+        # Keep the one-pixel outline inside the native rounded window region.
+        shell.pack(fill='both',expand=True,padx=1,pady=1)
+        self.area=ScrollArea(shell);self.area.pack(fill='both',expand=True)
+        font=tkfont.nametofont('TkDefaultFont')
+        width=max(width,max((font.measure(str(item.get('label','')))+round(68*self.scale) for item in items),default=width))
+        height=round(22*self.scale)
+        for index,item in enumerate(items):
+            if item.get('separator'):
+                ttk.Separator(self.area.body).pack(fill='x',pady=round(5*self.scale))
+                self.rows.append(None);height+=round(11*self.scale);continue
+            text=('✓  ' if item.get('checked') else '    ')+str(item['label'])
+            button=ttk.Button(self.area.body,text=text,style='Popup.Quiet.TButton',command=lambda i=index:self.choose(i),takefocus=False)
+            if item.get('disabled'):button.state(['disabled'])
+            if item.get('checked'):button.configure(style='Checked.Popup.Quiet.TButton')
+            button.pack(fill='x',pady=1)
+            button.bind('<Enter>',lambda _,i=index:self.highlight(i))
+            self.rows.append(button);height+=button.winfo_reqheight()+2
+        from .extras import MenuPopup
+        # The owner may live on a different monitor from the root window.
+        left,top,right,bottom=MenuPopup.work_area(owner.winfo_rootx(),owner.winfo_rooty())
+        width=min(width,right-left-16)
+        height=min(height,round(430*self.scale),bottom-top-24)
+        if above is not None and y+height>bottom-8:y=above-height-4
+        x=max(left+8,min(x,right-width-8));y=max(top+8,min(y,bottom-height-8))
+        # Keep negative virtual-desktop coordinates relative to the origin,
+        # rather than asking Tk to offset from the right/bottom screen edge.
+        self.geometry(f'{int(width)}x{int(height)}+{int(x)}+{int(y)}')
+        self.bind('<Escape>',lambda _:self.close())
+        self.bind('<Up>',lambda _:self.move(-1));self.bind('<Down>',lambda _:self.move(1))
+        self.bind('<Home>',lambda _:self.highlight(self.enabled()[0]) if self.enabled() else 'break')
+        self.bind('<End>',lambda _:self.highlight(self.enabled()[-1]) if self.enabled() else 'break')
+        self.bind('<Return>',lambda _:self.choose(self.cursor))
+        self.bind('<Tab>',lambda _:self.close())
+        self.bind('<ButtonPress-1>',self.outside,add='+')
+        self.bind('<FocusOut>',self.defer_focus_check,add='+')
+        self._host_binding=self.host.bind('<Configure>',self.host_configured,add='+')
+        self.attributes('-topmost',True)
+        self.deiconify();self.update_idletasks()
+        Modal.round_corners(self)
+        self.lift();self.focus_force();self.grab_set()
+        self.highlight(selected if selected in self.enabled() else next(iter(self.enabled()),None))
+
+    def enabled(self):return [i for i,row in enumerate(self.rows) if row is not None and not row.instate(['disabled'])]
+    def highlight(self,index):
+        if index not in self.enabled():return 'break'
+        if self.cursor is not None:self.rows[self.cursor].state(['!active'])
+        self.cursor=index;row=self.rows[index];row.state(['active'])
+        self.update_idletasks()
+        canvas=self.area.canvas;total=max(1,self.area.body.winfo_reqheight())
+        first,last=canvas.yview()
+        y=row.winfo_y();end=y+row.winfo_height()
+        if y<first*total:canvas.yview_moveto(y/total)
+        elif end>last*total:canvas.yview_moveto((end-canvas.winfo_height())/total)
+        return 'break'
+    def move(self,delta):
+        enabled=self.enabled()
+        if enabled:self.highlight(enabled[(enabled.index(self.cursor)+delta)%len(enabled)] if self.cursor in enabled else enabled[0])
+        return 'break'
+    def choose(self,index):
+        if index not in self.enabled():return 'break'
+        action=self.items[index].get('command')
+        self.close()
+        if action:action()
+        return 'break'
+    def outside(self,event):
+        if not (self.winfo_rootx()<=event.x_root<self.winfo_rootx()+self.winfo_width() and self.winfo_rooty()<=event.y_root<self.winfo_rooty()+self.winfo_height()):self.close()
+    def host_configured(self,event):
+        if event.widget is self.host:self.close()
+    def defer_focus_check(self,event):
+        if not self._closed and self._focus_job is None:self._focus_job=self.after(100,self.check_focus)
+    def check_focus(self):
+        self._focus_job=None
+        if self._closed:return
+        focus=self.focus_get()
+        if focus is None or focus.winfo_toplevel() is not self:self.close(restore_focus=False)
+    def close(self,*,restore_focus=True):
+        if self._closed:return 'break'
+        self._closed=True
+        if self._focus_job is not None:self.after_cancel(self._focus_job)
+        unbind(self.host,'<Configure>',self._host_binding)
+        if getattr(self.host,'_choice_popup',None) is self:self.host._choice_popup=None
+        self.grab_release();super().destroy()
+        if self.previous_grab is not None and self.previous_grab.winfo_exists():self.previous_grab.grab_set()
+        if restore_focus:
+            target=self.previous_focus
+            if target is None or not target.winfo_exists() or not target.winfo_viewable():target=self.host
+            if target.winfo_exists():target.focus_force()
+        return 'break'
+    def destroy(self):self.close()
+
+class ThemedCombobox(ttk.Combobox):
+    """The native entry/current/values API with a replacement choice window."""
+    def __init__(self,master=None,**kw):
+        super().__init__(master,**kw)
+        self.popup=None
+        self.bind('<ButtonPress-1>',self.click,add='+')
+        self.bind('<Down>',self.post_from_event)
+        self.bind('<Alt-Down>',self.post_from_event)
+        self.bind('<F4>',self.post_from_event)
+        self.bind('<Destroy>',self.cleanup,add='+')
+    def click(self,event):
+        if self.instate(['disabled']):return 'break'
+        if self.instate(['readonly']) or 'downarrow' in self.identify(event.x,event.y):return self.post_from_event()
+    def post_from_event(self,event=None):
+        try:self.open_popup()
+        except Exception:
+            import sys
+            self._root().report_callback_exception(*sys.exc_info())
+        # Never run the native TCombobox post binding, even on a failed custom
+        # callback. Otherwise a second, unthemed popup opens underneath it.
+        return 'break'
+    def open_popup(self,event=None):
+        if self.instate(['disabled']):return 'break'
+        if self.popup is not None and not self.popup._closed:self.popup.close();return 'break'
+        # cget may return a truthy Tcl_Obj whose string value is empty after
+        # the first selection. Normalize before testing/evaluating the script.
+        command=str(self.cget('postcommand')).strip()
+        if command:self.tk.call('uplevel','#0',command)
+        values=self.cget('values')
+        if not values:return 'break'
+        current=self.current()
+        items=[dict(label=value,checked=index==current,command=lambda i=index:self.choose(i)) for index,value in enumerate(values)]
+        self.popup=ChoicePopup(self,items,self.winfo_rootx(),self.winfo_rooty()+self.winfo_height()+4,
+                               width=self.winfo_width(),selected=max(0,current),above=self.winfo_rooty())
+        return 'break'
+    def choose(self,index):
+        self.current(index)
+        self.event_generate('<<ComboboxSelected>>',when='tail')
+    def cleanup(self,event):
+        if event.widget is self and self.popup is not None and not self.popup._closed:self.popup.close()
+
+class ThemedMenu(tk.Menu):
+    """Keep Tcl's menu model/invoke/checkbutton semantics; replace its popup."""
+    def __init__(self,*args,**kw):
+        super().__init__(*args,**kw);self.popup=None
+    def tk_popup(self,x,y,entry='',*,owner=None,min_width=190):
+        from .extras import MenuPopup
+        if self.index('end') is None and not str(self.cget('postcommand')).strip():return
+        if self.popup is not None and not self.popup._closed:self.popup.close()
+        selected=None if entry=='' else self.index(entry)
+        self.popup=MenuPopup(owner or self.master,self,x,y,min_width=min_width,selected=selected)
+    post=tk_popup
+    def unpost(self):
+        if self.popup is not None:self.popup.close()
+    def grab_release(self):
+        # Legacy callers use finally: menu.grab_release(). The custom popup
+        # owns its own grab until selection/dismissal, and restores it itself.
+        pass
+    def destroy(self):
+        self.unpost();super().destroy()

tkwebui/render.py

@@ -0,0 +1,198 @@
+"""Antialiased in-memory shapes for Tk PhotoImage. No third-party dependencies.
+
+Windows uses the OS GDI+ renderer. Other platforms use a pixel-coverage fallback.
+Text, events, axes and hit testing stay in Tk; no browser or external image files.
+"""
+import atexit
+import ctypes
+import math
+import struct
+import sys
+import tkinter as tk
+import zlib
+
+_gdip=None
+_token=None
+
+class _Point(ctypes.Structure):
+    _fields_=[('x',ctypes.c_float),('y',ctypes.c_float)]
+
+def _windows_api():
+    global _gdip,_token
+    if _gdip is not None:return _gdip
+    dll=ctypes.WinDLL('gdiplus')
+    pointer=ctypes.c_void_p;integer=ctypes.c_int;real=ctypes.c_float
+    class Startup(ctypes.Structure):
+        _fields_=[('version',ctypes.c_uint32),('callback',pointer),('background',integer),('codecs',integer)]
+    signatures={
+        'GdiplusStartup':([ctypes.POINTER(ctypes.c_size_t),ctypes.POINTER(Startup),pointer],integer),
+        'GdiplusShutdown':([ctypes.c_size_t],None),
+        'GdipCreateBitmapFromScan0':([integer,integer,integer,integer,pointer,ctypes.POINTER(pointer)],integer),
+        'GdipGetImageGraphicsContext':([pointer,ctypes.POINTER(pointer)],integer),
+        'GdipSetSmoothingMode':([pointer,integer],integer),
+        'GdipSetPixelOffsetMode':([pointer,integer],integer),
+        'GdipCreateSolidFill':([ctypes.c_uint32,ctypes.POINTER(pointer)],integer),
+        'GdipCreatePen1':([ctypes.c_uint32,real,integer,ctypes.POINTER(pointer)],integer),
+        'GdipSetPenStartCap':([pointer,integer],integer),
+        'GdipSetPenEndCap':([pointer,integer],integer),
+        'GdipSetPenLineJoin':([pointer,integer],integer),
+        'GdipDrawLines':([pointer,pointer,ctypes.POINTER(_Point),integer],integer),
+        'GdipDrawEllipse':([pointer,pointer,real,real,real,real],integer),
+        'GdipFillEllipse':([pointer,pointer,real,real,real,real],integer),
+        'GdipDrawArc':([pointer,pointer,real,real,real,real,real,real],integer),
+        'GdipFillPie':([pointer,pointer,real,real,real,real,real,real],integer),
+        'GdipFillRectangle':([pointer,pointer,real,real,real,real],integer),
+        'GdipFlush':([pointer,integer],integer),
+        'GdipDeleteBrush':([pointer],integer),'GdipDeletePen':([pointer],integer),
+        'GdipDeleteGraphics':([pointer],integer),'GdipDisposeImage':([pointer],integer),
+    }
+    for name,(args,result) in signatures.items():
+        fn=getattr(dll,name);fn.argtypes=args;fn.restype=result
+    token=ctypes.c_size_t()
+    if dll.GdiplusStartup(ctypes.byref(token),ctypes.byref(Startup(1,None,0,0)),None):raise OSError('GDI+ startup failed')
+    _token=token;_gdip=dll;atexit.register(dll.GdiplusShutdown,token)
+    return dll
+
+def _png(width,height,rgba):
+    def chunk(name,data):return struct.pack('>I',len(data))+name+data+struct.pack('>I',zlib.crc32(name+data)&0xffffffff)
+    stride=width*4
+    raw=b''.join(b'\0'+rgba[y*stride:(y+1)*stride] for y in range(height))
+    return b'\x89PNG\r\n\x1a\n'+chunk(b'IHDR',struct.pack('>IIBBBBB',width,height,8,6,0,0,0))+chunk(b'IDAT',zlib.compress(raw,2))+chunk(b'IEND',b'')
+
+class SmoothImage:
+    """A short-lived drawing surface. Keep the returned PhotoImage alive in Tk."""
+    def __init__(self,master,width,height,*,software=False):
+        self.master=master;self.width=max(1,int(math.ceil(width)));self.height=max(1,int(math.ceil(height)))
+        self.api=None;self.bitmap=ctypes.c_void_p();self.graphics=ctypes.c_void_p()
+        self.pens={};self.brushes={};self.colors={};self.closed=False
+        if sys.platform=='win32' and not software:
+            try:
+                self.api=_windows_api()
+                self.buffer=(ctypes.c_ubyte*(self.width*self.height*4))()
+                self._check(self.api.GdipCreateBitmapFromScan0(self.width,self.height,self.width*4,0x26200A,self.buffer,ctypes.byref(self.bitmap)))
+                self._check(self.api.GdipGetImageGraphicsContext(self.bitmap,ctypes.byref(self.graphics)))
+                self._check(self.api.GdipSetSmoothingMode(self.graphics,5)) # 8 x 8 edge coverage
+                self._check(self.api.GdipSetPixelOffsetMode(self.graphics,4))
+            except (OSError,AttributeError):
+                if self.graphics:self.api.GdipDeleteGraphics(self.graphics)
+                if self.bitmap:self.api.GdipDisposeImage(self.bitmap)
+                self.api=None
+        if self.api is None:self.buffer=bytearray(self.width*self.height*4)
+        self.backend='gdi+' if self.api else 'coverage'
+    @staticmethod
+    def _check(status):
+        if status:raise OSError(f'GDI+ status {status}')
+    def _color(self,color):
+        if color not in self.colors:
+            self.colors[color]=tuple(round(c/257) for c in self.master.winfo_rgb(color))
+        return self.colors[color]
+    def _argb(self,color):
+        r,g,b=self._color(color);return 0xff000000|(r<<16)|(g<<8)|b
+    def _pen(self,color,width):
+        key=(color,width)
+        if key not in self.pens:
+            pen=ctypes.c_void_p();self._check(self.api.GdipCreatePen1(self._argb(color),width,2,ctypes.byref(pen)))
+            self.api.GdipSetPenStartCap(pen,2);self.api.GdipSetPenEndCap(pen,2);self.api.GdipSetPenLineJoin(pen,2)
+            self.pens[key]=pen
+        return self.pens[key]
+    def _brush(self,color):
+        if color not in self.brushes:
+            brush=ctypes.c_void_p();self._check(self.api.GdipCreateSolidFill(self._argb(color),ctypes.byref(brush)));self.brushes[color]=brush
+        return self.brushes[color]
+    def _blend(self,x,y,rgb,coverage):
+        if coverage<=0:return
+        coverage=min(1,coverage);i=(y*self.width+x)*4;buf=self.buffer
+        if coverage>=1:buf[i:i+4]=bytes((*rgb,255));return
+        old=buf[i+3]/255;alpha=coverage+old*(1-coverage)
+        if not alpha:return
+        for c in range(3):buf[i+c]=round((rgb[c]*coverage+buf[i+c]*old*(1-coverage))/alpha)
+        buf[i+3]=round(alpha*255)
+    def _paint(self,bounds,color,coverage):
+        x1,y1,x2,y2=bounds;rgb=self._color(color)
+        for y in range(max(0,math.floor(y1)),min(self.height,math.ceil(y2))):
+            for x in range(max(0,math.floor(x1)),min(self.width,math.ceil(x2))):
+                self._blend(x,y,rgb,coverage(x+.5,y+.5))
+    def line(self,points,color,width=1):
+        if len(points)<4:return
+        if self.api:
+            values=(_Point*(len(points)//2))(*[_Point(points[i],points[i+1]) for i in range(0,len(points),2)])
+            self._check(self.api.GdipDrawLines(self.graphics,self._pen(color,width),values,len(values)));return
+        radius=width/2
+        for i in range(0,len(points)-2,2):
+            x1,y1,x2,y2=points[i:i+4];dx=x2-x1;dy=y2-y1;square=dx*dx+dy*dy
+            def coverage(x,y):
+                t=max(0,min(1,((x-x1)*dx+(y-y1)*dy)/square)) if square else 0
+                return max(0,min(1,radius+.5-math.hypot(x-x1-t*dx,y-y1-t*dy)))
+            self._paint((min(x1,x2)-radius-1,min(y1,y2)-radius-1,max(x1,x2)+radius+1,max(y1,y2)+radius+1),color,coverage)
+    def ellipse(self,bounds,*,fill=None,outline=None,width=1):
+        x1,y1,x2,y2=bounds
+        if self.api:
+            if fill:self._check(self.api.GdipFillEllipse(self.graphics,self._brush(fill),x1,y1,x2-x1,y2-y1))
+            if outline:self._check(self.api.GdipDrawEllipse(self.graphics,self._pen(outline,width),x1,y1,x2-x1,y2-y1))
+            return
+        cx=(x1+x2)/2;cy=(y1+y2)/2;rx=max(.001,(x2-x1)/2);ry=max(.001,(y2-y1)/2);r=min(rx,ry)
+        def distance(x,y):return (math.hypot((x-cx)/rx,(y-cy)/ry)-1)*r
+        if fill:self._paint((x1-1,y1-1,x2+1,y2+1),fill,lambda x,y:max(0,min(1,.5-distance(x,y))))
+        if outline:self._paint((x1-width,y1-width,x2+width,y2+width),outline,lambda x,y:max(0,min(1,width/2+.5-abs(distance(x,y)))))
+    def arc(self,bounds,start,sweep,color,width=1):
+        if sweep<=0:return
+        if sweep>=359.999:self.ellipse(bounds,outline=color,width=width);return
+        x1,y1,x2,y2=bounds
+        if self.api:
+            self._check(self.api.GdipDrawArc(self.graphics,self._pen(color,width),x1,y1,x2-x1,y2-y1,start,sweep));return
+        cx=(x1+x2)/2;cy=(y1+y2)/2;radius=(x2-x1)/2
+        a=math.radians(start);b=math.radians(start+sweep)
+        ends=[(cx+radius*math.cos(angle),cy+radius*math.sin(angle)) for angle in (a,b)]
+        def coverage(x,y):
+            angle=(math.degrees(math.atan2(y-cy,x-cx))-start)%360
+            distance=abs(math.hypot(x-cx,y-cy)-radius) if angle<=sweep else min(math.hypot(x-ex,y-ey) for ex,ey in ends)
+            return max(0,min(1,width/2+.5-distance))
+        self._paint((x1-width,y1-width,x2+width,y2+width),color,coverage)
+    def pie(self,bounds,start,sweep,color):
+        if sweep<=0:return
+        if sweep>=359.999:self.ellipse(bounds,fill=color);return
+        x1,y1,x2,y2=bounds
+        if self.api:
+            self._check(self.api.GdipFillPie(self.graphics,self._brush(color),x1,y1,x2-x1,y2-y1,start,sweep));return
+        cx=(x1+x2)/2;cy=(y1+y2)/2;radius=(x2-x1)/2
+        def coverage(x,y):
+            hits=0
+            for dx,dy in ((-.25,-.25),(.25,-.25),(-.25,.25),(.25,.25)):
+                angle=(math.degrees(math.atan2(y+dy-cy,x+dx-cx))-start)%360
+                hits+=math.hypot(x+dx-cx,y+dy-cy)<=radius and angle<=sweep
+            return hits/4
+        self._paint((x1-1,y1-1,x2+1,y2+1),color,coverage)
+    def rectangle(self,bounds,color):
+        x1,y1,x2,y2=bounds
+        if self.api:self._check(self.api.GdipFillRectangle(self.graphics,self._brush(color),x1,y1,x2-x1,y2-y1));return
+        self._paint(bounds,color,lambda x,y:1)
+    def rgba(self):
+        if not self.api:return bytes(self.buffer)
+        self._check(self.api.GdipFlush(self.graphics,1))
+        bgra=bytes(self.buffer);rgba=bytearray(len(bgra))
+        rgba[0::4]=bgra[2::4];rgba[1::4]=bgra[1::4];rgba[2::4]=bgra[0::4];rgba[3::4]=bgra[3::4]
+        return bytes(rgba)
+    def photo(self):return tk.PhotoImage(master=self.master,data=_png(self.width,self.height,self.rgba()),format='png')
+    def close(self):
+        if self.closed:return
+        self.closed=True
+        if self.api:
+            for pen in self.pens.values():self.api.GdipDeletePen(pen)
+            for brush in self.brushes.values():self.api.GdipDeleteBrush(brush)
+            self.api.GdipDeleteGraphics(self.graphics);self.api.GdipDisposeImage(self.bitmap)
+    def __enter__(self):return self
+    def __exit__(self,*_):self.close()
+
+def calendar_icon(master,size,color='#697180'):
+    root=master._root();cache=getattr(root,'_web_calendar_icons',None)
+    if cache is None:cache=root._web_calendar_icons={}
+    key=(size,color)
+    if key not in cache:
+        scale=size/24
+        with SmoothImage(root,size,size) as image:
+            def line(coords):image.line([v*scale for v in coords],color,max(1,1.5*scale))
+            line([4,6,20,6,20,21,4,21,4,6]);line([4,10,20,10]);line([8,3,8,8]);line([16,3,16,8])
+            for y in (13,17):
+                for x in (7,11,15):image.rectangle((x*scale,y*scale,(x+2)*scale,(y+2)*scale),color)
+            cache[key]=image.photo()
+    return cache[key]

tkwebui/scrolling.py

@@ -0,0 +1,73 @@
+"""Scrollbars that occupy layout space only while their viewport overflows."""
+import tkinter as tk
+from tkinter import ttk
+
+
+class AutoScrollbar(ttk.Scrollbar):
+    """Use with grid() and a widget's x/yscrollcommand, just like ttk.Scrollbar.
+
+    Starts hidden. Tk's viewport fractions determine visibility after content
+    changes, scrolling and resizing. grid_remove preserves the layout options.
+    """
+    def __init__(self, master=None, **kwargs):
+        super().__init__(master, **kwargs)
+        self._needed = False
+        self._laid_out = False
+        self._visibility_job = None
+        self.bind('<Destroy>', self._cleanup, add='+')
+
+    def grid(self, *args, **kwargs):
+        super().grid(*args, **kwargs)
+        self._laid_out = True
+        if not self._needed:
+            super().grid_remove()
+    grid_configure = grid
+
+    def set(self, first, last):
+        super().set(first, last)
+        self._needed = float(first) > 1e-7 or float(last) < 1-1e-7
+        if self._visibility_job is None:
+            self._visibility_job = self.after_idle(self._sync)
+
+    def _sync(self):
+        self._visibility_job = None
+        if self._laid_out:
+            if self._needed and not self.winfo_manager():
+                super().grid()
+            elif not self._needed and self.winfo_manager():
+                super().grid_remove()
+
+    def pack(self, *args, **kwargs):
+        raise tk.TclError('AutoScrollbar uses grid(); place it in a Frame if the outer layout uses pack().')
+    pack_configure = pack
+    place = pack
+    place_configure = pack
+
+    def _cleanup(self, event):
+        if event.widget is self and self._visibility_job is not None:
+            self.after_cancel(self._visibility_job)
+            self._visibility_job = None
+
+
+def _attach_scrollbars(widget, container):
+    """Add internal bars without taking over caller-supplied scroll commands."""
+    widget._auto_scrollbars = {}
+    for axis, options in [('y', dict(row=0, column=1, sticky='ns')),
+                          ('x', dict(row=1, column=0, sticky='ew'))]:
+        option = axis+'scrollcommand'
+        if widget.cget(option):
+            continue
+        bar = AutoScrollbar(container, orient='vertical' if axis=='y' else 'horizontal',
+                            command=getattr(widget, axis+'view'))
+        bar.grid(**options)
+        # Bypass subclass configure: this installs, rather than replaces, bars.
+        tk.Widget.configure(widget, **{option: bar.set})
+        widget._auto_scrollbars[option] = bar
+
+
+def _release_scrollbars(widget, options):
+    # Existing applications can still connect their own external scrollbar.
+    for option in options:
+        bar = getattr(widget, '_auto_scrollbars', {}).pop(option, None)
+        if bar is not None:
+            bar.destroy()