Skip to content

Transform your 3D texturing workflow with the power of generative AI, directly within Blender!

give the panel Blender's number fields and a draggable scrollbar

sakalond67b6429f744a
diff --git a/stablegen/ui/studio.py b/stablegen/ui/studio.py
index 4a8954d..d0e6bf7 100644
--- a/stablegen/ui/studio.py
+++ b/stablegen/ui/studio.py
@@ -219,6 +219,10 @@ class StudioSession:
self.last_refresh = 0
self.edit = None
self.drag = None
+ # Part of the hovered number button under the pointer, and the page scrollbar's (top, height, grip
+ # height, grip top) from the last draw.
+ self.hover_zone = None
+ self.scrollbar = None
self.camera_drag = None
self.camera_rows = []
self.camera_clip = None
@@ -322,7 +326,7 @@ class StudioSession:
if self.camera_drag or self.drag or self.edit and self.edit['selecting']:
self.clear_hover()
if cursor:
- self.set_cursor('MOVE_Y' if self.camera_drag else 'MOVE_X' if self.drag else 'TEXT')
+ self.set_cursor('MOVE_Y' if self.camera_drag else self.drag_cursor() if self.drag else 'TEXT')
return None
if not inside:
self.clear_hover()
@@ -339,10 +343,20 @@ class StudioSession:
self.hover_signature = signature
if target:
self.area.tag_redraw()
+ zone = (target.number_zone(self.pointer[0])
+ if target and isinstance(target.action, tuple) and target.action[0] == 'number' else None)
+ if zone != self.hover_zone:
+ self.hover_zone = zone
+ self.area.tag_redraw()
if cursor:
- self.set_cursor('MOVE_X' if self.drag else target.cursor if target else 'DEFAULT')
+ self.set_cursor(target.cursor if target else 'DEFAULT')
return target
+ def drag_cursor(self):
+ # Blender hides the pointer while a number is dragged (it wraps at the window edge, see scrub).
+ kind = self.drag.get('kind', 'slider')
+ return 'MOVE_X' if kind == 'slider' else 'NONE' if kind == 'number' and self.drag['moved'] else 'DEFAULT'
+
def tooltip_target(self, targets=None):
if (not bpy.context.preferences.view.show_tooltips or self.camera_drag or self.drag or self.popup
or self.notice and time.monotonic() < self.notice_until):
@@ -497,7 +511,8 @@ class StudioSession:
binding = target.action[1]
with _context(self):
value = self.query if binding is None else binding.value(bpy.context)
- buffer = TextBuffer(str(value))
+ # Floats open for typing as Blender shows them: six decimals at most, trailing zeros dropped.
+ buffer = TextBuffer(f'{value:.6f}'.rstrip('0').rstrip('.') if isinstance(value, float) else str(value))
if select:
buffer.anchor = 0
self.edit = {'key': target.key, 'binding': binding, 'buffer': buffer,
@@ -585,6 +600,26 @@ class StudioSession:
self.drag = {'binding': action[1], 'min': action[2], 'max': action[3],
'rect': target.rect, 'before': before}
self.slide(self.pointer[0])
+ elif action[0] == 'number':
+ # Like Blender, a press waits: a drag past the threshold scrubs, a click steps from an arrow or
+ # starts typing in the middle (see scrub and finish_drag).
+ self.commit()
+ with _context(self):
+ before = action[1].value(bpy.context)
+ self.drag = {'kind': 'number', 'key': target.key, 'target': target, 'binding': action[1],
+ 'before': before, 'zone': target.number_zone(self.pointer[0]), 'press': self.mouse,
+ 'start': self.mouse[0], 'wrap': 0, 'moved': False}
+ elif action[0] == 'scrollbar' and self.scrollbar:
+ self.commit()
+ top, height, grip, grip_top = self.scrollbar
+ y = self.pointer[1]
+ before = self.scroll.get(self.page, 0)
+ if not grip_top <= y <= grip_top + grip:
+ # A press beside the grip jumps it there, then keeps dragging, as in Blender's scrollbars.
+ travel = max(1, height - grip)
+ self.scroll[self.page] = max(0, min(self.max_scroll, (y - grip / 2 - top) / travel * self.max_scroll))
+ grip_top = y - grip / 2
+ self.drag = {'kind': 'scroll', 'offset': y - grip_top, 'before': before}
elif action[0] == 'camera-drag':
self.commit()
self.camera_drag = {'name': action[1], 'names': tuple(c.name for c in self.ordered_cameras())}
@@ -617,6 +652,112 @@ class StudioSession:
value = drag['min'] + max(0, min(1, (x - left) / width)) * (drag['max'] - drag['min'])
self.set_value(drag['binding'], value, undo=False)
+ def drag_move(self, event):
+ kind = self.drag.get('kind', 'slider')
+ if kind == 'scroll':
+ top, height, grip, _ = self.scrollbar or (0, 1, 1, 0)
+ travel = max(1, height - grip)
+ position = (self.pointer[1] - self.drag['offset'] - top) / travel * self.max_scroll
+ self.scroll[self.page] = max(0, min(self.max_scroll, position))
+ self.area.tag_redraw()
+ elif kind == 'number':
+ self.scrub(event)
+ else:
+ self.slide(self.pointer[0])
+ self.clear_hover()
+ self.set_cursor(self.drag_cursor())
+
+ def scrub(self, event):
+ """Blender's number drag: a threshold, then a linear change per pixel with the pointer hidden and
+ wrapped at the window edge, Shift for precision and Ctrl (Ctrl+Shift) for snapping."""
+ drag = self.drag
+ mouse_x = event.mouse_x
+ x = mouse_x + drag['wrap']
+ if drag['moved']:
+ width = self.window.width
+ if mouse_x <= 1 or mouse_x >= width - 2:
+ wrapped = width - 3 if mouse_x <= 1 else 2
+ drag['wrap'] += mouse_x - wrapped
+ self.window.cursor_warp(wrapped, event.mouse_y)
+ if not drag['moved']:
+ if abs(x - drag['start']) <= 3 * self.scale:
+ return
+ drag['moved'], drag['start'] = True, x
+ ctrl = event.ctrl or event.oskey
+ with _context(self):
+ prop = drag['binding'].rna(bpy.context)
+ value, shift = model.number_drag(prop, drag['before'], x - drag['start'], precise=event.shift,
+ snap=('SMALL' if event.shift else 'ON') if ctrl else None)
+ drag['start'] += shift
+ self.set_value(drag['binding'], value, undo=False)
+
+ def step_number(self, binding, direction):
+ with _context(self):
+ value = model.stepped_number(binding.rna(bpy.context), binding.value(bpy.context), direction)
+ self.set_value(binding, value)
+
+ def finish_drag(self, cancel=False):
+ drag, self.drag = self.drag, None
+ kind = drag.get('kind', 'slider')
+ if kind == 'scroll':
+ if cancel:
+ self.scroll[self.page] = drag['before']
+ elif kind == 'number' and not drag['moved']:
+ if not cancel and drag['zone'] == 'middle':
+ self.begin_edit(drag['target'], select=True)
+ elif not cancel:
+ self.step_number(drag['binding'], -1 if drag['zone'] == 'left' else 1)
+ else:
+ if kind == 'number':
+ # The hidden pointer comes back where the drag began.
+ self.window.cursor_warp(*drag['press'])
+ self.mouse = drag['press']
+ _window_mouse[self.key[0]] = self.mouse
+ if cancel:
+ self.set_value(drag['binding'], drag['before'], undo=False)
+ else:
+ with _context(self):
+ if drag['binding'].value(bpy.context) != drag['before']:
+ _undo('Adjust ' + drag['binding'].rna(bpy.context).name)
+ self.area.tag_redraw()
+ self.update_hover()
+
+ def number_key(self, event):
+ """Blender's keys over a hovered number button: Ctrl+Wheel steps, Enter types, Ctrl+C/Ctrl+V copy and
+ paste, Backspace resets to the default and Minus negates."""
+ target = self.hit_target()
+ if (event.value != 'PRESS' or not target or not target.enabled or not isinstance(target.action, tuple)
+ or target.action[0] != 'number'):
+ return False
+ binding, ctrl = target.action[1], event.ctrl or event.oskey
+ if event.type in {'WHEELUPMOUSE', 'WHEELDOWNMOUSE'} and event.ctrl:
+ self.step_number(binding, 1 if event.type == 'WHEELUPMOUSE' else -1)
+ elif event.type in {'RET', 'NUMPAD_ENTER'} and not ctrl:
+ self.begin_edit(target, select=True)
+ elif ctrl and event.type == 'C':
+ with _context(self):
+ value = binding.value(bpy.context)
+ self.window_manager.clipboard = (f'{value:.6f}'.rstrip('0').rstrip('.') if isinstance(value, float)
+ else str(value))
+ elif ctrl and event.type == 'V':
+ try:
+ value = float(self.window_manager.clipboard.strip())
+ except ValueError:
+ return True
+ self.set_value(binding, value)
+ elif event.type == 'BACK_SPACE' and not ctrl:
+ with _context(self):
+ default = binding.rna(bpy.context).default
+ self.set_value(binding, default)
+ elif event.type in {'MINUS', 'NUMPAD_MINUS'} and not ctrl:
+ with _context(self):
+ value = binding.value(bpy.context)
+ self.set_value(binding, -value)
+ else:
+ return False
+ self.area.tag_redraw()
+ return True
+
def ordered_cameras(self):
from ..texturing.view_plan import order_cameras
scene = bpy.context.scene
@@ -715,11 +856,15 @@ class StudioSession:
elif key in {'BACK_SPACE', 'DEL'}:
buffer.delete(backward=key == 'BACK_SPACE', word=ctrl)
elif key == 'TAB':
- candidates = [t for t in self.targets if t.enabled and isinstance(t.action, tuple) and t.action[0] in {'edit', 'enum', 'toggle'}]
+ candidates = [t for t in self.targets if t.enabled and isinstance(t.action, tuple) and t.action[0] in {'edit', 'number', 'enum', 'toggle'}]
index = next((i for i, target in enumerate(candidates) if target.key == edit['key']), -1)
self.commit()
if candidates:
- self.activate(candidates[(index + (-1 if event.shift else 1)) % len(candidates)])
+ target = candidates[(index + (-1 if event.shift else 1)) % len(candidates)]
+ if target.action[0] == 'number':
+ self.begin_edit(target, select=True)
+ else:
+ self.activate(target)
elif getattr(event, 'unicode', '') and not ctrl and not event.alt:
buffer.replace(event.unicode)
else:
@@ -771,10 +916,8 @@ class StudioSession:
return {'RUNNING_MODAL'}
# Keep shortcuts and other commands from changing the scene mid-drag.
return {'RUNNING_MODAL'}
- if event.value == 'PRESS' and event.type == 'ESC' and self.drag:
- drag, self.drag = self.drag, None
- self.set_value(drag['binding'], drag['before'], undo=False)
- self.update_hover()
+ if event.value == 'PRESS' and event.type in {'ESC', 'RIGHTMOUSE'} and self.drag:
+ self.finish_drag(cancel=True)
return {'RUNNING_MODAL'}
if self.edit and event.value == 'PRESS' and (event.ctrl or event.oskey) and event.type == 'S':
self.commit()
@@ -782,9 +925,7 @@ class StudioSession:
return {'PASS_THROUGH'}
if event.type in {'MOUSEMOVE', 'INBETWEEN_MOUSEMOVE'}:
if self.drag:
- self.slide(x)
- self.clear_hover()
- self.set_cursor('MOVE_X')
+ self.drag_move(event)
return {'RUNNING_MODAL'}
if self.edit and self.edit['selecting']:
self.select_caret(x, y, extend=True)
@@ -801,11 +942,7 @@ class StudioSession:
self.clear_hover()
if event.type == 'LEFTMOUSE' and event.value == 'RELEASE':
if self.drag:
- drag, self.drag = self.drag, None
- with _context(self):
- if drag['binding'].value(bpy.context) != drag['before']:
- _undo('Adjust ' + drag['binding'].rna(bpy.context).name)
- self.update_hover()
+ self.finish_drag()
return {'RUNNING_MODAL'}
if self.edit:
self.edit['selecting'] = False
@@ -849,6 +986,8 @@ class StudioSession:
self.menu['index'] = self.menu['scroll'] = 0
self.area.tag_redraw()
return {'RUNNING_MODAL'}
+ if not self.edit and not self.menu and self.number_key(event):
+ return {'RUNNING_MODAL'}
if event.type in {'WHEELUPMOUSE', 'WHEELDOWNMOUSE', 'TRACKPADPAN'}:
self.clear_hover()
change = -45 if event.type == 'WHEELUPMOUSE' else 45
@@ -910,6 +1049,10 @@ class StudioSession:
def hovered(self, key):
return key == self.hover_key
+ def number_state(self, key):
+ drag = self.drag if self.drag and self.drag.get('key') == key else None
+ return {'zone': self.hover_zone if self.hovered(key) else None, 'dragging': bool(drag and drag['moved'])}
+
def draw_binding(self, painter, binding, label, x, y, width, *, enabled=True, multiline=False, height=112, corners='ALL'):
ctx = bpy.context
prop, value = binding.rna(ctx), binding.value(ctx)
@@ -977,10 +1120,14 @@ class StudioSession:
filepath = prop.type == 'STRING' and prop.subtype in {'FILE_PATH', 'DIR_PATH'}
field_width = 90 if inline else width - 27 if filepath else width
field_x = x + width - field_width if inline else x
- lines, scroll = painter.text_field(key, (field_x, y, field_width, CONTROL_HEIGHT), display,
- ('edit', binding, False), enabled=enabled, hint=hint,
- editing=editing['buffer'] if editing else None,
- kind='number' if prop.type in {'INT','FLOAT'} else 'field')
+ if prop.type in {'INT', 'FLOAT'} and not editing:
+ painter.number_field(key, (field_x, y, field_width, CONTROL_HEIGHT), display,
+ ('number', binding, False), enabled=enabled, hint=hint, **self.number_state(key))
+ else:
+ lines, scroll = painter.text_field(key, (field_x, y, field_width, CONTROL_HEIGHT), display,
+ ('edit', binding, False), enabled=enabled, hint=hint,
+ editing=editing['buffer'] if editing else None,
+ kind='number' if prop.type in {'INT','FLOAT'} else 'field')
if editing:
editing.update(rect=(field_x, y, field_width, CONTROL_HEIGHT), lines=lines, scroll=scroll)
if filepath:
@@ -1021,16 +1168,19 @@ class StudioSession:
precision = binding.rna(bpy.context).precision
number = f'{value:.{precision}f}'
display = editing['buffer'].text if editing else (number.rstrip('0').rstrip('.') if precision else number) + unit
- lines, scroll = p.text_field(key, (ex, ey, edit_width, CONTROL_HEIGHT), display, ('edit', binding, False),
- enabled=enabled, hint=binding.rna(bpy.context).description,
- editing=editing['buffer'] if editing else None, kind='number')
if editing:
+ lines, scroll = p.text_field(key, (ex, ey, edit_width, CONTROL_HEIGHT), display, ('edit', binding, False),
+ enabled=enabled, hint=binding.rna(bpy.context).description,
+ editing=editing['buffer'], kind='number')
editing.update(rect=(ex, ey, edit_width, CONTROL_HEIGHT), lines=lines, scroll=scroll)
+ else:
+ p.number_field(key, (ex, ey, edit_width, CONTROL_HEIGHT), display, ('number', binding, False),
+ enabled=enabled, hint=binding.rna(bpy.context).description, **self.number_state(key))
track_y = y + (46 if narrow else 27)
p.rect(x, track_y, width, 3, 'line', 1)
fill = max(0, min(1, (value - minimum) / (maximum - minimum)))
p.rect(x, track_y, width * fill, 3, 'blue', 1)
- radius = 5 if enabled and (self.hovered(key + ':slider') or self.drag and self.drag['binding'] == binding) else 4
+ radius = 5 if enabled and (self.hovered(key + ':slider') or self.drag and self.drag.get('binding') == binding) else 4
p.rect(x + width * fill - radius, track_y + 1 - radius, radius * 2, radius * 2,
'accent' if enabled else 'disabled', radius)
p.target(key + ':slider', (x, track_y - 7, width, 17), ('slider', binding, minimum, maximum),
@@ -2179,10 +2329,20 @@ class StudioSession:
if offset > self.max_scroll:
self.scroll[self.page] = self.max_scroll
self.area.tag_redraw()
+ self.scrollbar = None
if self.max_scroll:
available = bottom - top
thumb = max(24, available * available / (available + self.max_scroll))
- p.rect(p.width - 5, top + offset / self.max_scroll * max(0, available - thumb), 2, thumb, 'muted', 1)
+ thumb_y = top + min(offset, self.max_scroll) / self.max_scroll * max(0, available - thumb)
+ self.scrollbar = (top, available, thumb, thumb_y)
+ dragging = bool(self.drag and self.drag.get('kind') == 'scroll')
+ if dragging or self.hovered('scrollbar'):
+ # At rest the bar stays a hairline; under the pointer it widens like Blender's.
+ p.rect(p.width - 10, top + 2, 8, available - 4, 'scroll_track', 4)
+ p.rect(p.width - 9, thumb_y + 1, 6, thumb - 2, 'text' if dragging else 'secondary', 3)
+ else:
+ p.rect(p.width - 5, thumb_y, 2, thumb, 'muted', 1)
+ p.target('scrollbar', (p.width - 12, top, 12, available), ('scrollbar',))
p.clip(None)
if not tips.dismissed(tips.WIDEN_CALLOUT):
if self.callout_width is not None and width > self.callout_width + 20:
diff --git a/stablegen/ui/studio_model.py b/stablegen/ui/studio_model.py
index 7dd1920..cde00f0 100644
--- a/stablegen/ui/studio_model.py
+++ b/stablegen/ui/studio_model.py
@@ -1,6 +1,7 @@
"""Live RNA bindings for the custom Studio sidebar; no generation logic."""
from dataclasses import dataclass
import json
+import math
from pathlib import Path
import bpy
@@ -35,6 +36,63 @@ def operator(name):
return getattr(getattr(bpy.ops, namespace), identifier)
+# Number buttons follow Blender's own (interface_handlers.cc: ui_do_but_NUM, ui_numedit_but_NUM and its
+# snapping helpers) so the panel's fields respond exactly like native ones.
+def _soft_range(prop):
+ return max(prop.soft_min, prop.hard_min), min(prop.soft_max, prop.hard_max)
+
+
+def _round(value):
+ """C's roundf: halves away from zero."""
+ return math.copysign(math.floor(abs(value) + .5), value)
+
+
+def number_step(prop):
+ """The arrow and Ctrl+Wheel increment: an int's step, or a float's step in hundredths."""
+ return prop.step * .01 if prop.type == 'FLOAT' else max(1, int(prop.step))
+
+
+def stepped_number(prop, value, direction):
+ """The value after one arrow step, kept inside the soft range."""
+ soft_min, soft_max = _soft_range(prop)
+ value += direction * number_step(prop)
+ return max(soft_min, value) if direction < 0 else min(soft_max, value)
+
+
+def snap_number(prop, value, snap):
+ """Ctrl ('ON') and Ctrl+Shift ('SMALL') snapping of a dragged value."""
+ soft_min, soft_max = _soft_range(prop)
+ if not snap or value in (soft_min, soft_max):
+ return value
+ if prop.type == 'INT':
+ unit = 100 if snap == 'SMALL' else 10
+ return unit * int(value / unit)
+ fac = .1 if snap == 'SMALL' else 1.0
+ # Wider ranges snap like a range of 20.
+ if soft_max - soft_min < 2.1:
+ return _round(value * 10 / fac) * .1 * fac
+ return _round(value / fac) * fac
+
+
+def number_drag(prop, start, pixels, *, precise=False, snap=None):
+ """The value after dragging *pixels* from *start*: a float moves one click step per pixel (a tenth with
+ *precise*), an int one per pixel, per 2 or per 16 pixels by the size of its soft range. Also returns how
+ far the drag origin moves when the soft range clamps, so turning back responds at once."""
+ soft_min, soft_max = _soft_range(prop)
+ if prop.type == 'FLOAT':
+ fac = .01 * prop.step * (.1 if precise else 1)
+ value = snap_number(prop, start + pixels * fac, snap)
+ else:
+ span = soft_max - soft_min
+ fac = 1 if span > 256 else .5 if span > 32 else 1 / 16
+ value = snap_number(prop, int(start + pixels * fac), snap)
+ if value < soft_min:
+ return soft_min, -(soft_min - value) / fac
+ if value > soft_max:
+ return soft_max, (value - soft_max) / fac
+ return value, 0
+
+
@dataclass(frozen=True)
class Binding:
"""Resolve RNA again after undo instead of holding invalid datablocks."""
diff --git a/stablegen/ui/studio_widgets.py b/stablegen/ui/studio_widgets.py
index 60fb1b5..5351cf4 100644
--- a/stablegen/ui/studio_widgets.py
+++ b/stablegen/ui/studio_widgets.py
@@ -47,6 +47,7 @@ ICON_PATHS = {
'down': [[(5, 8), (10, 13), (15, 8)]],
'up': [[(5, 13), (10, 8), (15, 13)]],
'right': [[(7, 5), (12, 10), (7, 15)]],
+ 'left': [[(13, 5), (8, 10), (13, 15)]],
'reset': [arc for arc, _ in _SYNC],
'search': [[(14, 14), (19, 19)]],
'settings': [[(2, 5), (19, 5)], [(2, 10), (19, 10)], [(2, 15), (19, 15)], [(7, 3), (7, 7)], [(14, 8), (14, 12)], [(9, 13), (9, 17)]],
@@ -184,7 +185,8 @@ def color(value):
COLORS = {key: color(value) for key, value in {
'panel': '3d3d3d', 'field': '1d1d1d', 'field_text': 'e6e6e6',
- 'number': '545454', 'number_text': 'e6e6e6', 'menu': '282828', 'menu_text': 'e6e6e6',
+ 'number': '545454', 'number_text': 'e6e6e6', 'number_hover': '646464', 'number_hot': '797979',
+ 'menu': '282828', 'menu_text': 'e6e6e6', 'scroll_track': '2f2f2f',
'raised': '545454', 'line': '494949', 'divider': '464646', 'text': 'e6e6e6',
'secondary': 'c4c4c4', 'muted': '999999', 'accent': '8fa6ca',
'blue': '4772b3', 'on_accent': 'ffffff', 'hover': '545454', 'disabled': '787878',
@@ -212,6 +214,11 @@ def _over(foreground, background):
return _mix(background, foreground, foreground[3])
+def _shade(color, amount):
+ """Lighten like Blender's widget hover shading, which adds to each channel."""
+ return tuple(max(0, min(1, c + amount)) for c in color[:3]) + (1,)
+
+
def theme_colors(context):
"""Read the active native palette each draw, including unsaved theme edits."""
theme = context.preferences.themes[0]
@@ -232,6 +239,10 @@ def theme_colors(context):
return {
'panel': panel, 'field': field_back, 'field_text': _rgba(field.text),
'number': _over(number.inner, panel), 'number_text': _rgba(number.text),
+ # A hovered number field lightens, and the part under the pointer more (measured on Blender's own).
+ 'number_hover': _shade(_over(number.inner, panel), 16 / 255),
+ 'number_hot': _shade(_over(number.inner, panel), 37 / 255),
+ 'scroll_track': _mix(panel, (0, 0, 0, 1), .22),
'menu': _over(menu.inner, panel), 'menu_text': _rgba(menu.text),
'field_border': _over(field.outline, panel), 'number_border': _over(number.outline, panel),
'menu_border': _over(menu.outline, panel), 'tool_border': _over(tool.outline, panel),
@@ -278,6 +289,12 @@ class Target:
kind = self.action[0] if isinstance(self.action, tuple) else ''
return 'TEXT' if kind in {'edit', 'menu-lora-search'} else 'MOVE_X' if kind == 'slider' else 'MOVE_Y' if kind == 'camera-drag' else 'DEFAULT'
+ def number_zone(self, x):
+ """Blender's arrow zones: min(a third of the width, 0.7 x the height) at each end."""
+ rx, _, width, height = self.rect
+ handle = min(width / 3, height * .7)
+ return 'left' if x < rx + handle else 'right' if x > rx + width - handle else 'middle'
+
def contains(self, x, y):
rx, ry, width, height = self.rect
inside = rx <= x <= rx + width and ry <= y <= ry + height
@@ -609,6 +626,27 @@ class Painter:
self.rect(sx + (16 if checked else 2), sy + 2, 10, 10, 'switch_knob' if enabled else 'muted', 5)
self.target(key, rect, action, enabled, hint)
+ def number_field(self, key, rect, display, action, *, enabled=True, hint='', zone=None, dragging=False):
+ """A number button drawn like Blender's: the value centered, arrows at both ends while hovered and the
+ part under the pointer (*zone*: left, middle or right) lit."""
+ x, y, w, h = rect
+ target = self.target(key, rect, action, enabled, hint)
+ hovered = enabled and (dragging or key == self.hover_key)
+ self.outline(x, y, w, h, 'number_selected' if dragging else 'number_hover' if hovered else 'number',
+ 'hover_border' if hovered else 'number_border')
+ handle = min(w / 3, h * .7)
+ if hovered and not dragging and zone:
+ zx, zw, corners = {'left': (x + 1, handle - 1, 'LEFT'), 'middle': (x + handle, w - 2 * handle, 'NONE'),
+ 'right': (x + w - handle, handle - 1, 'RIGHT')}[zone]
+ self.rect(zx, y + 1, zw, h - 2, 'number_hot', 3, corners=corners)
+ if hovered:
+ for name, zx in (('left', x), ('right', x + w - handle)):
+ self.icon(name, zx + (handle - 12) / 2, y + (h - 12) / 2, 12, 'number_text')
+ text = self.fit(display, max(0, w - 2 * handle - 2))
+ self.text(text, x + (w - self.measure(text)) / 2, y + (h - font_size()) / 2 - 1, FONT_SIZE,
+ 'number_text' if enabled else 'disabled')
+ return target
+
def text_field(self, key, rect, value, action, *, enabled=True, hint='', editing=None, scroll=0, multiline=False, follow_caret=True, kind='field'):
x, y, w, h = rect
self.outline(x, y, w, h, fill=kind, border='cursor' if editing else 'hover_border'