# create a frame with a shadow effect border
# using overlapping frames
# vegaseat
 
try:
    # Python2
    import Tkinter as tk
except ImportError:
    # Python3
    import tkinter as tk
 
root = tk.Tk()
w = 320
h = 220
x = 150
y = 100
# use width x height + x_offset + y_offset (no spaces!)
root.geometry("%dx%d+%d+%d" % (w, h, x, y))
root.title("shadow effect border")
 
frame1 = tk.Frame(root, bg='grey', width=w-30, height=h-30)
frame1.place(x=20, y=20)
 
frame2 = tk.Frame(root, bg='yellow', width=w-30, height=h-30)
frame2.place(x=10, y=10)
 
root.mainloop()

# show width and height of Tkinter's root window
# vegaseat
 
try:
    # Python2
    import Tkinter as tk
except ImportError:
    # Python3
    import tkinter as tk
 
root = tk.Tk()
w = 460
h = 320
x = 150
y = 100
# use width x height + x_offset + y_offset (no spaces!)
root.geometry("%dx%d+%d+%d" % (w, h, x, y))
 
# update is needed
root.update()
geo = root.geometry()
print(geo)                    # 460x320+150+100
width = root.winfo_width()    # 460
print(width)
height = root.winfo_height()  # 320
print(height)
 
root.mainloop()

"""
Simple py2exe version used for Tkinter programs.
Run this program to create a windows exe file with py2exe.
Run it in a folder that als contains your source code file.
 
It will create 2 folders named build and dist.
 
The build folder is temporary info and can be deleted.
 
Distribute whatever is in the dist folder.
 
Your library.zip file contains your optimized byte code, and all
needed modules.  This file together with the Python interpreter
(eg. Python25.dll) should accompany the created executable file.
Note that you might be able to share this large library file with
other Python/Tkinter based .exe files.
 
The MSVCR71.dll can be distributed and is often already in the
Windows/system32 folder.
 
w9xpopen.exe is needed for os.popen() only, can be deleted otherwise.
"""
 
from distutils.core import setup
import py2exe
import sys
 
sys.argv.append("py2exe")
sys.argv.append("-q")
 
# insert your own source code filename below ...
code_file = 'Tk_ParResist1.pyw'
 
# replace windows with console for a console program
setup(windows = [{"script": code_file}])

# show a colorful splash message for a set time then quit
# tested with PyQT45  by  vegaseat
 
from PyQt4.QtCore import *
from PyQt4.QtGui import *
 
def do_html(text, color='black', size=3):
    """create a line of html code for text with color and size"""
    sf = "<FONT color=%s size=%d>%s</FONT>"
    return sf % (color, size, text)
 
# build up simple HTML code ...
# text between <B> and </B> is bold
# <BR> inserts a line break (new line)
html = ""
html += '<BR>'
orange = "#FFBA00"  # gives a better orange color
color_list = ['red', orange, 'yellow', 'green', 'blue']
ix = 0
for c in 'WE LOVE RAINBOWS':
    # make character c bold
    c = "<B>" + c + "</B>"
    if ix >= len(color_list):
        ix = 0
    html += do_html(c, color_list[ix], 7)
    ix += 1
html += '<BR>'
 
# create a QT GUI application
app = QApplication([])
label = QLabel(html)
# show label without frame
# comment line out if you want a frame
label.setWindowFlags(Qt.SplashScreen)
label.show()
# show for x milliseconds, then quit
x = 5000
QTimer.singleShot(x, app.quit)
app.exec_()

# explore Tkinter's Text widget
# get the line and column values of the text insertion point
# vegaseat
 
import Tkinter as tk
 
def get_position(event):
    """get the line and column number of the text insertion point"""
    line, column = text.index('insert').split('.')
    s = "line=%s  column=%s" % (line, column)
    root.title(s)
 
 
root= tk.Tk()
root.title('start typing')
text = tk.Text(root, width=40, height=10)
text.bind("<KeyRelease>", get_position)
text.pack()
# start cursor in text area
text.focus()
 
