\ j dZddlZddlZddlZddlZddlZddlZddlZddlmZddl m Z ddl m Z ddl mZeedoejZGdd eZGd d eZGd d eZGddeZGddeZGddZGddeZGddeZGddZGddeZGddeZdZdZGd d!e Z!Gd"d#ee!e Z"e"#d$e"#d%e"#d&e"#d'e"#d(e"#d)e"#d*e"#d+e"#d,e"#d-e"#d.e"#d/e"#d0e"#d1e"#d2e"#d3e"#d4e"#d5e"#d6e"#d7e"#d8e"#d9e"#d:e"#d;Gd<d=Z$er e"Z%d>e%_&["n(((**   ++'rctjtjtjztjddddtjtjtjtjtj |j ||j z ||j z dtjdS)Nr)r glPushAttrib GL_ENABLE_BITGL_CURRENT_BIT glColor4fglEnableGL_BLEND glBlendFunc GL_SRC_ALPHAGL_ONE_MINUS_SRC_ALPHAr+blitr,r- glPopAttribrs rr!zImageMouseCursor.draws (2+<<=== Q1a    BK    r(ABBB !dj.!dj.!<<< rN)rrF)r r r rr0r!rrrr(r(sA((((6rr(ceZdZdZdZdS) ProjectionzAbstract OpenGL projection.c td)aSet the OpenGL projection Using the passed in Window and viewport sizes, set a desired orthographic or perspective projection. :Parameters: `window_width` : int The Window width `window_height` : int The Window height `viewport_width` : int The Window internal viewport width. `viewport_height` : int The Window internal viewport height. abstractNotImplementedErrorr window_width window_heightviewport_widthviewport_heights rsetzProjection.sets "*---rNr r r rrIrrrr?r?s)%%.....rr?ceZdZdZdZdS) Projection2DzA 2D orthographic projectionc ttjddtd|td|tjtjtjtjdtd|dtd|ddtjtjdS)Nrr2)r glViewportmax glMatrixMode GL_PROJECTIONglLoadIdentityglOrtho GL_MODELVIEWrDs rrIzProjection2D.sets aC>22C?4K4KLLL ()))  1c!\**As1m/D/Db!LLL (((((rNrJrrrrLrLs)&&)))))rrLc eZdZdZddZdZdS) Projection3DzA 3D perspective projection<皙?c0||_||_||_dS)a.Create a 3D projection :Parameters: `fov` : float The field of vision. Defaults to 60. `znear` : float The near clipping plane. Defaults to 0.1. `zfar` : float The far clipping plane. Defaults to 255. N)fovznearzfar)rr\r]r^s rr0zProjection3D.__init__s  rc tjddtd|td|tjtjtjt |t |z }tj|j dz tj z|j z}||z}tj | || ||j |j tjtjdS)Nrr2gv@)rrOrPrQrRrSfloatmathtanr\pir] glFrustumr^rU)rrErFrGrH aspect_ratiof_widthf_heights rrIzProjection3D.set,s aC>22C?4K4KLLL ())) \**U=-A-AA (48e+dg577$*D\) hY7(GTZSSS (((((rN)rXrYrZ)r r r rr0rIrrrrWrWs=%%     ) ) ) ) )rrWcfd}|S)aDecorator for platform event handlers. Apply giving the platform-specific data needed by the window to associate the method with an event. See platform-specific subclasses of this decorator for examples. The following attributes are set on the function, which is returned otherwise unchanged: _platform_event True _platform_event_data List of data applied to the function (permitting multiple decorators on the same method). cxd|_t|dsg|_|j|S)NT_platform_event_data)_platform_eventhasattrrjappend)fdatas r_event_wrapperz-_PlatformEventHandler.._event_wrapperKsB q011 (%'A " %%d+++rr)rorps` r_PlatformEventHandlerrq:s$" rcd|_|S)NT)_view)rns r_ViewEventHandlerrtUsAG Hrc"eZdZdZfdZxZS)_WindowMetaclasszNSets the _platform_event_names class variable on the window subclass. crt|_|D]1}t|dr|j|j2|D]/\}}t|dr|j|0t t||||dS)N_platform_event_namesrk) rIrxrlupdateitemsaddsuperrvr0)clsnamebasesdictbasefunc __class__s rr0z_WindowMetaclass.__init___s$'EE! M MDt455 M)001KLLL**,, 4 4JD$t.// 4)--d333 $$--dE4@@@@@r)r r r rr0 __classcell__)rs@rrvrvZsKAAAAAAAAArrvcLeZdZdZeZdZdZdZdZ dZ dZ dZ dZ d Zd Zd Zd Zd ZdZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!dZ"dZ#dZ$dZ%eZ&dZ'dZ(dZ)dZ*dZ+dZ,dZ-e.Z/dZ0dZ1e2Z3dZ4dZ5dZ6dZ7dZ8dZ9dZ:dZ;dZd Z?d!Z@d"ZAd#ZBd$ZCd%ZD dmd&ZEd'ZFd(ZGd)ZHd*ZId+ZJd,ZKeLd-ZMeLd.ZNeLd/ZOeLd0ZPeLd1ZQeLd2ZReLd3ZSeLd4ZTeLd5ZUeLd6ZVeLd7ZWeWjXd8ZWeLd9ZYeYjXd:ZYeLd;ZZeZjXd<ZZd=Z[d>Z\d?Z]d@Z^dAZ_dBZ`dCZaeaZbdDZcdEZddFZedndGZfdHZgdIZhdJZidndKZjdodLZkdodMZldndNZmdndOZndPZodQZpdRZqdSZrdTZsetrJdUZIdVZudWZvdXZwdYZxdZZyd[Zzd\Z{d]Z|d^Z}d_ZHd`Z~daZdbZdcZGddZdeZdfZdgZdhZdiZdjZdkZdlZdSdS)p BaseWindowaAPlatform-independent application window. A window is a "heavyweight" object occupying operating system resources. The "client" or "content" area of a window is filled entirely with an OpenGL viewport. Applications have no access to operating system widgets or controls; all rendering must be done via OpenGL. Windows may appear as floating regions or can be set to fill an entire screen (fullscreen). When floating, windows may appear borderless or decorated with a platform-specific frame (including, for example, the title bar, minimize and close buttons, resize handles, and so on). While it is possible to set the location of a window, it is recommended that applications allow the platform to place it according to local conventions. This will ensure it is not obscured by other windows, and appears on an appropriate screen for the user. To render into a window, you must first call `switch_to`, to make it the current OpenGL context. If you use only one window in the application, there is no need to do this. Ndialogtool borderless transparentoverlay crosshairhandhelpnosizesize_up size_up_right size_rightsize_down_right size_downsize_down_left size_left size_up_left size_up_downsize_left_righttextwait wait_arrowFTriicTtj|g|_| stj} | s| } | shtjddtjdddfD])} | |} n#t$rY&wxYw| std|dvrd| _ | s| | } | s| tj} | |_|jj|_t%|jd r|jj|_n| |_|jj|_|rB|||j|jf|_||||\}}|js ||f|_n||j}||j}||_||_||_||_||_tj d tj d |_!n||_!| |_"|tFj$d }||_%d d lm&}|j'(||)| *}|+d d sUd|,d|-d|.}t_j0||1|r+|2d|3dSdS)a Create a window. All parameters are optional, and reasonable defaults are assumed where they are not specified. The `display`, `screen`, `config` and `context` parameters form a hierarchy of control: there is no need to specify more than one of these. For example, if you specify `screen` the `display` will be inferred, and a default `config` and `context` will be created. `config` is a special case; it can be a template created by the user specifying the attributes desired, or it can be a complete `config` as returned from `Screen.get_matching_configs` or similar. The context will be active as soon as the window is created, as if `switch_to` was just called. :Parameters: `width` : int Width of the window, in pixels. Defaults to 640, or the screen width if `fullscreen` is True. `height` : int Height of the window, in pixels. Defaults to 480, or the screen height if `fullscreen` is True. `caption` : str or unicode Initial caption (title) of the window. Defaults to ``sys.argv[0]``. `resizable` : bool If True, the window will be resizable. Defaults to False. `style` : int One of the ``WINDOW_STYLE_*`` constants specifying the border style of the window. `fullscreen` : bool If True, the window will cover the entire screen rather than floating. Defaults to False. `visible` : bool Determines if the window is visible immediately after creation. Defaults to True. Set this to False if you would like to change attributes of the window before having it appear to the user. `vsync` : bool If True, buffer flips are synchronised to the primary screen's vertical retrace, eliminating flicker. `display` : `Display` The display device to use. Useful only under X11. `screen` : `Screen` The screen to use, if in fullscreen. `config` : `pyglet.gl.Config` Either a template from which to create a complete config, or a complete config. `context` : `pyglet.gl.Context` The context to attach to this window. The context must not already be attached to another window. `mode` : `ScreenMode` The screen will be switched to this mode if `fullscreen` is True. If None, an appropriate mode is selected to accomodate `width` and `height.` T) double_buffer depth_sizeNz No standard config is available.)rrscreenvsyncrappzb Your graphics drivers do not support OpenGL 2.0. You may experience rendering issues or crashes.  )4rr0 _event_queuepygletcanvas get_displayget_default_screenrConfigget_best_configralpha is_completecreate_contextcurrent_context_contextconfig_configrlr_screendisplay_display_default_width_default_height_windowed_size_set_fullscreen_mode_width_height _resizable _fullscreen_styleoptions_vsync _file_dropssysargv_captionrwindowsr{_createget_info have_version get_vendor get_renderer get_versionwarningswarn switch_to set_visibleactivate)rwidthheightcaption resizablestyle fullscreenvisibler file_dropsrrrcontextmodetemplate_configrgl_infomessages rr0zBaseWindow.__init__swV  &&& 2m//11G 2//11F P$&IDR$P$P$P$&IDR$P$P$P$($*  #33ODDFE,D P+,NOOO . . .FL!!## 4++F33F @++B,>??G  }+  4< * * "<.DLL!DL ,  .}&*&94;O&O# 55dE6JJME6& 4&+Vm#}+~-  #% >' " . .1DKKDK% ?hqkG   ""$$##Aq)) #d!,,..dd292F2F2H2HddLSL_L_LaLaddG M' " " "      T " " " MMOOOOO  sB B('B(c@ |dS#YdSxYwN)closers r__del__zBaseWindow.__del__s(  JJLLLLL  DDsc:d|jj|j|jfzS)Nz%s(width=%d, height=%d))rr rrrs r__repr__zBaseWindow.__repr__s(DN,CTZQUQ\+]]]rc td)NrArBrs rrzBaseWindow._creates!*---rc td)aRRecreate the window with current attributes. :Parameters: `changes` : list of str List of attribute names that were changed since the last `_create` or `_recreate`. For example, ``['fullscreen']`` is given if the window is to be toggled to or from fullscreen. rArB)rchangess r _recreatezBaseWindow._recreate"*---rc td)aSwap the OpenGL front and back buffers. Call this method on a double-buffered window to update the visible display with the back buffer. The contents of the back buffer is undefined after this operation. Windows are double-buffered by default. This method is called automatically by `EventLoop` after the :py:meth:`~pyglet.window.Window.on_draw` event. rArBrs rflipzBaseWindow.flip"*---rc td)aTMake this window the current OpenGL rendering context. Only one OpenGL context can be active at a time. This method sets the current window's context to be current. You should use this method in preference to `pyglet.gl.Context.set_current`, as it may perform additional initialisation functions. rArBrs rrzBaseWindow.switch_to"*---rcd||jkr'| ||jur| ||jkr| ||jkrdS|js2||_||_|r||j|jusJ||_||_|jr%| |||\|_|_n?|j |j\|_|_|||_|||_| dg|js|jr|j |jdSdSdS)aToggle to or from fullscreen. After toggling fullscreen, the GL context should have retained its state and objects, however the buffers will need to be cleared and redrawn. If `width` and `height` are specified and `fullscreen` is True, the screen may be switched to a different resolution that most closely matches the given size. If the resolution doesn't match exactly, a higher resolution is selected and the window will be centered within a black border covering the rest of the screen. :Parameters: `fullscreen` : bool True if the window should be made fullscreen, False if it should be windowed. `screen` : Screen If not None and fullscreen is True, the window is moved to the given screen. The screen must belong to the same display as the window. `mode` : `ScreenMode` The screen will be switched to the given mode. The mode must have been obtained by enumerating `Screen.get_modes`. If None, an appropriate mode will be selected from the given `width` and `height`. `width` : int Optional width of the window. If unspecified, defaults to the previous window size when windowed, or the screen size if fullscreen. .. versionadded:: 1.2 `height` : int Optional height of the window. If unspecified, defaults to the previous window size when windowed, or the screen size if fullscreen. .. versionadded:: 1.2 Nr)rrrrget_sizer get_location_windowed_locationrrr restore_moder set_location)rrrrrrs rset_fullscreenzBaseWindow.set_fullscreensmP $* * * ^v55 ]et{22 ^v55 F :"&--//D &*&7&7&9&9D #  "&,>T\1111!DL%   &(,(A(A$v(V(V %DK K $ $ & & &(,(; %DK # !%   ~&&& 8D$; 8 D t6 7 7 7 7 8 8 8 8rc|7|j|| |jj}| |jj}n||n|d}|d}|j||}||j|nF|jrt d||fzn|jj}|jj}||fS)NrzNo mode matching %dx%d)rset_moderrget_closest_mode get_modesr)rrrrs rrzBaseWindow._set_fullscreen_modes   K  & & &} )~+  &"4}~;//v>>D $$T****&&(( \/0HESY?0Z[[[ \K%E['Ff}rcR|jj||g|RdS)aA default resize event handler. This default handler updates the GL viewport to cover the entire window and sets the ``GL_PROJECTION`` matrix to be orthogonal in window space. The bottom-left corner is (0, 0) and the top-right corner is the width and height of the window in pixels. Override this event handler with your own to create another projection, for example in perspective. N) _projectionrIget_framebuffer_sizerrrs r on_resizezBaseWindow.on_resize3s6 UFIT-F-F-H-HIIIIIIrcdd|_ddlm}|jjr|dSdS)zDefault on_close handler.TrrN)has_exitrr event_loop is_runningrrrs ron_closezBaseWindow.on_close@sC  > $  JJLLLLL  rc|tjkrA|tjtjztjzzs|ddSdSdS)zDefault on_key_press handler.r N)rESCAPE MOD_NUMLOCK MOD_CAPSLOCKMOD_SCROLLLOCKdispatch_eventrsymbol modifierss r on_key_presszBaseWindow.on_key_pressGsf SZ  s7:7G8H7:7I8J6K*K     + + + + +   rcddlm}|jsdS|j||jd|_d|_|jr|jd|g|_ dS)a8Close the window. After closing the window, the GL context will be invalid. The window instance cannot be reused once closed (see also `set_visible`). The `pyglet.app.EventLoop.on_window_close` event is dispatched on `pyglet.app.event_loop` when this method is called. rrNon_window_close) rrrrremovedestroyrrrrrs rrzBaseWindow.closeNs }  F 4      > C N ) )*;T B B Brc|jjrD|jr>|jr8t jtjt jt jt j d|j d|j ddt jtj t jt j|j |j|jt jtjt jt jtj t jdSdSdSdS)aDraw the custom mouse cursor. If the current mouse cursor has ``drawable`` set, this method is called before the buffers are flipped to render it. This method always leaves the ``GL_MODELVIEW`` matrix as current, regardless of what it was set to previously. No other GL state is affected. There is little need to override this method; instead, subclass :py:class:`MouseCursor` and provide your own :py:meth:`~MouseCursor.draw` method. rrNr2N) _mouse_cursorr#_mouse_visible_mouse_in_windowrrQrR glPushMatrixrSrTrrrUr!_mouse_x_mouse_y glPopMatrixrs rdraw_mouse_cursorzBaseWindow.draw_mouse_cursorbs%   ) d.A dF[  OB, - - - O         Jq$*ab! < < < OBO , , , O           # #DM4= A A A OB, - - - N    OBO , , , N     !      rc|jS)zDThe window caption (title). Read-only. :type: str )rrs rrzBaseWindow.caption }rc|jS)zJTrue if the window is resizable. Read-only. :type: bool )rrs r resizeablezBaseWindow.resizeables rc|jS)zjThe window style; one of the ``WINDOW_STYLE_*`` constants. Read-only. :type: int )rrs rrzBaseWindow.style {rc|jS)zUTrue if the window is currently fullscreen. Read-only. :type: bool )rrs rrzBaseWindow.fullscreens rc|jS)zRTrue if the window is currently visible. Read-only. :type: bool )_visiblers rrzBaseWindow.visibler"rc|jS)zyTrue if buffer flips are synchronised to the screen's vertical retrace. Read-only. :type: bool )rrs rrzBaseWindow.vsyncr&rc|jS)z\The display this window belongs to. Read-only. :type: :py:class:`Display` )rrs rrzBaseWindow.displayr"rc|jS)z`The screen this window is fullscreen in. Read-only. :type: :py:class:`Screen` )rrs rrzBaseWindow.screen |rc|jS)ztA GL config describing the context of this window. Read-only. :type: :py:class:`pyglet.gl.Config` )rrs rrzBaseWindow.configr-rc|jS)znThe OpenGL context attached to this window. Read-only. :type: :py:class:`pyglet.gl.Context` )rrs rrzBaseWindow.contextr"rc6|dS)zMThe width of the window, in pixels. Read-write. :type: int rrrs rrzBaseWindow.width }}q!!rc<|||jdSr)set_sizer)r new_widths rrzBaseWindow.widths i-----rc6|dS)zNThe height of the window, in pixels. Read-write. :type: int r2r1rs rrzBaseWindow.heightr2rc<||j|dSr)r4r)r new_heights rrzBaseWindow.heights dj*-----rc|jS)aThe OpenGL window projection. Read-write. The default window projection is orthographic (2D), but can be changed to a 3D or custom projection. Custom projections should subclass :py:class:`pyglet.window.Projection`. There are two default projection classes are also provided, which are :py:class:`pyglet.window.Projection3D` and :py:class:`pyglet.window.Projection3D`. :type: :py:class:`pyglet.window.Projection` )rrs r projectionzBaseWindow.projections rct|tsJ|j|j|jg|R||_dSr) isinstancer?rIrrrr)rr:s rr:zBaseWindow.projectionsR*j11111 t{DLO43L3L3N3NOOOO%rc td)aSet the window's caption. The caption appears in the titlebar of the window, if it has one, and in the taskbar on Windows and many X11 window managers. :Parameters: `caption` : str or unicode The caption to set. rArB)rrs r set_captionzBaseWindow.set_captions"*---rc td)avSet the minimum size of the window. Once set, the user will not be able to resize the window smaller than the given dimensions. There is no way to remove the minimum size constraint on a window (but you could set it to 0,0). The behaviour is undefined if the minimum size is set larger than the current size of the window. The window size does not include the border or title bar. :Parameters: `width` : int Minimum width of the window, in pixels. `height` : int Minimum height of the window, in pixels. rArBrs rset_minimum_sizezBaseWindow.set_minimum_sizes&"*---rc td)aSet the maximum size of the window. Once set, the user will not be able to resize the window larger than the given dimensions. There is no way to remove the maximum size constraint on a window (but you could set it to a large value). The behaviour is undefined if the maximum size is set smaller than the current size of the window. The window size does not include the border or title bar. :Parameters: `width` : int Maximum width of the window, in pixels. `height` : int Maximum height of the window, in pixels. rArBrs rset_maximum_sizezBaseWindow.set_maximum_size's("*---rc td)aResize the window. The behaviour is undefined if the window is not resizable, or if it is currently fullscreen. The window size does not include the border or title bar. :Parameters: `width` : int New width of the window, in pixels. `height` : int New height of the window, in pixels. rArBrs rr4zBaseWindow.set_size="*---rcF|d|jz S)aIReturn the framebuffer/window size ratio. Some platforms and/or window systems support subpixel scaling, making the framebuffer size larger than the window size. Retina screens on OS X and Gnome on Linux are some examples. On a Retina systems the returned ratio would usually be 2.0 as a window of size 500 x 500 would have a frambuffer of 1000 x 1000. Fractional values between 1.0 and 2.0, as well as values above 2.0 may also be encountered. :rtype: float :return: The framebuffer/window size ratio r)rrrs rget_pixel_ratiozBaseWindow.get_pixel_ratioNs"((**1- ::rc td)zReturn the current size of the window. The window size does not include the border or title bar. :rtype: (int, int) :return: The width and height of the window, in pixels. rArBrs rrzBaseWindow.get_size_rrc*|S)a?Return the size in actual pixels of the Window framebuffer. When using HiDPI screens, the size of the Window's framebuffer can be higher than that of the Window size requested. If you are performing operations that require knowing the actual number of pixels in the window, this method should be used instead of :py:func:`Window.get_size()`. For example, setting the Window projection or setting the glViewport size. :rtype: (int, int) :return: The width and height of the Window viewport, in pixels. r1rs rrzBaseWindow.get_framebuffer_sizeis}}rc td)aeSet the position of the window. :Parameters: `x` : int Distance of the left edge of the window from the left edge of the virtual desktop, in pixels. `y` : int Distance of the top edge of the window from the top edge of the virtual desktop, in pixels. rArBrs rrzBaseWindow.set_location{s"*---rc td)zReturn the current position of the window. :rtype: (int, int) :return: The distances of the left and top edges from their respective edges on the virtual desktop, in pixels. rArBrs rrzBaseWindow.get_location"*---rc td)abAttempt to restore keyboard focus to the window. Depending on the window manager or operating system, this may not be successful. For example, on Windows XP an application is not allowed to "steal" focus from another application. Instead, the window's taskbar icon will flash, indicating it requires attention. rArBrs rrzBaseWindow.activaterrc td)zShow or hide the window. :Parameters: `visible` : bool If True, the window will be shown; otherwise it will be hidden. rArBrrs rrzBaseWindow.set_visiblerrc td)zMinimize the window. rArBrs rminimizezBaseWindow.minimizes"*---rc td)zMaximize the window. The behaviour of this method is somewhat dependent on the user's display setup. On a multi-monitor system, the window may maximize to either a single screen or the entire virtual desktop. rArBrs rmaximizezBaseWindow.maximizerKrc td)agEnable or disable vertical sync control. When enabled, this option ensures flips from the back to the front buffer are performed only during the vertical retrace period of the primary display. This can prevent "tearing" or flickering when the buffer is updated in the middle of a video scan. Note that LCD monitors have an analogous time in which they are not reading from the video buffer; while it does not correspond to a vertical retrace it has the same effect. Also note that with multi-monitor systems the secondary monitor cannot be synchronised to, so tearing and flicker cannot be avoided when the window is positioned outside of the primary display. :Parameters: `vsync` : bool If True, vsync is enabled, otherwise it is disabled. rArB)rrs r set_vsynczBaseWindow.set_vsyncs*"*---rc<||_|dS)aTShow or hide the mouse cursor. The mouse cursor will only be hidden while it is positioned within this window. Mouse events will still be processed as usual. :Parameters: `visible` : bool If True, the mouse cursor will be visible, otherwise it will be hidden. N)rset_mouse_platform_visiblerNs rset_mouse_visiblezBaseWindow.set_mouse_visibles$& '')))))rct)aSet the platform-drawn mouse cursor visibility. This is called automatically after changing the mouse cursor or exclusive mode. Applications should not normally need to call this method, see `set_mouse_visible` instead. :Parameters: `platform_visible` : bool or None If None, sets platform visibility to the required visibility for the current exclusive mode and cursor type. Otherwise, a bool value will override and force a visibility. rB)rplatform_visibles rrVz%BaseWindow.set_mouse_platform_visibles"###rc\|t}||_|dS)aChange the appearance of the mouse cursor. The appearance of the mouse cursor is only changed while it is within this window. :Parameters: `cursor` : `MouseCursor` The cursor to set, or None to restore the default cursor. N)r&rrV)rcursors rset_mouse_cursorzBaseWindow.set_mouse_cursors4 >'))F# '')))))rc td)aJHide the mouse cursor and direct all mouse events to this window. When enabled, this feature prevents the mouse leaving the window. It is useful for certain styles of games that require complete control of the mouse. The position of the mouse as reported in subsequent events is meaningless when exclusive mouse is enabled; you should only use the relative motion parameters ``dx`` and ``dy``. :Parameters: `exclusive` : bool If True, exclusive mouse is enabled, otherwise it is disabled. rArBr exclusives rset_exclusive_mousezBaseWindow.set_exclusive_mouserDrc td)aPrevent the user from switching away from this window using keyboard accelerators. When enabled, this feature disables certain operating-system specific key combinations such as Alt+Tab (Command+Tab on OS X). This can be useful in certain kiosk applications, it should be avoided in general applications or games. :Parameters: `exclusive` : bool If True, exclusive keyboard is enabled, otherwise it is disabled. rArBr^s rset_exclusive_keyboardz!BaseWindow.set_exclusive_keyboard rDrct)aObtain a system mouse cursor. Use `set_mouse_cursor` to make the cursor returned by this method active. The names accepted by this method are the ``CURSOR_*`` constants defined on this class. :Parameters: `name` : str Name describing the mouse cursor to return. For example, ``CURSOR_WAIT``, ``CURSOR_HELP``, etc. :rtype: `MouseCursor` :return: A mouse cursor which can be used with `set_mouse_cursor`. rB)rr~s rget_system_mouse_cursorz"BaseWindow.get_system_mouse_cursors"###rcdS)aSet the window icon. If multiple images are provided, one with an appropriate size will be selected (if the correct size is not provided, the image will be scaled). Useful sizes to provide are 16x16, 32x32, 64x64 (Mac only) and 128x128 (Mac only). :Parameters: `images` : sequence of `pyglet.image.AbstractImage` List of images to use for the window icon. Nr)rimagess rset_iconzBaseWindow.set_icon.r"rc\tjtjtjzdS)zClear the window. This is a convenience method for clearing the color and depth buffer. The window must be the active context (see `switch_to`). N)rglClearGL_COLOR_BUFFER_BITGL_DEPTH_BUFFER_BITrs rclearzBaseWindow.clear?s% 2)B,BBCCCCCrc|jr|jr!tj|g|Rdkr d|_dSdS|j|dS)NFT)_enable_event_queue_allow_dispatch_eventrr_legacy_invalidrrm)rargss rrzBaseWindow.dispatch_eventGsk' +4+E +-d:T:::eCC'+$$$DC   $ $T * * * * *rc td)aXPoll the operating system event queue for new events and call attached event handlers. This method is provided for legacy applications targeting pyglet 1.0, and advanced applications that must integrate their event loop into another framework. Typical applications should use `pyglet.app.run`. rArBrs rdispatch_eventszBaseWindow.dispatch_eventsNrrcdS)a/A key on the keyboard was pressed (and held down). In pyglet 1.0 the default handler sets `has_exit` to ``True`` if the ``ESC`` key is pressed. In pyglet 1.1 the default handler dispatches the :py:meth:`~pyglet.window.Window.on_close` event if the ``ESC`` key is pressed. :Parameters: `symbol` : int The key symbol pressed. `modifiers` : int Bitwise combination of the key modifiers active. :event: Nrrs rrzBaseWindow.on_key_press]rcdS)aA key on the keyboard was released. :Parameters: `symbol` : int The key symbol pressed. `modifiers` : int Bitwise combination of the key modifiers active. :event: Nrrs ron_key_releasezBaseWindow.on_key_releaseorurcdS)aThe user input some text. Typically this is called after :py:meth:`~pyglet.window.Window.on_key_press` and before :py:meth:`~pyglet.window.Window.on_key_release`, but may also be called multiple times if the key is held down (key repeating); or called without key presses if another input method was used (e.g., a pen input). You should always use this method for interpreting text, as the key symbols often have complex mappings to their unicode representation which this event takes care of. :Parameters: `text` : unicode The text entered by the user. :event: Nr)rrs ron_textzBaseWindow.on_text{rurcdS)aThe user moved the text input cursor. Typically this is called after :py:meth:`~pyglet.window.Window.on_key_press` and before :py:meth:`~pyglet.window.Window.on_key_release`, but may also be called multiple times if the key is help down (key repeating). You should always use this method for moving the text input cursor (caret), as different platforms have different default keyboard mappings, and key repeats are handled correctly. The values that `motion` can take are defined in :py:mod:`pyglet.window.key`: * MOTION_UP * MOTION_RIGHT * MOTION_DOWN * MOTION_LEFT * MOTION_NEXT_WORD * MOTION_PREVIOUS_WORD * MOTION_BEGINNING_OF_LINE * MOTION_END_OF_LINE * MOTION_NEXT_PAGE * MOTION_PREVIOUS_PAGE * MOTION_BEGINNING_OF_FILE * MOTION_END_OF_FILE * MOTION_BACKSPACE * MOTION_DELETE :Parameters: `motion` : int The direction of motion; see remarks. :event: Nrrmotions ron_text_motionzBaseWindow.on_text_motionrurcdS)aThe user moved the text input cursor while extending the selection. Typically this is called after :py:meth:`~pyglet.window.Window.on_key_press` and before :py:meth:`~pyglet.window.Window.on_key_release`, but may also be called multiple times if the key is help down (key repeating). You should always use this method for responding to text selection events rather than the raw :py:meth:`~pyglet.window.Window.on_key_press`, as different platforms have different default keyboard mappings, and key repeats are handled correctly. The values that `motion` can take are defined in :py:mod:`pyglet.window.key`: * MOTION_UP * MOTION_RIGHT * MOTION_DOWN * MOTION_LEFT * MOTION_NEXT_WORD * MOTION_PREVIOUS_WORD * MOTION_BEGINNING_OF_LINE * MOTION_END_OF_LINE * MOTION_NEXT_PAGE * MOTION_PREVIOUS_PAGE * MOTION_BEGINNING_OF_FILE * MOTION_END_OF_FILE :Parameters: `motion` : int The direction of selection motion; see remarks. :event: Nrr{s ron_text_motion_selectz BaseWindow.on_text_motion_selectrurcdS)aThe mouse was moved with no buttons held down. :Parameters: `x` : int Distance in pixels from the left edge of the window. `y` : int Distance in pixels from the bottom edge of the window. `dx` : int Relative X position from the previous mouse position. `dy` : int Relative Y position from the previous mouse position. :event: Nr)rrr dxdys ron_mouse_motionzBaseWindow.on_mouse_motionrurcdS)aThe mouse was moved with one or more mouse buttons pressed. This event will continue to be fired even if the mouse leaves the window, so long as the drag buttons are continuously held down. :Parameters: `x` : int Distance in pixels from the left edge of the window. `y` : int Distance in pixels from the bottom edge of the window. `dx` : int Relative X position from the previous mouse position. `dy` : int Relative Y position from the previous mouse position. `buttons` : int Bitwise combination of the mouse buttons currently pressed. `modifiers` : int Bitwise combination of any keyboard modifiers currently active. :event: Nr)rrr rrbuttonsrs r on_mouse_dragzBaseWindow.on_mouse_dragrurcdS)aA mouse button was pressed (and held down). :Parameters: `x` : int Distance in pixels from the left edge of the window. `y` : int Distance in pixels from the bottom edge of the window. `button` : int The mouse button that was pressed. `modifiers` : int Bitwise combination of any keyboard modifiers currently active. :event: Nrrrr buttonrs ron_mouse_presszBaseWindow.on_mouse_pressrurcdS)aA mouse button was released. :Parameters: `x` : int Distance in pixels from the left edge of the window. `y` : int Distance in pixels from the bottom edge of the window. `button` : int The mouse button that was released. `modifiers` : int Bitwise combination of any keyboard modifiers currently active. :event: Nrrs ron_mouse_releasezBaseWindow.on_mouse_releaserurcdS)aThe mouse wheel was scrolled. Note that most mice have only a vertical scroll wheel, so `scroll_x` is usually 0. An exception to this is the Apple Mighty Mouse, which has a mouse ball in place of the wheel which allows both `scroll_x` and `scroll_y` movement. :Parameters: `x` : int Distance in pixels from the left edge of the window. `y` : int Distance in pixels from the bottom edge of the window. `scroll_x` : float Amount of movement on the horizontal axis. `scroll_y` : float Amount of movement on the vertical axis. :event: Nr)rrr scroll_xscroll_ys ron_mouse_scrollzBaseWindow.on_mouse_scrollrurcdS)aThe user attempted to close the window. This event can be triggered by clicking on the "X" control box in the window title bar, or by some other platform-dependent manner. The default handler sets `has_exit` to ``True``. In pyglet 1.1, if `pyglet.app.event_loop` is being used, `close` is also called, closing the window immediately. :event: Nrrs rr zBaseWindow.on_close4rurcdS)aThe mouse was moved into the window. This event will not be triggered if the mouse is currently being dragged. :Parameters: `x` : int Distance in pixels from the left edge of the window. `y` : int Distance in pixels from the bottom edge of the window. :event: Nrrs ron_mouse_enterzBaseWindow.on_mouse_enterArurcdS)aThe mouse was moved outside of the window. This event will not be triggered if the mouse is currently being dragged. Note that the coordinates of the mouse pointer will be outside of the window rectangle. :Parameters: `x` : int Distance in pixels from the left edge of the window. `y` : int Distance in pixels from the bottom edge of the window. :event: Nrrs ron_mouse_leavezBaseWindow.on_mouse_leavePrurcdS)a/A portion of the window needs to be redrawn. This event is triggered when the window first appears, and any time the contents of the window is invalidated due to another window obscuring it. There is no way to determine which portion of the window needs redrawing. Note that the use of this method is becoming increasingly uncommon, as newer window managers composite windows automatically and keep a backing store of the window contents. :event: Nrrs r on_exposezBaseWindow.on_expose`rurcdS)aThe window was resized. The window will have the GL context when this event is dispatched; there is no need to call `switch_to` in this handler. :Parameters: `width` : int The new width of the window, in pixels. `height` : int The new height of the window, in pixels. :event: Nrrs rrzBaseWindow.on_resizeorurcdS)aThe window was moved. :Parameters: `x` : int Distance from the left edge of the screen to the left edge of the window. `y` : int Distance from the top edge of the screen to the top edge of the window. Note that this is one of few methods in pyglet which use a Y-down coordinate system. :event: Nrrs ron_movezBaseWindow.on_move~rurcdS)aThe window was activated. This event can be triggered by clicking on the title bar, bringing it to the foreground; or by some platform-specific method. When a window is "active" it has the keyboard focus. :event: Nrrs r on_activatezBaseWindow.on_activaterurcdS)zThe window was deactivated. This event can be triggered by clicking on another application window. When a window is deactivated it no longer has the keyboard focus. :event: Nrrs r on_deactivatezBaseWindow.on_deactivaterurcdS)zThe window was shown. This event is triggered when a window is restored after being minimised, or after being displayed for the first time. :event: Nrrs ron_showzBaseWindow.on_showrurcdS)zThe window was hidden. This event is triggered when a window is minimised or (on Mac OS X) hidden by the user. :event: Nrrs ron_hidezBaseWindow.on_hiderurcdS)aThe window's GL context was lost. When the context is lost no more GL methods can be called until it is recreated. This is a rare event, triggered perhaps by the user switching to an incompatible video mode. When it occurs, an application will need to reload all objects (display lists, texture objects, shaders) as well as restore the GL state. :event: Nrrs ron_context_lostzBaseWindow.on_context_lostrurcdS)a#The state of the window's GL context was lost. pyglet may sometimes need to recreate the window's GL context if the window is moved to another video device, or between fullscreen or windowed mode. In this case it will try to share the objects (display lists, texture objects, shaders) between the old and new contexts. If this is possible, only the current state of the GL context is lost, and the application should simply restore state. :event: Nrrs ron_context_state_lostz BaseWindow.on_context_state_lostrurcdS)zFile(s) were dropped into the window, will return the position of the cursor and a list of paths to the files that were dropped. .. versionadded:: 1.5.1 :event: Nr)rrr pathss r on_file_dropzBaseWindow.on_file_droprurcdS)aThe window contents must be redrawn. The `EventLoop` will dispatch this event when the window should be redrawn. This will happen during idle time after any window events and after any scheduled functions were called. The window will already have the GL context, so there is no need to call `switch_to`. The window's `flip` method will be called after this event, so your event handler should not. You should make no assumptions about the window contents when this event is triggered; a resize or expose event may have invalidated the framebuffer since the last time it was drawn. .. versionadded:: 1.1 :event: Nrrs ron_drawzBaseWindow.on_drawrur)TNNNN)Tr)r r r rrIrxWINDOW_STYLE_DEFAULTWINDOW_STYLE_DIALOGWINDOW_STYLE_TOOLWINDOW_STYLE_BORDERLESSWINDOW_STYLE_TRANSPARENTWINDOW_STYLE_OVERLAYCURSOR_DEFAULTCURSOR_CROSSHAIR CURSOR_HAND CURSOR_HELP CURSOR_NO CURSOR_SIZECURSOR_SIZE_UPCURSOR_SIZE_UP_RIGHTCURSOR_SIZE_RIGHTCURSOR_SIZE_DOWN_RIGHTCURSOR_SIZE_DOWNCURSOR_SIZE_DOWN_LEFTCURSOR_SIZE_LEFTCURSOR_SIZE_UP_LEFTCURSOR_SIZE_UP_DOWNCURSOR_SIZE_LEFT_RIGHT CURSOR_TEXT CURSOR_WAITCURSOR_WAIT_ARROWrinvalidrprrrrrrr)rrrrrrLrrrr&rrrr_mouse_exclusiverrrnrorrr0rrrrrrrrrr rrr propertyrr$rrrrrrrrrsetterrr:r>r@rBr4rFrrget_viewport_sizerrrrrPrRrTrWrVr\r`rbrdrgrlrrs_is_pyglet_doc_runrwryr}rrrrrrrrrrrrrrrrrrrrrrrjso0 CEE "*,$N"KKIKN+%/#-#)(.KK$HG OFGHJ !FKH FKGGH,..KN'&((MHHNL!NO +!!aaaaF^^^... . . . . . ....AE*.G8G8G8G8R. J J J,,,(   FXXX  X XXXXXX""X" \..\.""X" ]..].   X  &&& . . ....*...,...";;;"...    - . . ....... . . . .... ....... * * * *$$$$ **** ...."...."$$$"   "DDD+++ . . .L   $      &" " " H! ! ! F       0   "   "   *                                            u LLrrrrwryr}rrrrrrrrr rrrrrrrrrrrc4eZdZdZdZdZdZdZdZdZ dS) FPSDisplayaDisplay of a window's framerate. This is a convenience class to aid in profiling and debugging. Typical usage is to create an `FPSDisplay` for each window, and draw the display at the end of the windows' :py:meth:`~pyglet.window.Window.on_draw` event handler:: window = pyglet.window.Window() fps_display = FPSDisplay(window) @window.event def on_draw(): # ... perform ordinary window drawing operations ... fps_display.draw() The style and position of the display can be modified via the :py:func:`~pyglet.text.Label` attribute. Different text can be substituted by overriding the `set_fps` method. The display can be set to update more or less often by setting the `update_period` attribute. Note: setting the `update_period` to a value smaller than your Window refresh rate will cause inaccurate readings. :Ivariables: `label` : Label The text label displaying the framerate. g?cddlm}ddlm}|dddddd |_||_|j|_|j|_d |_||_d|_ dS) Nrtime)Label rT)rrr)rr font_sizeboldcolorg) r pyglet.textrlabelwindowr _window_flip _hook_flip last_timecount)rrrrs rr0zFPSDisplay.__init__&s%%%%%%U2r%'d!5777  "Ko   rc$ddlm}|}|xjdz c_|xj||jz z c_||_|j|jkr@||j|jz |xj|jzc_d|_dSdS)zRecords a new data point at the current time. This method is called automatically when the window buffer is flipped. rrr2N)rrr update_periodset_fps)rrts rryzFPSDisplay.update5s  DFF a  Q''  9* * * LLdi/ 0 0 0 II+ +IIDJJJ + *rc$d|z|j_dS)zSet the label text for the given FPS estimation. Called by `update` every `update_period` seconds. :Parameters: `fps` : float Estimated framerate of the window. z%.2fN)rr)rfpss rrzFPSDisplay.set_fpsDs!3, rc*tjtjtjtjtjtjtjtjtjd|jjd|jj dd|j tj tjtjtj dS)zDraw the label. The OpenGL state is assumed to be at default values, except that the MODELVIEW and PROJECTION matrices are ignored. At the return of this method the matrix mode will be MODELVIEW. rrNr2N) rrQrUrrSrRrTrrrrr!rrs rr!zFPSDisplay.drawPs (((   ()))   1dk'DK,>AFFF   ((( rcV||dSr)ryrrs rrzFPSDisplay._hook_flipgs'  rN) r r r rrr0ryrr!rrrrrrsp<M       ' ' '.rrWindowheadless)HeadlessWindowdarwin) CocoaWindow)win32cygwin) Win32Window) XlibWindow)4rrrarrpyglet.window.keypyglet.window.mousepyglet.window.eventr pyglet.eventr pyglet.windowr pyglet.utilrrlrr Exceptionr rrrrrr&r(r?rLrWrqrttypervrregister_event_typerrr rpyglet.window.headlessrcompat_platformpyglet.window.cocoarpyglet.window.win32rpyglet.window.xlibrmodulesr_create_shadow_windowrrrrsHXXt  ((((((&&&&&&WS"566P3;P     i        _        O                ?           4 +++++{+++\........,))))):)))))))):)))@6   A A A A At A A A ~~~~~ 0/BB~~~B, ~... /000 y))) /000 6777 0111 /// /000 1222 0111 /000 /000 z*** {+++ {+++ y))) }--- /// y))) y))) 0111 6777 ~... y)))ddddddddN< FFO ~j!<CCCCCCC  8 + +=======  #6 6 6=======;;;;;;K)FMBr