mirror of
https://github.com/python/cpython.git
synced 2025-10-24 02:13:49 +00:00
ca07ba00ac
run either as a standalone application (by running pynche or
pynche.pyw), or as a modal dialog inside another application. This
can be done by importing pyColorChooser and running askcolor(). The
API for this is the same as the tkColorChooser.askcolor() API, namely:
When `Okay' is hit, askcolor() returns ((r, g, b), "name"). When
`Cancel' is hit, askcolor() returns (None, None).
Note the following differences:
1. pyColorChooser.askcolor() takes an optional keyword `master'
which if set tells Pynche to run as a modal dialog. `master'
is a Tkinter parent window. Without the `master' keyword
Pynche runs standalone.
2. in pyColorChooser.askcolor() will return a Tk/X11 color name as
"name" if there is an exact match, otherwise it will return a
color spec, e.g. "#rrggbb". tkColorChooser can't return a
color name.
There are also some UI differences when running standalone vs. modal.
When modal, there is no "File" menu, but instead there are "Okay" and
"Cancel" buttons.
The implementation of all this is a bit of a hack, but it seems to
work moderately well. I'm not guaranteeing the pyColorChooser.Chooser
class has the same semantics as the tkColorChooser.Chooser class.
139 lines
5.2 KiB
Python
139 lines
5.2 KiB
Python
"""TypeinViewer class.
|
|
|
|
The TypeinViewer is what you see at the lower right of the main Pynche
|
|
widget. It contains three text entry fields, one each for red, green, blue.
|
|
Input into these windows is highly constrained; it only allows you to enter
|
|
values that are legal for a color axis. This usually means 0-255 for decimal
|
|
input and 0x0 - 0xff for hex input.
|
|
|
|
You can toggle whether you want to view and input the values in either decimal
|
|
or hex by clicking on Hexadecimal. By clicking on Update while typing, the
|
|
color selection will be made on every change to the text field. Otherwise,
|
|
you must hit Return or Tab to select the color.
|
|
"""
|
|
|
|
from Tkinter import *
|
|
import string
|
|
import re
|
|
|
|
class TypeinViewer:
|
|
def __init__(self, switchboard, master=None):
|
|
# non-gui ivars
|
|
self.__sb = switchboard
|
|
optiondb = switchboard.optiondb()
|
|
self.__hexp = BooleanVar()
|
|
self.__hexp.set(optiondb.get('HEXTYPE', 0))
|
|
self.__uwtyping = BooleanVar()
|
|
self.__uwtyping.set(optiondb.get('UPWHILETYPE', 0))
|
|
# create the gui
|
|
self.__frame = Frame(master, relief=RAISED, borderwidth=1)
|
|
self.__frame.grid(row=3, column=1, sticky='NS')
|
|
# Red
|
|
self.__xl = Label(self.__frame, text='Red:')
|
|
self.__xl.grid(row=0, column=0, sticky=E)
|
|
self.__x = Entry(self.__frame, width=4)
|
|
self.__x.grid(row=0, column=1)
|
|
self.__x.bindtags(self.__x.bindtags() + ('Normalize', 'Update'))
|
|
self.__x.bind_class('Normalize', '<Key>', self.__normalize)
|
|
self.__x.bind_class('Update' , '<Key>', self.__maybeupdate)
|
|
# Green
|
|
self.__yl = Label(self.__frame, text='Green:')
|
|
self.__yl.grid(row=1, column=0, sticky=E)
|
|
self.__y = Entry(self.__frame, width=4)
|
|
self.__y.grid(row=1, column=1)
|
|
self.__y.bindtags(self.__y.bindtags() + ('Normalize', 'Update'))
|
|
# Blue
|
|
self.__zl = Label(self.__frame, text='Blue:')
|
|
self.__zl.grid(row=2, column=0, sticky=E)
|
|
self.__z = Entry(self.__frame, width=4)
|
|
self.__z.grid(row=2, column=1)
|
|
self.__z.bindtags(self.__z.bindtags() + ('Normalize', 'Update'))
|
|
# Update while typing?
|
|
self.__uwt = Checkbutton(self.__frame,
|
|
text='Update while typing',
|
|
variable=self.__uwtyping)
|
|
self.__uwt.grid(row=3, column=0, columnspan=2, sticky=W)
|
|
# Hex/Dec
|
|
self.__hex = Checkbutton(self.__frame,
|
|
text='Hexadecimal',
|
|
variable=self.__hexp,
|
|
command=self.__togglehex)
|
|
self.__hex.grid(row=4, column=0, columnspan=2, sticky=W)
|
|
|
|
def __togglehex(self, event=None):
|
|
red, green, blue = self.__sb.current_rgb()
|
|
self.update_yourself(red, green, blue)
|
|
|
|
def __normalize(self, event=None):
|
|
ew = event.widget
|
|
contents = ew.get()
|
|
icursor = ew.index(INSERT)
|
|
if contents == '':
|
|
contents = '0'
|
|
if contents[0] in 'xX' and self.__hexp.get():
|
|
contents = '0' + contents
|
|
# figure out what the contents value is in the current base
|
|
try:
|
|
if self.__hexp.get():
|
|
v = string.atoi(contents, 16)
|
|
else:
|
|
v = string.atoi(contents)
|
|
except ValueError:
|
|
v = None
|
|
# if value is not legal, delete the last character inserted and ring
|
|
# the bell
|
|
if v is None or v < 0 or v > 255:
|
|
i = ew.index(INSERT)
|
|
if event.char:
|
|
contents = contents[:i-1] + contents[i:]
|
|
icursor = icursor-1
|
|
ew.bell()
|
|
elif self.__hexp.get():
|
|
contents = hex(v)
|
|
else:
|
|
contents = int(v)
|
|
ew.delete(0, END)
|
|
ew.insert(0, contents)
|
|
ew.icursor(icursor)
|
|
|
|
def __maybeupdate(self, event=None):
|
|
if self.__uwtyping.get() or event.keysym in ('Return', 'Tab'):
|
|
self.__update(event)
|
|
|
|
def __update(self, event=None):
|
|
redstr = self.__x.get()
|
|
greenstr = self.__y.get()
|
|
bluestr = self.__z.get()
|
|
if self.__hexp.get():
|
|
red = string.atoi(redstr, 16)
|
|
green = string.atoi(greenstr, 16)
|
|
blue = string.atoi(bluestr, 16)
|
|
else:
|
|
red, green, blue = map(string.atoi, (redstr, greenstr, bluestr))
|
|
self.__sb.update_views(red, green, blue)
|
|
|
|
def update_yourself(self, red, green, blue):
|
|
if self.__hexp.get():
|
|
redstr, greenstr, bluestr = map(hex, (red, green, blue))
|
|
else:
|
|
redstr, greenstr, bluestr = red, green, blue
|
|
x, y, z = self.__x, self.__y, self.__z
|
|
xicursor = x.index(INSERT)
|
|
yicursor = y.index(INSERT)
|
|
zicursor = z.index(INSERT)
|
|
x.delete(0, END)
|
|
y.delete(0, END)
|
|
z.delete(0, END)
|
|
x.insert(0, redstr)
|
|
y.insert(0, greenstr)
|
|
z.insert(0, bluestr)
|
|
x.icursor(xicursor)
|
|
y.icursor(yicursor)
|
|
z.icursor(zicursor)
|
|
|
|
def hexp_var(self):
|
|
return self.__hexp
|
|
|
|
def save_options(self, optiondb):
|
|
optiondb['HEXTYPE'] = self.__hexp.get()
|
|
optiondb['UPWHILETYPE'] = self.__uwtyping.get()
|