root.mainloop()

# use pygame to bounce/move loaded image around the screen
 
import sys, pygame
 
pygame.init()
 
size = width, height = 320, 240
# this determines the move direction/speed in pixels
# speed[0] left or right
# speed[1] up or down
speed = [2, 2]
# color uses r, g, b tuple
black = 0, 0, 0
# white works better here
white = 255, 255, 255
 
# create the window
screen = pygame.display.set_mode(size)
# give the window a title
pygame.display.set_caption("watch the beach ball bounce")
 
# make sure the image file is in the working directory
# or give full path name
ball = pygame.image.load("ball.bmp")
# create rectangle object you can move
# it is used to put the image on
ballrect = ball.get_rect()
 
while True:
    for event in pygame.event.get():
        # window corner x will exit
        if event.type == pygame.QUIT:
            sys.exit()
    # move the rectangle object
    ballrect = ballrect.move(speed)
    # change direction if left or right boundry is reached
    if ballrect.left < 0 or ballrect.right > width:
        speed[0] = -speed[0]
    # change direction if top or bottom boundry is reached
    if ballrect.top < 0 or ballrect.bottom > height:
        speed[1] = -speed[1]
    # clear the screen with white background
    screen.fill(white)
    # put the image on the rectangle object
    screen.blit(ball, ballrect)
    # update screen
    pygame.display.flip()
    # small time delay
    milliseconds = 20
    pygame.time.delay(milliseconds)

# multiple color text with Tkinter using widget Text() and tags
# vegaseat
 
try:
    # Python2
    import Tkinter as tk
except ImportError:
    # Python3
    import tkinter as tk
 
def color_text(edit, tag, word, fg_color='black', bg_color='white'):
    # add a space to the end of the word
    word = word + " "
    edit.insert('end', word)
    end_index = edit.index('end')
    begin_index = "%s-%sc" % (end_index, len(word) + 1)
    edit.tag_add(tag, begin_index, end_index)
    edit.tag_config(tag, foreground=fg_color, background=bg_color)
 
 
root = tk.Tk()
root.geometry("600x200")
 
edit = tk.Text(root)
edit.pack()
 
text = "Up the hill went Jack and Jill, down fell Jill and cried!"
# create a list of single words
word_list = text.split()
#print( word_list )  # test
 
# pick word to be colored
myword1 = 'Jack'
myword2 = 'Jill'
# create a list of unique tags
tags = ["tg" + str(k) for k in range(len(word_list))]
for ix, word in enumerate(word_list):
    # word[:len(myword)] for word ending with a punctuation mark
    if word[:len(myword1)] == myword1:
        color_text(edit, tags[ix], word, 'blue')
    elif word[:len(myword2)] == myword2:
        color_text(edit, tags[ix], word, 'red', 'yellow')
    else:
        color_text(edit, tags[ix], word)
 
root.mainloop()

# use Tkinter popup dialogs for input and output
# see:
# http://www-acc.kek.jp/WWW-ACC-exp/KEKB/control/Activity/Python/
#   TkIntro/introduction/intro08.htm
# simple dialogs are:
# askfloat, askinteger, and askstring
# messagebox dialogs are:
# showinfo, showwarning, showerror, askquestion, askokcancel,
# askyesno, askretrycancel
# vegaseat
 
try:
    # Python2
    import Tkinter as tk
    import tkSimpleDialog as tksd
    import tktkMessageBox as tkmb
except ImportError:
    # Python3
    import tkinter as tk
    import tkinter.simpledialog as tksd
    import tkinter.messagebox as tkmb
 
def get_data():
    # tksd.askfloat(title, prompt [,options])
    miles = tksd.askfloat('Miles', 'Enter miles driven')
    # give minvalue to avoid division by zero errors
    gal = tksd.askfloat('Petrol', 'Enter gallon of petrol consumed',
        minvalue=0.1)
    str_result = "Your milage is %0.2f miles/gallon" % (miles/gal)
    # tkmb.showinfo(title, message [, options])
    tkmb.showinfo('Result:', str_result)
 
