# --------------------------------------------------------------------------------- # # ZoomBar wxPython IMPLEMENTATION # # Andrea Gavana @ 19 Dec 2012, 21.00 GMT # # # For all kind of problems, requests of enhancements and bug reports, please write # to me at: # # andrea.gavana@gmail.com # andrea.gavana@maerskoil.com # # Or, obviously, to the wxPython mailing list!!! # # Tags: phoenix-port, documented, unittest, py3-port # # End of comments # --------------------------------------------------------------------------------- # """ :class:`~wx.lib.agw.zoombar.ZoomBar` is a class that *appoximatively* mimics the behaviour of the Mac Dock, inside a :class:`Panel`. Description =========== :class:`ZoomBar` is a class that *appoximatively* mimics the behaviour of the Mac Dock, inside a :class:`Panel`. Once you hover mouse over the :class:`ZoomBar` correct button will bubble up, grow to predefined size, so you can easily see the button you are about to click and have larger area to click. Difference this makes is amazing. The buttons are able to be zoomed from the bottom up (bottom fixed) as well as to zoom from a central point. Also the container is able to move the remaining buttons around the zoomed button. Usage ===== Usage example:: import os import random import glob import wx import wx.lib.agw.zoombar as ZB class MyFrame(wx.Frame): def __init__(self, parent): wx.Frame.__init__(self, parent, -1, "ZoomBar Demo") panel = wx.Panel(self) bar = ZB.ZoomBar(panel, -1) standard = glob.glob(bitmapDir + "/*96.png") reflections = glob.glob(bitmapDir + "/*96Flip40.png") separatorImage = bitmapDir + "/separator.gif" separatorReflection = bitmapDir + "/separatorFlip.png" count = 0 for std, ref in zip(standard, reflections): if random.randint(0, 1) == 1 and count > 0: sep1 = wx.Bitmap(separatorImage, wx.BITMAP_TYPE_GIF) sep2 = wx.Bitmap(separatorReflection, wx.BITMAP_TYPE_PNG) bar.AddSeparator(sep1, sep2) bname = os.path.split(std)[1][0:-6] bar.AddButton(wx.Bitmap(std, wx.BITMAP_TYPE_PNG), wx.Bitmap(ref, wx.BITMAP_TYPE_PNG), bname) count += 1 bar.ResetSize() sizer = wx.BoxSizer(wx.HORIZONTAL) sizer.Add(bar, 0, wx.ALIGN_CENTER_HORIZONTAL | wx.ALIGN_CENTER_VERTICAL | wx.ALL, 15) panel.SetSizer(sizer) # our normal wxApp-derived class, as usual app = wx.App(0) frame = MyFrame(None) app.SetTopWindow(frame) frame.Show() app.MainLoop() Supported Platforms =================== :class:`ZoomBar` has been tested on the following platforms: * Windows (Windows XP). Window Styles ============= `No particular window styles are available for this class.` Events Processing ================= This class processes the following events: ============================== ================================================== Event Name Description ============================== ================================================== ``EVT_ZOOMBAR`` Process a ``wxEVT_ZOOMBAR`` event, when a :class:`ZoomBar` button is clicked. ============================== ================================================== License And Version =================== :class:`ZoomBar` is distributed under the wxPython license. Latest Revision: Andrea Gavana @ 19 Dec 2012, 21.00 GMT Version 0.1 """ import wx import sys import six from wx.lib.embeddedimage import PyEmbeddedImage zoombackgrey = PyEmbeddedImage( "iVBORw0KGgoAAAANSUhEUgAAAjkAAAAyCAYAAAC+s8qHAAAABHNCSVQICAgIfAhkiAAAIABJ" "REFUeJzVXUuv5Udxr/O4xrzEAtvIAnYevkDAJp8piRfeeIGSsEFiY96QbUyiWRgn9reIieTx" "YIGsAWQZCQkJz3h83/e8s0jquG7Nr17dfeY6JR2dc/rfXVXdXY9f9f88JpPpjEbTL37+s91u" "tyN+EBF8XenDZPWR1yXp65rktclkAtv5tbwueU+nU5cXv9dtuq81xpLP77VcS45ci+12+8h1" "OQ/Jg9u9uVk6ete5fTqdXtOb5cs2a66IJ1oDqYMe662Zlpnpg3hZdjqZTGg+n9MTTzxBn/nM" "Z+jJJ5+k+XxO0+mUttstrVYrWiwWdHV1RVdXV7RYLGi9Xu/HTqdTmk6ntNvtaLPZ0Hq9Nm3e" "WhO0FtoGJGl7IPrEnuQ1zy/1uvAckH7WONTH20ePpB8TfTIPtDba7lCfaLyUhWxQjtfXrHiI" "rk0mE5rNZjSbzfa2wv622+1ou93Ser3ePzabDW232zDGWjYuydK5lby91jHGi1l6TXVskjEy" "ylloblHOQetixXbrPfJBj6QcFPu5T7RPkR8zbbdbGLPRax672WxotVrRP/7TP7c5sUGTUSDn" "3//tl7urqyu6uLig5XK5X0jPKNiI5GT1swVyvDHS4HW7pgzIschL7IhQsLISteyfdRivTZLc" "m8w4rbeXBKv66Lmidi0XtVvj9BgLECIeco4jgjSyYwly+MEgZ7fb7UHOYrGg5XJJy+XyGsjh" "gC4TVg/I8drlOG3HEphG4Eb6aGTfFh0C5PB4ZJMRwJF9NEBhYnDBr+WaWTJ2ux3NZrNrMvT6" "WglFjplOp3ugw89EtAfGDHCyIEfPHcXZ1r1ApG0lsmUiDATk+lty9HvrYY3zrmViYRTj+H3r" "+nogx3tvtaF2S4bsK9dytVrR5eUlnZyc0Mcff0y/ev0/hhlPN8j55av/ujs7O6PNZnMtCLOj" "WECGX3vo2DImvUjWdU0oMGrHQABJtyN+klCwzxi3fN1jxN44tHaRbhXgogOcBYYs3hbwQPtk" "va6um0w+SMdKErb6a6fnPtPplObzOR0dHe0f8iSHfUo+mJdMitvt9tpDAzRrXaXe3py8gCtl" "yLnp99l1HAEos4TAgbYHD/hoPnKsB16sZItsEZ1KSH2jpIVADuvAwAaBHC9max11PLWuj6Rs" "DEJtUkcvzqN84wE/6z2iKKZF+aMS6zLgJAtgvLllChzZzrZ3dXVFp6endHJyQicnJ3T//n26" "d+8eLVfrbrDTBXLefOM/d3/6059ovV7Tcrmk1WpFy+Vy7yhWwGXSziSvS0PSwMMyQs0/2hwr" "WOv3MkhpA9fVheXkmiww4I3NgBLrupSH9sXig0AI6ucBvgzvihN7fTPgCvGJKiVpi7yGiLhC" "j6oguV7z+ZxmsxkdHR3tT3Jms9n+dhX7FfsYn+SwPNZT+p0ViCygU9k377qcn+4jwRnSD7VH" "ySKzzxZl7APddmKybol4IMk65ZH26yVnRAh4aIAib1XJBxHtTwAlyNlsNqnYWgEz2aKvh6x1" "RzJ1XLdIx3wL6PA1672VB5He8jnKW61gJwIhlnzZ5oFdq5CWMYptb7FY0Pn5OV1cXNDFxQVd" "Xl7S8fEx/fGPf6TVetNlLPOewUT0yFG5dBZZFSCggqoFq4LQ41C7fI9IVxseaR76swZR8I0S" "OGrPBLSs4Vs8eZx3nCjHRqAGyc4Ak+z7zNplEzdRfIvQk5mpzryAaSWJ9XpNs9ls7zNHR0d7" "kLNerx8BOZyAdJCWhQWaL9LVel0Fv9Y8dXsFlGQAjtQpQ9oPrCCNQInmIdcBgZ8IxKDxaG0t" "OVLfKP4xYNMPBuzV0xzNm9st2XrcSJCjbcrzb/YVBCgRX+tZ+5h8Rjz0e2tNMuvSA3Iq+lb8" "L+KvX3Oc4gMS/rwh3wmSuf7bLzy/e+vX/91sMM0g5+47d3Z3797dV5pcYfKHh/iWlf78h3Yc" "y1gyYEaO4fvSGshIo8oAEwt5e1RN+LJdGnsGHESE5imdwDNwj2dFH6u//HApWicNQLyElKl8" "dB+0T1GlJ6myZposIM63peS17Xa7b2eQw0BH3grWwY3BDzrJyaxdxY4zRYLs49ldxjcPRUhH" "2a7XOPsegRfdP2rz9NDkARIJ2PjBt64Y5LBdcQxnftbn9zRvq4+mkeBGy0QxBMn0QKMlwyvG" "de7xxss25HNeXNQ+L+NcdV2tgqsC2CL+1rwlwJGxTRZwI6kZ5HzwwQd0enp6rQLgikAfeVqf" "zyHCH4KVxkP0yeJHnwrPLI4HYqJg6zm0FSCR00W8LT4tpIOkFQyzOiG+klcmOUbAryq7ErA8" "/hk+1pqhygyNReCDT234wZ/JIaL96SgHAH4vx8vTVHS7KgLP1rfqrP6ZdubnvdfjqzZu2ZxH" "USDnPh648OxOghwPWFq3wdBYiweaQxSX0EkOAx15u1Of5mT20ro2AtggnpEvWmBekvUBZLS+" "OnZaryP9td0iv5Pzq/he5VtXls5RLpX6Zu1Ar9Vut7sGphl4yzFf+tKX6LnnnqM7d+7Q3377" "hd1/vfXrJkPqvl1F5Cc25DBM2oEsg5K8NCFD86jirJoyG4uuR8kbIXqLT1VfVDFk18oLtKiC" "0mMsfaPKowoKEZDLzCWSkbmeSbRZUCmvS+CiP+OmT3JkUYA+S+HpZ9lehqL96QU5oys6KS8D" "8CMw411DIInXRH5uS4MdvmZ93sdacyuhaPJuWaEiFZ20W+9le1T8VMmLhUiWBhAW6JTfTNPk" "AZ0od3njrXnoMVZe9da0tVCIgE7Wbyw9JD9pZ1a8knL5s4mt1ARy7r5zZ/f222/vq8vogapL" "OWF+Hy2058hV4NFC2U33wAgyXtQWyY8o0oGfrWQYASrpaBayzzhj9iRABykrOEXrrtfamodH" "yA4yn3Gy9EOBk/0FnZLKfvIUxqu8NWVPAnT/LFUSYtRnBPH+ZuTpRGPZDuoj5egx8tREJ1nu" "t9lsrumWOY3w5iPnzLKtvvoDoV4Cl7wR4LC+TajnYr3PxC7dJvcN2Z9VbMp9Q7FB80I5q5K7" "vHnqMdn4qHVrIct+tC49udYCiBaoGkG1XxT6P3r//ffp/Pz82vG5rgJQ5SkpE4h1f0TRqYBF" "oysLxNfSzUvefD0KCh5ZzoxkR+M9GVHQ9fbGcxgvIMjAWtXZChqyipZV36hTDd3P22+dlPRt" "Be/bObqvfGTBD9LJWzPUX76vAK5DEtIBrZNOlN4D8fYSn6VXZU8QZfxQyuJEqD+krn80MOKr" "ZXtxJ6KKrVj+afHIgjWLh5aj/bElXmTJ8inWK7sGrYR8IjPGu6Y/E6Z/3oB/UuOJJ56gL37x" "i/Tcc8/Ru+++Sy88/62mSTWBHERe8tGbUdkAPc4z4iqNBDraGCx5ljNknCTrSF5ykrwqPCXv" "HkPPyhrlpBFVwEl1TJYQwIlkjQg46HoE8h5nUfE4wM+niRBAiooADUQisGHxRXYgv2Y+gipg" "oKcfyjXIxxDosdZP6x4VWSNsN1oDK+eOkmfN1yoMNC+Lv7VW3pjtdkuLxaJpXmULvvvOnd3H" "H38MfwocneZYR1OaMujbqrgyZG2Kl4y9zfQq3R6jywSCauKyrh+i+siCNXZO5DzoRMKT1TqH" "KsCJ7CFLuq83V+1D8lTUskepq37fslaenSNfik4qNQ/rlAXJbKUqn9HJ+BBUjREZm63EyV7/" "i/Sz5FZ5ZtokSeAg41QlOWfktFAFVBxCdpZ6i9RMjs5SGeT84Q9/2H+ryrol5R3tMsnAaS2I" "VXVUKt6bIs9ZtdNYycNyLu146Lp8Ru06Eekj6uzcouDn8csAW0t+y363Ok7Gniv8IiCjq0r5" "sPbIs6ceXT3yjvRbeVTARZVa97ylX2ac9f4Qp5gcZxkoy8/eyA+yWx9MZh5oDQ956trCO5tP" "srHJyjXa5zIFWYWsvOkdHEg5Lbet9NpEOjBVCz6+LTWfz/d2x7dL+cG3rL7whS/QrVu36L33" "3qNvv/B82SCGnEXqCeqFtsjaHM2zokfPOFQZW5v5uBKJJCv5tcpuTdatQU3bBAJ+0fiMXWne" "iHpAchTIWqpRVCDosVGy0fyi42yrPQs8rAKlupYIpEcgo3JMP6IqzBRa1jhrby3K2rg1Lnov" "AY9+aCDdGlMRRXPP7LtFlg1V9In8RcpBflEB6T3kyWlZO8Rbv5bXJaFvTUe2k4mPciyD7c1m" "QxcXF+U5lUDO3Xfu7I6Pj83/O0F/52AteBR4vY2qJMMqRQaUka/7ZoNspLcHsKpVsPXooWoy" "zYzzgkmFX0v/iE8WmEXydT9+cKXNtqRPSzUoz/CPKBsgkb5VG/J8zOtT4V/Z20y/ajzLUibu" "jCANTL3TuNEJvLLulk6tcr33vfyiviPn0xLfe6kaf1tlSBpp8yWQ8/vf/54uLi7Mb1VVkXgF" "LFSvHYoqR/TVxOIF0AzAieSPNHqm7DF7FLyzemVtpvdWSnRCMdrJUUXJcvihK2xkN5lEheRk" "9Ou5pVIBTyMD9EiKbAqd9uh29JrXNvovP48X0it7aqILU/ltF3Qbe6Sv6v5RnGuh6O5C5jTS" "8xX54WyvMGvVvep3vac5FlX3JDoUkLem5C9x61tWR0dH9PnPf55u3bpF9+7dK3/LqgRyWo4A" "W8Z7hAyn9QQhokwyr8ruWT+repbXWxJEzzFxhrfULeqX4XdIXb2A0htgoiCeGZu1Nyug/3+k" "yM97+VYJ7VM1rnkxEl3vPUHJ6ITGZOJJdK0nHkkemp/mHcWXTOxozVGV06JRIP5QcVCSB9a8" "05doPbIFuNxbvmV1cnJSmkMa5Nx9587u7OzskW9U6W9WWYaEnLwVpUqKnPGmq8EWY9Zzkq8r" "JzmjqRrsosCePYHKykNtvckhE0wr87ACpAdQd7vdtV8NRxSdBkZ6oWveWkbrmglaTFmdW0Cn" "R9WTx6yfjUw6LfaM4oe+nomXFh+rwBpFVRBQXW/PLzOFo7d+GVm9hE55D01ecYV8WrZXTtZ1" "XBjhS2mQc+/ePTo7O9sHXPS1cQ8pZxTOOo0+5n0c1CsnAile200DNY+yibxCmdMMC3D0yNZ8" "K/bVY4tyrLxtIfWybh2gOUS6VfxQ88nw8PZJ++6h/LcCBlrIi3MoUOs9bpFnPXv8omvoh1uJ" "sM21AtssjbAHLzboNiSrRQdUpLSCIouQDbWcOI2gzBysX9aWxcpkMnnkdpW8ZTWfz699y4pv" "Wb3//vv0/Le+mZ7ckP+uYoUtanXqyCBHJjjEJzLKXvCh5+jxjJBwb3KXc0a6ZU/ZdDLjNeRr" "qCLP6iifM3PJEtoH2ZbdZz33ah8OXNYaah6W7qhf5ZpHls1Gc7bmJd9HVO3fStlCRLfzHL09" "sa7pdssPM7w8PTOJUfoq/5eWfq95IVvV/ax1HQFskB5eP9nfWhsvJkR9on1+nMV51V8t8mxI" "87SKG0++Bwr59Ww2o81mQ8fHx2m9Uyc5v7n7zu78/Hz/9+jWN6q8kxwmdHSVSewRVQKlDiaW" "DlJXC6Uj/llCelR5sJ4t8pE+KGD07oMMklpepEOVWtfCOz3K9O3RW9qU/sNGlmdVcD1gxWvP" "2jcKTJ7MiH9EI5NDpnA6hNyIrPh5CB2sxO75K9pHr79lF71F4iHIK+yiogH5b6YoG0nZOHSI" "ta/GgApV9kJTCuS89957dHZ2du32FLpNhX4UUCqlFbUAkfd+hKNHPDJgJhovnzNyMrxa9LHW" "GAUkBLoySalFt4z8kZQFqa2EAHFWJ7lH1u9OyCCqx3Ef2f+QNHoNs3yqJz4t/SrxRe9BxEsD" "1UxBmG2vgHRNOq7L21by9sGh/6dpBGWKVp1PUH7hZ+9zcEg2EcFCxdOtup5ePtQncb02blE2" "b2X4RLes+L+sjo6O6HOf+xzdunWLPvjgg/QtqyE/Bhg5WIToJZ+ouhoBOg6ZQCv9I12qelbn" "l9G5BbxkAJUmnbCt0wrP1iwQ07PfKBlZVWkrCJVy9GvJG8nUfB5XBdlit6P3ZgRVk4tMIHrP" "dF+vHb2vgh2vn7XGUeLzTnb0Z3MycT2K9zdJvetN5AMX9Jr53zRQ7Fn7lvyV9f0otk6nU5rP" "57Rer+nBgwcpfUOQ8+5v7u74FGe1WoX/OO6hYv3aM47q8VT1eq+RtSLZKDC0JkkZdK1TAD3O" "O0XLnnYhnlb/qM3a+6oeGRkZ/TKyW3hZPmDZhlf1oz3w9B1VgWmZ0anE4yR0UuI9JGXW5nHN" "8VAAoeKj+lTA+82c1ph6iIQfFUPZ/lk5EcCsFqAtOtwUtcaTyolkD4Ug53e/+93+BwDlrxxr" "YJP9TE5EXrUsr+u2m9roFqDioVXUZ0TFkaEswIn6IIeuGvSoYBCdDMp+N5W8ssWAtJGo8j4E" "IR16AhUDc+86kn8oyoBTTvpen0q71U+vbdTeKk/2z/6fFd9KYIoKiajIyvhe1j+jflKetmO9" "rvyofOaUbVoXL/J99ttq0TytebXGst6iv7XvZDIJfxhQ3rL67Gc/S9/4xjfoz3/+M33rm38T" "TtQFOednpzv5mRtJ2UW1grEeZ50oyL4Wb0TRsVd2TKWfdTJVkeudbll9kTNZ/byHlmEl0EiO" "7oueo7VBshF/i09FV/TekqvXIts/S9a8rTY9z0NRBFg9e9LXPT6Somp89KO6Di1kjc8AF2+M" "bIuAfTR/zcPyL28uli9pnhnKrk0lsU8m8TeMvJzk2TGKPeia7KNfZ6j3QAFRRX6Pz/TEVHnL" "6q9//Wso3wU5b775Jj148IDW6zUtFgtaLpe0Wq1ouVxe+1FA/Q0riyIjaQl6ljPq99XNi4I1" "GtMy1gsg1cRtrUvWGSyjs3SwdPWc3FoHby3QdaSv7od+UwYFHd3H+j0aK1hF84z2Sl7XVZ6u" "PKOAaemLZHltiE8kz5J1aGrxcY9HxWYlRQDVixsZ/bJyPR7R3ukTDi0f2arm5/n/iL0akdQt" "IOadlFV1zvrTCOo5UR2lSwsPbU/yJEfHQ3m6c3R0RM888wydnp7SD3/wijvR8HYVCmzyvzpa" "qXJrJOsU6HRpxDGe1iF7HBrx8/T2+meu9RotckTvtC572tZyjJ7pEwUjL9hmgIjm22NHlv5o" "HT0AY/XnR8YGs341ok9Fl6xuhwRRkU1EPivb5X4g37dIxsmWUwxPd0tfJFMmHP0tqyr4y8wl" "e4dAUnafMjEa6ay/Oezx4v3OgNxRxYDeO6RnNDaK17qfV1hV5GoeGpBbIOf4+JheeeUVkz+R" "A3Iuzs92UslRn7nhiXlt1vVRBuHp3opGW/p484mqQo+XVYVW9bSSerUSGZlsM4Ev46xadqtt" "ZX0hA2CzwBglTKv6rs7L62/ZFlMv0NEyWviN8t9MUsz6rm7TiQiRJc/SF+nVGie17AjoaP0y" "5NnRaLLsNooJWi/LLjPrUI2ZHmXiYCYuZfr1FBqZ+JOx5V4yQc4bb7xBH3300f721Gq1uvbQ" "t6sQiuTX3rUMWQkrSuwW9QYBz6B7AIWXXHqoUsFIXbxrke7Z4BcZf2VvPZ0y61oFA9UxHvER" "LROqxPRv6Fhys36VAXi9viJ5HJpaiq8WvTLJxQI6aF8zYy0waQH6qNr2bCejC7KLKO7zIwMM" "s0VPlTwA7YHPSB+kv/V7OdzGj8rcK76N+ltFUJYyY7KgR8dmXjP9VyK6XX4Y+ZlnnqHz83P6" "0Q9/YC6MCXK8r4NXK+UqeUktquJbZEX82RC1E6AEmlmf7JpkQUmGRiQrRL1JJQK9lflba1xZ" "72z/7KmLfG8FUZRYNIjK/odQJhi3JocqWEY8Iv0t3laiQP177dybF1oDL05a4yNZFvix+Htx" "p+I/ElDrbxURXd9DmcQzdikTbwYQRnpG/ZAOWX2tvbX2AuUAKVO/lrrL9fSKMq+9QqNyiiS9" "t63FotwXBHgk0OFbVicnJ/T973/flAFBzuXF+bUVQE5pGYnlwBl02gMQLLCSqVYtnTLGEBml" "1c9D92gc61ShqqO0VPTZeWcosyZVwFIhXV30BhSvYtH99OsIsKEKkMdZAVf3ixJNJEvrWZGX" "1cGSY7VpHSIZFR2iGIL2OjOf0QkH6VSxZWuNUDK2/jC2RW41MVrXLH0QZXONnH81LkQ6VXXO" "gjT0+tBU8QE55pAEQc7rr79ODx8+3N+akt+qkr+Vwz8MGCFyD7h4FVgEeCJCvKzxHkDyXltV" "jk5MWedAzhQ5tUdZuRkZnOyywC9Dep3QJ+urfEc6TWtgy/C12pA8LxlrYIRsD5FVqfJrC9RW" "wbMGHB5lgUS2SBhFVZDgJZlsnByRqFrjJeKhAXQ2nlkyDuVblh4tQEe+b1lLa75ewTNqPbQ/" "o+tW/xYaobfOAfKBblnxac7l5SX9+Ec/hMq7X5NCG6AXzQM3clwV3bVSr+NUUfJoQmCrh08U" "cGV7BASrVbsnT+rYQoeyKSu5S7ktlLEpfqCfY9AOj4B2Bhxk5+CBsKx9tMjQ1z2wh+R7SbWH" "LDDYMl63VdczavcKOQRSrDiPblfxdZ1wKv9rlQFTEaFcpPlY/DWfDPipAh2veNfrbhXGkX5V" "ysb23rzTWphaD21j0u7m8zl95StfobOzM/re974HeT8Ccq4uL3ZEGMRINJyZSJTgRgQKj6pV" "Qzb4o6AQ0Qhg1GLsFtgZRVWdDgkQJVX1qvTv6WsBhQhUZQBKtLbW6al8Hc2tZf96g/RNj6/w" "a41pFkCLkk+rP8l4qIGjdWooTwpbYuBoOqTMLKipgp9Mrmwp3qICtaLXTeylpJHAjgiAnNde" "e40ePnxIm82GFosFXV1d7b9JJb9RJW9V8T/WImWZ0AnQoSkTFFoTVrVqsZC5xwcBFK9fRXYG" "8Fn9PSdE87EcGLVnqnG9fvIUIzunaM0ycrOgAO2dlSgsHeUpD6qsZT8k36piPX0y16z+Hp/q" "OnpVMeLTKsebj7fGVltLO5IdyWst/iwbQmTZXSWmVPWz9IpizKEpe9Kk36N5WTEarW0kz1p/" "T18Un0YX5NXYwQ/9QWxuQ9+yevrpp+ny8pJ+8uMfPaI8vF3lVXpSIEL7mUlYFPGxAlklgGWM" "pYWspIWerf4Wz5aAnV2bbHKQFB37erz0GI8snqhfRAgwZMZngk1mLzQhW5cghm8VaBnytgA6" "BbD2Luuj0Xxb/UfbRPSL0tY4NDci/xZND3nzQes+IlF4cTV7smC1eWAXran1v00o6Xi5wpKZ" "aY/iV6V/ljK2pcla5yhfZWKw1qmHPBuJYl2FqvlO9tX/lybb+DUDnPl8Ts8++yxdXFzQd7/7" "3Uf4XQM5i6vL3Xa7pclkAk9nsoFEO2cGSWYMKQOqsoCn6giVDRphKNVx2kEqwDPaH8lftlun" "S9m9RGO9xFwB1VaCsBwcHdVneFrz8q5FNmolzopNoQDjjaskZS8ge/yj/fOSQIZaiq4sT/l+" "RN+Iopiq+Vv+pNsqYAGRFQ8qtiD5RO1oP6197t1/xIuoDlyjWCl/DwutFyrAKvmgx/51LOzh" "McoHNVVz4zWQc/v2bTo9PaXlcknL5ZIWi8UjPwAov10VJRJvolHAzwTBVsoCoFagkkXmmTEj" "qhIkq0q6gqtUV1ZAZL7oObNHWbmZvlK2JzMz9yp4lv3RBzgtgIBsSvtcZFeZNcrMtdVeW20c" "zRPp3kOW704m+C8adB+kZ5YyYCkLWvX47L7qRI1+M0d/IDSK5TqOfJpI7iuTBVwtQBQV4PK1" "3ofMfmb8xdqDyKasfRm5T1leVozSpzryttXTTz9Ni8WCfvqTH1+b3FwzlovpOSdaCIR8uV0n" "NW6X15hQfyS7B2miOSCSBliVd2gnzlZvLYTWOMszu6den1EkeWZ4V3So6qr9gl/L93ySqpOB" "Pr5Ff4ark1IPaV69PpfVzZKj/a9i81nftU4pPD0tPhaIjvj2+olOVAgI82sZn+V1vVbb7Xaf" "XCTQljL0/xlW/qz5JsmzMysGorzG/TwAjPhY7zVlAW2FqnmwcpLl6ZXhxQBa2xvbGo/fbrc0" "n89pu93Ss88+Sx9++CF95zvfucZrb5mr5WJnAZcInVqOJMmrMC1UGaHlEQkxu3H6FMOi1kQT" "VXyosrL4VPjqfqgiQdWL1OlQAQsFe2v9H1dVGK1nZr2tig7xyvD4NFHW3kaOR76B7Ne67iUj" "T56Ui2RkY6MnR+qrqXedkV4twCQTF3VfT8ZNAqBIthdfK3aE7COrX0bHrM2MjCMRVtByH1cM" "24Oc27dv0/Hx8f7W1NXV1f4HAPnHAOWtKr5dZZHlROjHAxG4shLZiAq1usBZYIPmYfWN5GV1" "8mRWqlfdVgFGkU5aL/Rejh9JmYocJS35nE1UaP4ICFpgUVYq8oOc0l9QINF6t6xhzxxHUgtf" "D9BEsloAZrbA0Lp5/bPzPjQAQL6g5aLqWtqf9f9DlpzM3JCfeg85Lpqv1450t5J51fYsWd6c" "qjEqAjroMMHrn51T5ZQowxPFSGlr8ltWq9WKfvbTn+yV3t+uQp+QR4rzQ4MVDuToJECPl4sQ" "LbBsZ134Q9EyCaD+HlVQN88tSt6ecyFd9drypmUJrbHWVa+dXPcINHoBQI/N6C0NFq2Dduhs" "EsiAKtSG+ugKqyUJen0scM8y5/P/dcntdkuz2YwmkwltNptr/yWk/1dIjpf7y34i+3iyvXXp" "IeQ71YoZtfcAlJ45ZhOn/PIG34a0+uo/c7T2J3rm19ofPZ2j+MnvrW+7sK3xQ9prlBM8uZoO" "AaytEzjrpCUDLKzY4YElL39GIL4K8L3chOasx2RjX2VMZINsZxro8C0tvm311a9+lT788EN6" "+eWX92PnRETr1XJ3+/ZtiKylscrfykEGrJ8tkOMhSW+imlCS7kGdmb7e9YyxRDyjcUwtht3r" "DN417311/VAwaFlPvR8ZvfW1bCLNJHFt/xrMzWazvbNOp1PabDb7fdN/p8KJxALfshCx5mbN" "s5pM0Fpo38wGPQ94VyplNNbSE/EfBYKiteXrvNdovH7O8szGEkkREEH/3oWAAAAEp0lEQVRf" "7eVxEtxI+0RxH8mN6BDgO9IhsxeWfpVCKcqlTNZv0lVju6evpbPnm6hPVhcPuKHrVbueE33y" "rSq+TXV1dUWLxYIuLy9psVjQYrGg5XL5CLjRE7JAjH4dXR9BkUNlQU42+GcMxKPKplUNCc21" "h0flfWZeXnBHfVEy8vTJgCRLbgVwonFWgNKVG1cqs9ls/56rcQ/kWPNleWit0Hro117CtwCM" "Bm/6um7zSMv3gA9a66jvIShKiKiv3AdvvNU36ofea4qSvdxX9JslTPoUR/7W0wigc8i9yxQD" "Xjta40phpdfHypVRPo3m4+mf7YPsw5oTj6sCnkyhI+2Rv2E1m83oqaeeouPjY/r5z366+7u/" "/4fJXE+GA+pyubwGeFar1bWg6W2C5zTepqEJZcFItBgjAZTkq197yd1KHig5RFVlNKaV0JpH" "DhAFggrAawWIVQBjJV10281L4HKsNSbjuOywm81m76wS5HACkb86rqs6vW+Zk5wKqKskykz1" "GpFe8xFAB1HPWMRHvvfsOQIqXlsEYizwFJEXu9lG+TXfTpXrJ09wJOCx+FttPTQazEp+nr9E" "+6cJxSAEZCIQWvlNu0gn73rWp3v9ycIFkq+8Lr9GPpvN6Gtf+xrdv3+fXnrpJSIimvOtKjbK" "xWJBZ2dndHZ2RpeXl/u/dZAfNPYMNYM2ZRsnA2sCSE60SYcANIgqiaLV6SqJRY+proNnWJEu" "1vWeiiFDLfzQew/EWHKrCdvzG04Ws9lsD3Tk13Y5YcgP/ltH11JeJthV1x/5rMdfz9Vr89Z1" "ZNFzSMqua9QPgRmvHb22xkeJ02pnntPplNbr9SO3rPQvduvfU8vKPTShPOIVK5U448XMbDzn" "1x6AQXnUmkcU37I5KwN0dFyIdLP4WLInk8m1E8JIx/mrr75K9+/fp5OTE3rw4AEdHx/TxcXF" "/ttUqBpEAS569l5nJjkySI2o9ioG4AUXz4ksvpYRj6ieM/JRW8Z5UILyAnSkd1Uva/0jnpZs" "z3EtAGDtnf65cn7NDs0JQwIcDWJ0oZApFrIgNAMCI9/I+L/Ht0KVSjbD3xsj110nuhYb9cbz" "nnl8W5JsZCt6vP4BQCYNciTwQXKs95b/jwCoEbDOghqr3dt7r13riA4OPD/K7mFGj4yOUZHj" "Uc8pj9fOvvHlL3+ZHj58SP/yi5/v5svlkv7yl7/QRx99tAc4y+XykUDpLWZm0SsbkFmAStCN" "+HgG3VLhozbU3pLELYqA0iGATva6Nf8Kn8patACXnj4ZkJMF7xLgyJMc69srzAMl4eyJiDe3" "EUnFoyrYyYDfSM6h5yRlVJIlX4vGegBIt3uAB1HWTtGD++kTHQS6szHfSu6H3MMIwCIdDuFP" "Uo/oA8feay2/FzzyfvfmFO/wBPXzZMo4OZlM6Otf/zo9fPiQXnzxRZr/9re/pbfeeotOT0/3" "t6ZQgOw5ZqouRuviRcgSnSSMoh4QMFoXKW8k79ZA0xOQRgezx5HgKoTW00pk1a/k3gSxjXjJ" "YXRw/LRQa2LLjIv8rgXY9xJK8jrRZm3007qnEd1EPDnkej5OMCmpchoeEcfP9XpNRET/Ax6j" "kIck2UJrAAAAAElFTkSuQmCC") # ---------------------------------------------------------------------------- # ZoomBar events and binding for handling them # ---------------------------------------------------------------------------- wxEVT_ZOOMBAR = wx.NewEventType() EVT_ZOOMBAR = wx.PyEventBinder(wxEVT_ZOOMBAR, 1) """ Process a `wxEVT_ZOOMBAR` event, when a :class:`ZoomBar` button is clicked. """ # ---------------------------------------------------------------------------- def MakeDisabledBitmap(original): """ Creates a disabled-looking bitmap starting from the input one. :param `original`: an instance of :class:`wx.Bitmap` to be greyed-out. """ img = original.ConvertToImage() return wx.Bitmap(img.ConvertToGreyscale()) # ---------------------------------------------------------------------------- class ZoomBarImage(object): """ This simple class holds information about a :class:`ZoomBar` button, such as normal bitmaps, disabled bitmap, button label, etc... """ def __init__(self, parent, bitmap, disabledBmp=wx.NullBitmap, label=""): """ Default class constructor. :param `parent`: the main :class:`ZoomBar` window; :param `bitmap`: the button bitmap, an instance of :class:`wx.Bitmap`; :param `disabledBmp`: the button bitmap when the button is in a disabled state; :param `label`: the button label. """ self._parent = parent self._bitmap = bitmap if not disabledBmp.IsOk(): disabledBmp = MakeDisabledBitmap(bitmap) self._disabledBmp = disabledBmp self._label = label self._height = 36 self._width = 36 self._oldnx = 0 self._oldLeft = 0 self._oldTop = 0 self._oldWidth = 0 self._oldBottom = 0 self._oldHeight = 0 self._vCenter = 0 self._hCenter = 0 self._oldInc = -six.MAXSIZE self._isSeparator = False self._enabled = True # Larger number gives a greater zoom effect self._zoomFactor = 3 # Whether this is a reflection or not self._isAReflection = False self._cachedBitmaps = {} self._cachedDisabledBitmaps = {} def SetZoomFactor(self, zoom): """ Sets the zoom factor for the button. Larger number gives a greater zoom effect. :param `zoom`: a floating point number, greater than or equal to 1.0. """ self._zoomFactor = zoom def SetCenterZoom(self, center=True): """ Sets to zoom from the center. :param `center`: if ``True`` button zooms upwards. """ self._centerZoom = center def ZoomImage(self, nxcoord): """ Zooms the button bitmap depending on the mouse x position. :param `nxcoord`: the mouse x position relative to the button center. """ if nxcoord < self._vCenter: inc = int(((nxcoord - self._oldLeft)*10.0)/(self._oldWidth/2.0)) + 1 else: inc = int(((self._oldLeft + self._oldWidth - nxcoord)*10.0)/(self._oldWidth/2)) + 1 if self._isSeparator: return False if abs(inc - self._oldInc) < 2: return False self._oldInc = inc if not self._isAReflection: # original button inc = inc*self._zoomFactor self._width = self._oldWidth + inc self._left = self._vCenter - self._width/2 self._height = self._oldHeight + inc self._top = self._oldBottom - self._height else: # the reflection self._height = self._oldHeight + inc self._width = self._oldWidth + inc self._top = self._top + self._height self._oldnx = nxcoord return True def SetSize(self, width, height): """ Sets the button size. :param `width`: the button width; :param `height`: the button height. """ self._width = width self._height = height def GetPosition(self): """ Returns the button position. """ return wx.Point(self._left, self._top) def GetSize(self): """ Returns the button size. """ return wx.Size(self._width, self._height) def GetBitmap(self): """ Returns the button bitmap, which may be a scaled up version of the original bitmap is the button is being zoomed. """ if self._isAReflection: return self._paintBitmap if self._enabled: return self._cachedBitmaps[self._width] return self._cachedDisabledBitmaps[self._width] def SetupProps(self, buttonSize): """ Set up the button position and size. :param `buttonSize`: the button original size (not zoomed), in pixels. """ self._width = self._oldWidth = buttonSize self._height = self._oldHeight = buttonSize self._oldLeft = self._left self._oldTop = self._top self._vCenter = self._oldLeft + int(self._oldWidth/2.0) self._hCenter = self._oldTop + int(self._oldHeight/2.0) self._oldBottom = self._top + self._height if self._isAReflection: img = self._bitmap.ConvertToImage() img = img.Scale(self._width, self._height, wx.IMAGE_QUALITY_HIGH) self._paintBitmap = img.ConvertToBitmap() def GetLabel(self): """ Returns the button label (if any). """ return self._label def SetLabel(self, label): """ Sets the button label. :param `label`: a string specifying the button label. May be an empty string for no label. """ self._label = label def IsZoomed(self): """ Returns ``True`` if the button is zoomed, ``False`` otherwise. """ return self._width/float(self._oldWidth) >= 1.25 def LoopScales(self, size): """ Caches the bitmaps at various zoom levels to avoid calling every time `image.Scale` on the button bitmap. :param `size`: the original button size, in pixels. """ if self._isAReflection: return for scale in range(size-10*self._zoomFactor, size+15*self._zoomFactor, self._zoomFactor): if scale in self._cachedBitmaps or scale <= 0: continue img = self._bitmap.ConvertToImage() img = img.Scale(scale, scale, wx.IMAGE_QUALITY_HIGH) bmp = img.ConvertToBitmap() self._cachedBitmaps[scale] = bmp img = self._disabledBmp.ConvertToImage() img = img.Scale(scale, scale, wx.IMAGE_QUALITY_HIGH) bmp = img.ConvertToBitmap() self._cachedDisabledBitmaps[scale] = bmp def Enable(self, enable=True): """ Enables/disables a button. :param `enable`: ``True`` to enable a button, ``False`` to disable it. """ self._enabled = enable def IsEnabled(self): """ Returns ``True`` if the button is enabled, ``False`` otherwise. """ return self._enabled class ImageBar(object): """ This class holds the background button bar on which the buttons float. """ def __init__(self, bitmap=None): """ Default class constructor. :param `bitmap`: if not ``None``, the bitmap to use as a background button bar on which the buttons float. It should be an instance of :class:`wx.Image`. """ if bitmap and bitmap.IsOk(): self._bitmap = bitmap self._hasBitmap = bitmap else: self._bitmap = zoombackgrey.GetImage() self._hasBitmap = None self._left = 23 self._top = 53 self._startColour = wx.Colour(97, 97, 97) self._endColour = wx.Colour(97, 97, 97) def GetPosition(self): """ Returns the position of :class:`wx.ImageBar`, as a :class:`wx.Point`. """ return wx.Point(self._left, self._top) def GetSize(self): """ Returns the size of :class:`wx.ImageBar`, as a :class:`wx.Size`. """ return wx.Size(self._bitmap.GetWidth(), self._bitmap.GetHeight()) def GetBitmap(self): """ Returns the background button bar on which the buttons float. """ if isinstance(self._bitmap, wx.Image): return wx.Bitmap(self._bitmap) return self._bitmap def SetPosition(self, xpos, ypos): """ Sets the position of :class:`wx.ImageBar`. :param `xpos`: the `x` position of the bar; :param `ypos`: the `y` position of the bar. """ self._left = xpos self._top = ypos def SetSize(self, xSize, ySize): """ Sets the size of :class:`wx.ImageBar`. :param `xSize`: the width of the bar, in pixels; :param `ySize`: the height of the bar, in pixels. """ self.SetBarColour(self._startColour, xSize, ySize) def SetBarColour(self, colour, xSize=None, ySize=None): """ Sets the background button bar colour. :param `colour`: an instance of :class:`wx.Colour`; :param `xSize`: if not ``None``, the new :class:`wx.ImageBar` width; :param `ySize`: if not ``None``, the new :class:`wx.ImageBar` height. """ if not isinstance(colour, wx.Colour): colour = wx.Colour(colour) if self._hasBitmap: bitmap = self._hasBitmap else: bitmap = zoombackgrey.GetImage() if xSize is not None: self._size = wx.Size(xSize, ySize) bitmap.Rescale(self._size.width, self._size.height/2) r1, g1, b1 = self._startColour.Red(), self._startColour.Green(), self._startColour.Blue() r2, g2, b2 = colour.Red(), colour.Green(), colour.Blue() fr = (r1 > 0 and [float(r2)/r1] or [0])[0] fg = (g1 > 0 and [float(g2)/g1] or [0])[0] fb = (b1 > 0 and [float(b2)/b1] or [0])[0] bitmap = bitmap.AdjustChannels(fr, fg, fb, 1) self._bitmap = bitmap.ConvertToBitmap() self._endColour = colour def GetBarColour(self): """ Returns the background button bar colour. """ return self._endColour class ZoomBarEvent(wx.PyCommandEvent): """ Event sent from the :class:`ZoomBar` when a button is activated. """ def __init__(self, eventType, eventId=1): """ Default class constructor. :param `eventType`: the event type; :param `eventId`: the event identifier. """ wx.PyCommandEvent.__init__(self, eventType, eventId) self._eventType = eventType def SetSelection(self, selection): """ Sets the index of the selected button. :param `selection`: an integer indicating the current selected button. """ self._selection = selection def GetSelection(self): """ Returns the index of the selected button. """ return self._selection def GetLabel(self): """ Returns the text label of the selected button. """ return self._label def SetLabel(self, label): """ Sets the text label of the selected button. :param `label`: the text label of the selected button. """ self._label = label class ZoomBar(wx.Control): """ :class:`ZoomBar` is a class that *appoximatively* mimics the behaviour of the Mac Dock, inside a :class:`Panel`. This is the main class implementation. """ def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size=wx.DefaultSize, name="ZoomBar"): """ Default class constructor. :param `parent`: the :class:`ZoomBar` parent. Must not be ``None``; :param `id`: window identifier. A value of -1 indicates a default value; :param `pos`: the control position. A value of (-1, -1) indicates a default position, chosen by either the windowing system or wxPython, depending on platform; :param `size`: the control size. A value of (-1, -1) indicates a default size, chosen by either the windowing system or wxPython, depending on platform; :param `name`: the window name. """ wx.Control.__init__(self, parent, id, pos, size, style=wx.BORDER_THEME) # Zoom from the center. If True button zooms upwards. self._centerZoom = False # Whether you want reflections or not self._showReflections = True # Allows us to nudge a reflection closer to original self._nudgeReflection = 0 # Extension of the reflection. BMP or PNG etc. # Initial size of the buttons self._buttonSize = 48 # Show labels on hovering self._showLabels = True # used internally self._noResize = False self._buttons = [] self._reflectionButtons = [] self._imgBar = ImageBar() self._previousHit = -1 self._currentHit = -1 wx.CallLater(200, self.OnLeaveWindow, None) self.Bind(wx.EVT_PAINT, self.OnPaint) self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground) self.Bind(wx.EVT_SIZE, self.OnSize) self.Bind(wx.EVT_MOTION, self.OnMotion) self.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeaveWindow) self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown) self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp) if wx.Platform == "__WXMSW__": self.Bind(wx.EVT_LEFT_DCLICK, self.OnLeftDown) self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM) def DoGetBestSize(self): """ Gets the size which best suits the window: for a control, it would be the minimal size which doesn't truncate the control, for a panel - the same size as it would have after a call to `Fit()`. :note: Overridden from :class:`wx.Control`. """ xSize = self._buttonSize*len(self._buttons) + len(self._buttons) + self._buttonSize ySize = self._buttonSize*2 if self._showLabels: dc = wx.ClientDC(self) dummy, yextent = dc.GetTextExtent("Ajgt") ySize += yextent return wx.Size(xSize+50, ySize+20) # reposition the buttons def Reposition(self, toButton): """ Repositions all the buttons inside the :class:`ZoomBar`. :param `toButton`: the button currently hovered by the mouse (and hence zoomed). """ nLeft = toButton._left nRight = toButton._left + toButton._width + 1 nButton = self._buttons.index(toButton) # do any buttons on the right for n in range(nButton + 1, len(self._buttons)): oButton = self._buttons[n] oButton._left = nRight if self._showReflections: oButtonR = self._reflectionButtons[n] oButtonR._left = nRight nRight = nRight + oButton._width + 1 # Reset nLeft = toButton._left # now to the left if nButton > 0: # only for 2nd and more for n in range(nButton-1, -1, -1): oButton = self._buttons[n] oButton._left = nLeft - (oButton._width + 1) if self._showReflections: oButtonR = self._reflectionButtons[n] oButtonR._left = oButton._left nLeft = oButton._left # method to add required buttons def AddButton(self, normalBmp, reflectionBmp=wx.NullBitmap, label="", disabledBmp=wx.NullBitmap, disabledReflectionBmp=wx.NullBitmap): """ Adds a button to :class:`ZoomBar`. :param `normalBmp`: the button main bitmap, an instance of :class:`wx.Bitmap`; :param `reflectionBmp`: a bitmap representing a reflection of the main bitmap, an instance of :class:`wx.Bitmap`; :param `label`: the button label; :param `disabledBmp`: the button main bitmap when the button is in a disabled state, an instance of :class:`wx.Bitmap`; :param `disabledReflectionBmp`: a bitmap representing a reflection of the main bitmap, when the button is in a disabled state, an instance of :class:`wx.Bitmap`. """ button = ZoomBarImage(self, normalBmp, disabledBmp, label) button.SetSize(self._buttonSize, self._buttonSize) button._centerZoom = (self._showReflections and [False] or [self._centerZoom])[0] self._buttons.append(button) self.InitialReposition() if self._showReflections and reflectionBmp.IsOk(): rbutton = ZoomBarImage(self, reflectionBmp, disabledReflectionBmp) rbutton.SetSize(self._buttonSize, self._buttonSize) rbutton._centerzoom = False rbutton._isAReflection = True self._reflectionButtons.append(rbutton) return button def AddSeparator(self, normalBmp, reflectionBmp=wx.NullBitmap): """ Adds a separator to :class:`ZoomBar`. :param `normalBmp`: the separator main bitmap, an instance of :class:`wx.Bitmap`; :param `reflectionBmp`: a bitmap representing a reflection of the main bitmap, an instance of :class:`wx.Bitmap`. """ button = self.AddButton(normalBmp, reflectionBmp) button._isSeparator = True def SetZoomFactor(self, zoom): """ Sets the zoom factor for all the buttons. Larger number gives a greater zoom effect. :param `zoom`: a floating point number, greater than or equal to 1.0. """ if zoom < 1: raise Exception("The zoom factor must be greater or equal to 1") for button in self._buttons: button._zoomFactor = zoom self._zoomFactor = zoom self.DoLayout() def GetZoomFactor(self): """ Returns the current zoom factor. """ return self._zoomFactor def SetCenterZoom(self, center=True): """ Sets to zoom from the center. :param `center`: if ``True`` button zooms upwards. """ self._centerZoom = center for button in self._buttons: button._centerZoom = (self._showReflections and [False] or [self._centerZoom])[0] self.DoLayout() def GetCenterZoom(self): """ Returns ``True`` if buttons zoom upwards. """ return self._centerZoom def SetShowReflections(self, show): """ Sets whether to show reflections or not. :param `show`: ``True`` to show reflections, ``False`` otherwise. """ self._showReflections = show self.DoLayout() def GetShowReflections(self): """ Returns ``True`` if reflections bitmap are currently shown. """ return self._showReflections def SetShowLabels(self, show): """ Sets whether to show button labels or not. :param `show`: ``True`` to show button labels, ``False`` otherwise. """ self._showLabels = show self.DoLayout() def GetShowLabels(self): """ Returns ``True`` if button labels are currently shown. """ return self._showLabels def SetBarColour(self, colour): """ Sets the background button bar colour. :param `colour`: an instance of :class:`wx.Colour`; """ self._imgBar.SetBarColour(colour) self.Refresh() def GetBarColour(self): """ Returns the background button bar colour. """ return self._imgBar.GetBarColour() def SetButtonSize(self, size): """ Sets the original button size. :param `size`: the new (not-zoomed) button size, in pixels. """ self._buttonSize = size self.DoLayout() def GetButtonSize(self): """ Returns the original (not zoomed) button size, in pixels. """ return self._buttonSize def EnableButton(self, index, enable=True): """ Enables/disables the button at position `index`. :param `index`: the index of the button to enable/disable; :param `enable`: ``True`` to enable the button, ``False`` to disable it. """ if index < 0 or index >= len(self._buttons): return False self._buttons[index].Enable(enable) self.Refresh() return True def IsButtonEnabled(self, index): """ Returns ``True`` if the button at position `index` is enabled, ``False`` otherwise. :param `index`: the index of the button to check. """ if index < 0 or index >= len(self._buttons): return False return self._buttons[index].IsEnabled() def DoLayout(self): """ Common method to re-layout :class:`ZoomBar`. """ self.ResetSize() self.GetContainingSizer().Layout() self.Refresh() def ResetSize(self): """ Resets all the button sizes and positions, recalculating the optimal :class:`ZoomBar` size. """ xSize = self._buttonSize*len(self._buttons) + len(self._buttons) + self._buttonSize ySize = self._buttonSize*2 self._imgBar.SetSize(xSize+self._buttonSize, ySize) for button in self._buttons: button.LoopScales(self._buttonSize) if self._showLabels: dc = wx.ClientDC(self) dummy, yextent = dc.GetTextExtent("Ajgt") ySize += yextent if self._showReflections: ySize += self._buttonSize/2 if self._centerZoom: ySize += self._buttonSize size = wx.Size(xSize+50, ySize) self.SetInitialSize(size) self.SnapToBottom(size) # Sets up the initial buttons and sizes them from the center def InitialReposition(self): """ Sets up the initial buttons and sizes them from the center. """ # repositions the button centrally # odd buttons one is central - even, half by half if not self._buttons: return size = self.GetSize() oButton = self._buttons[0] totalWidth = oButton._width*len(self._buttons) + len(self._buttons) center = size.GetWidth()/2 nbCenter = totalWidth/2 nLeft = center - nbCenter if self._showReflections: nTop = self._imgBar._top - (oButton._height/2) else: if self._centerZoom: nTop = size.height/2 - oButton._height/2 else: nTop = size.height - oButton._height - 5 for oButton in self._buttons: oButton._left = nLeft oButton._top = nTop oButton.SetupProps(self._buttonSize) nLeft = nLeft + oButton._width+1 # And the reflection if any if self._showReflections: nLeft = center - nbCenter nudge = self._nudgeReflection for oButton in self._reflectionButtons: oButton._left = nLeft oButton._top = (nTop + oButton._height - 2) - nudge oButton.SetupProps(self._buttonSize) nLeft = nLeft + oButton._width + 1 def OnLeaveWindow(self, event): """ Handles the ``wx.EVT_LEAVE_WINDOW`` event for :class:`ZoomBar`. :param `event`: a :class:`MouseEvent` event to be processed. """ if self.GetScreenRect().Contains(wx.GetMousePosition()): return for button in self._buttons: button.SetSize(self._buttonSize, self._buttonSize) self.InitialReposition() self.Refresh() def OnSize(self, event): """ Handles the ``wx.EVT_SIZE`` event for :class:`ZoomBar`. :param `event`: a :class:`wx.SizeEvent` event to be processed. """ self.SnapToBottom(event.GetSize()) self.Refresh() event.Skip() def SnapToBottom(self, size): """ Snaps the background button bar bitmap and all the buttons to the bottom of :class:`ZoomBar`. :param `size`: the current :class:`ZoomBar` size. """ backgroundSize = self._imgBar.GetSize() xPos = (size.width - backgroundSize.width)/2 yPos = (size.height - backgroundSize.height) self._imgBar.SetPosition(xPos, yPos) self.InitialReposition() def OnPaint(self, event): """ Handles the ``wx.EVT_PAINT`` event for :class:`ZoomBar`. :param `event`: a :class:`PaintEvent` event to be processed. """ dc = wx.AutoBufferedPaintDC(self) dc.SetBackground(wx.WHITE_BRUSH) dc.Clear() background = self._imgBar.GetBitmap() pos = self._imgBar.GetPosition() dc.DrawBitmap(background, pos.x, pos.y, True) if not self._buttons: return self.DrawButtons(dc) self.DrawReflections(dc) self.DrawLabels(dc) def DrawButtons(self, dc): """ Draws all the main button bitmaps on the :class:`ZoomBar` client window. :param `dc`: an instance of :class:`wx.DC`. """ for button in self._buttons: pos = button.GetPosition() bitmap = button.GetBitmap() dc.DrawBitmap(bitmap, pos.x, pos.y, True) def DrawReflections(self, dc): """ Draws all the reflection button bitmaps on the :class:`ZoomBar` client window. :param `dc`: an instance of :class:`wx.DC`. """ if self._showReflections: for button in self._reflectionButtons: pos = button.GetPosition() bitmap = button.GetBitmap() dc.DrawBitmap(bitmap, pos.x, pos.y, True) def DrawLabels(self, dc): """ Draws all the button labels on the :class:`ZoomBar` client window. :param `dc`: an instance of :class:`wx.DC`. """ if not self._showLabels: return dc.SetBrush(wx.WHITE_BRUSH) dc.SetPen(wx.BLACK_PEN) for button in self._buttons: if not button.IsZoomed(): continue label = button.GetLabel() if not label: continue textWidth, textHeight = dc.GetTextExtent(label) buttonPos = button.GetPosition() buttonSize = button.GetSize() xpos = buttonPos.x + (buttonSize.width - textWidth)/2 ypos = buttonPos.y - textHeight - 2 dc.DrawRectangle(xpos-2, ypos-1, textWidth+4, textHeight+2) dc.DrawText(label, xpos, ypos) def OnEraseBackground(self, event): """ Handles the ``wx.EVT_ERASE_BACKGROUND`` event for :class:`ZoomBar`. :param `event`: a :class:`EraseEvent` event to be processed. :note: This method is intentionally empty to avoid flicker. """ pass def OnMotion(self, event): """ Handles the ``wx.EVT_MOTION`` event for :class:`ZoomBar`. :param `event`: a :class:`MouseEvent` event to be processed. """ pos = event.GetPosition() hit = self.HitTest(pos) if hit >= 0: button = self._buttons[hit] if not button.ZoomImage(pos.x): return self.Reposition(button) else: if self._previousHit < 0: return for button in self._buttons: button.SetSize(self._buttonSize, self._buttonSize) self.InitialReposition() self._previousHit = hit self.Refresh() def OnLeftDown(self, event): """ Handles the ``wx.EVT_LEFT_DOWN`` and ``wx.EVT_LEFT_DCLICK`` events for :class:`ZoomBar`. :param `event`: a :class:`MouseEvent` event to be processed. """ self._currentHit = self.HitTest(event.GetPosition()) def OnLeftUp(self, event): """ Handles the ``wx.EVT_LEFT_UP`` event for :class:`ZoomBar`. :param `event`: a :class:`MouseEvent` event to be processed. """ if self.HitTest(event.GetPosition()) != self._currentHit: return if not self.IsButtonEnabled(self._currentHit): return eventOut = ZoomBarEvent(wxEVT_ZOOMBAR, self.GetId()) eventOut.SetSelection(self._currentHit) eventOut.SetLabel(self._buttons[self._currentHit].GetLabel()) eventOut.SetEventObject(self) self.GetEventHandler().ProcessEvent(eventOut) def HitTest(self, pos): """ HitTest method for :class:`ZoomBar`. :param `pos`: the current mouse position. :return: an index representing the button on which the mouse is hovering, or ``wx.NOT_FOUND`` if no button has been hit. """ for index, button in enumerate(self._buttons): buttonPos = button.GetPosition() if pos.x >= buttonPos.x and pos.x <= buttonPos.x + button._width: return index return wx.NOT_FOUND