root = tk.Tk()
str_var = tk.StringVar()
 
tk.Button(root, text="Get data", command=get_data).pack(pady=5)
 
root.mainloop()

# explore PyQT QLineEdit, QPushButton, QLabel, QMessageBox,
# QHBoxLayout, QWidget, QMainWindow
# tested with Python 3.1.1 and PyQT 4.6.2.2
# ene
 
# easy import
from PyQt4.QtCore import *
from PyQt4.QtGui import *
 
class MyWindow(QMainWindow):
    def __init__(self, parent= None):
        QMainWindow.__init__(self, parent)
        # setGeometry(x_pos, y_pos, width, height)
        self.setGeometry(100, 150, 320, 100)
        self.setWindowTitle("Explore QLineEdit")
        self.create_widgets()
 
    def create_widgets(self):
        self.label = QLabel("Say hello:")
        self.edit = QLineEdit()
        self.button = QPushButton("Push Me!")
        # connect signal to button
        #QObject.connect(self.button, SIGNAL("clicked()"), self.on_click)
        # newer connect style used with PyQT 4.5+
        self.button.clicked.connect(self.on_click)
 
        # use horizontal layout
        h_box = QHBoxLayout()
        h_box.addWidget(self.label)
        h_box.addWidget(self.edit)
        h_box.addWidget(self.button)
        # create central widget, add layout and set
        central_widget = QWidget()
        central_widget.setLayout(h_box)
        self.setCentralWidget(central_widget)
 
    def on_click(self):
        """the button has been clicked"""
        msg = "Good day %s" % self.edit.displayText()
        QMessageBox.information(self, "Title", msg, QMessageBox.Ok)
 
 
# test potential module
if __name__ == "__main__":
    app = QApplication([])
    window = MyWindow()
    window.show()
    app.exec_()

# experiments with Tkinter resizing
# two frames on a frame, keep one frame height fairly constant
# vegaseat
 
try:
    # Python2
    import Tkinter as tk
except ImportError:
    # Python3
    import tkinter as tk
 
class MyApp(tk.Frame):
    def __init__(self, master=None):
        tk.Frame.__init__(self, master, bg='yellow')
        self.prepare_resizing()
        # set the title, self.top is from prepare_resizing()
        # and is actually the master in this case
        self.top.title("Two Frames (resize the window)")
        self.make_widgets()
 
    def prepare_resizing(self):
        """ needed for stretch/resize """
        self.grid(sticky='nswe')
        self.top = root.winfo_toplevel()
        self.top.rowconfigure(0, weight=1)
        self.top.columnconfigure(0, weight=1)
        # there are two rows in this example
        # set row ratios
        self.rowconfigure(0, weight=1)
        # make weight for row 1 very high to keep row 0 constant
        self.rowconfigure(1, weight=1000)
        # there is only one column in this example
        self.columnconfigure(0, weight=1)
 
    def make_widgets(self):
        # put frame1 in row 0 to keep it fixed in height
        frame1 = tk.Frame(self, bg='brown', width=400, height=50)
        frame1.grid(row=0, column=0, sticky='nesw')
        # needed for width and height
        frame1.grid_propagate(0)
        # need for button to stick 'w'
        frame1.columnconfigure(0, weight=1)
 
        # put frame2 in row 1 to make it resize
        frame2 = tk.Frame(self, bg='green', width=400, height=200)
        frame2.grid(row=1, column=0, sticky='nesw')
        # needed for width and height
        frame2.grid_propagate(0)
        # need for button to stick 'e'
        frame2.columnconfigure(0, weight=1)
 
        b1 = tk.Button(frame1, text="Frame1 Button1")
        # this grid is inside frame1
        b1.grid(row=0, column=0, padx=5, pady=10, sticky='w')
 
        b2 = tk.Button(frame2, text="Frame2 Button2")
        b2.grid(row=0, column=0, padx=5, pady=10, sticky='e')
 
 
root = tk.Tk()
app = MyApp(master=root)
root.mainloop()