^ jVdZddlmZddlZddlmZddlmZddlm Z m Z m Z m Z ddl Z ddlZ ddlZ ddl mZddlmZmZdd lmZdd lmZdd lmZmZe rddlZdd lmZmZm Z dd l!m"Z"m#Z#m$Z$ddl%m&Z&e'edoej(Z)Gdde*Z+Gdde+Z,Gdde+Z-Gdde+Z.Gdde+Z/GddZ0Gdde0Z1Gdde0Z2dTd$Z3dUd&Z4Gd'd(e5Z6Gd)d*ee6+Ze7d,e7d-e7d.e7d/e7d0e7d1e7d2e7d3e7d4e7d5e7d6e7d7e7d8e7d9e7d:e7d;e7d<e7d=e7d>e7d?e7d@e7dAe7dBe7dCe7dDe7dEe7dFe7dGGdHdIZ8e)rRddl9Z9eZdJe_:dJe_;e9j<ee9j=KD]%\Z>Z?e?j;@d*dJe?_;&nT\9A Ndl;Z\]^^^ R[!!!!!r#N)rrF) rBrCrDr3rEr3rFr/r5r6r<)rrr r!rLr:r"r#r$rArAsUXY&+(((((2""""""r#rAdatarr5r cdfd }|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). fr r5cxd|_t|dsg|_|j|S)NT_platform_event_data)_platform_eventhasattrrYappend)rWrUs r$_event_wrapperz-_PlatformEventHandler.._event_wrappersB q011 (%'A " %%d+++r#rWr r5r r")rUr]s` r$_PlatformEventHandlerr_s)" r#rWcd|_|S)NT)_view)rWs r$_ViewEventHandlerrbsAG Hr#c$eZdZdZd fd ZxZS)_WindowMetaclasszESets the _platform_event_names class variable on the window subclass.clstype[_WindowMetaclass]namestrbasestupledctdictr5r6cdt|_|D]1}t|dr|j|j2|D]/\}}t|dr|j|0t |||dS)N_platform_event_namesrZ)setrnr[updateitemsaddsuperrL)rergrirkbasefunc __class__s r$rLz_WindowMetaclass.__init__s$'EE! M MDt455 M)001KLLL))++ 4 4JD$t.// 4)--d333 uc*****r#) rerfrgrhrirjrkrlr5r6)rrr r!rL __classcell__rvs@r$rdrdsCOO++++++++++r#rdc eZdZUdZeZded<dZded<dZded <d Z ded <d Z ded <dZ ded<dZ ded<dZ dZded<dZded<dZded<dZded<dZded<dZded<dZded<d Zded!<d"Zded#<d$Zded%<d&Zded'<d(Zded)<d*Zded+<d,Zded-<d.Zded/<d0Zded1<d2Zded3<d4Zded5<d6Z d7ed8<d9Z!d7ed:<d;Z"ded?<dZ$d>ed@<dZ%dAedB<d6Z&d7edC<eZ'dAedD<d6Z(d7edE<d6Z)d7edF<d6Z*d7edG<d6Z+d7edH<dZ,dIedJ<dZ-dKedL<dZ.dMedN<e/j01Z2dOedP<e/j01Z3dOedQ<dRZ4dSedT<dZ5dUedV<dZ6dUedW<dZ7dUedX<dZ8dUedY<d6Z9d7edZ<d6Z:d7ed[<e;ZddZd?dZd?dZd?dZd@dZddZhdd Zid9d ZdAd ZdBd ZdBdZxZSxZS(C BaseWindowa{Platform-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 its :py:meth:`.switch_to` method to make it the active OpenGL context. If you use only one window in your application, you can skip this step as it will always be the active context. zset[_PlatformEventHandler]rnNr6WINDOW_STYLE_DEFAULTdialogrhWINDOW_STYLE_DIALOGtoolWINDOW_STYLE_TOOL borderlessWINDOW_STYLE_BORDERLESS transparentWINDOW_STYLE_TRANSPARENToverlayWINDOW_STYLE_OVERLAY crosshairCURSOR_CROSSHAIRhand CURSOR_HANDhelp CURSOR_HELPno CURSOR_NOsize CURSOR_SIZEsize_upCURSOR_SIZE_UP size_up_rightCURSOR_SIZE_UP_RIGHT size_rightCURSOR_SIZE_RIGHTsize_down_rightCURSOR_SIZE_DOWN_RIGHT size_downCURSOR_SIZE_DOWNsize_down_leftCURSOR_SIZE_DOWN_LEFT size_leftCURSOR_SIZE_LEFT size_up_leftCURSOR_SIZE_UP_LEFT size_up_downCURSOR_SIZE_UP_DOWNsize_left_rightCURSOR_SIZE_LEFT_RIGHTtext CURSOR_TEXTwait CURSOR_WAIT wait_arrowCURSOR_WAIT_ARROWFr/has_exitTinvalid`r3_dpi int | None_width_height str | None_caption _resizable_style _fullscreen_visible_vsync _file_drops Screen | None_screenzDisplayConfig | None_configContext | None_contextr_projection_matrix _view_matrix)rrrrtuple[int, int, int, int] _viewportztuple[int, int] | None_windowed_size_windowed_location _minimum_size _maximum_size_keyboard_exclusive_shadowzMouseCursor | ImageMouseCursor _mouse_cursorr_mouse_x_mouse_y_mouse_visible_mouse_exclusive_mouse_in_window_enable_event_queue_allow_dispatch_eventi_default_widthi_default_height_requested_width_requested_heighta #version 150 core in vec4 position; uniform WindowBlock { mat4 projection; mat4 view; } window; void main() { gl_Position = window.projection * window.view * position; } z#version 150 core out vec4 color; void main() { color = vec4(1.0, 0.0, 0.0, 1.0); } widthheightcaption resizablestyle fullscreenvisiblevsync file_dropsdisplayDisplay | Nonescreenconfig Config | NonecontextmodeScreenMode | Noner5c tj|t|_| stj} | s| } | sd}d}|dvrd}d}tj dddd||tj dd dd||dfD])} | |} n#t$rY&wxYw| sd }t|n|dvrd| _ d| _ | s| | } | s| tj} | |_|jj|_t)|jd r|jj|_n| |_|jj|_|rB|||j|jf|_||||\}}|js ||f|_n||j}||j}||_||_||_||_||_ ||_!||_"tj#d tj#d |_$n||_$| |_%|ptLj'd |_(d dlm)}|j*+||,|-|.|r+|/d|0dSdS)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 :py:meth:`~pyglet.display.Screen.get_matching_configs` or similar. The context will be active as soon as the window is created, as if :py:meth:`~pyglet.window.Window.switch_to` was just called. Args: width: Width of the window, in pixels. Defaults to 960, or the screen width if ``fullscreen`` is True. height: Height of the window, in pixels. Defaults to 540, or the screen height if ``fullscreen`` is True. caption: Initial caption (title) of the window. Defaults to ``sys.argv[0]``. resizable: If True, the window will be resizable. Defaults to False. style: One of the ``WINDOW_STYLE_*`` constants specifying the border style of the window. fullscreen: If True, the window will cover the entire screen rather than floating. Defaults to False. visible: 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: If True, buffer flips are synchronised to the primary screen's vertical retrace, eliminating flicker. file_drops: If True, the Window will accept files being dropped into it and call the ``on_file_drop`` event. display: The display device to use. Useful only under X11. screen: The screen to use, if in fullscreen. config: Either a template from which to create a complete config, or a complete config. context: The context to attach to this window. The context must not already be attached to another window. mode: The screen will be switched to this mode if `fullscreen` is True. If None, an appropriate mode is selected to accommodate ``width`` and ``height``. NF)rrT) double_buffer depth_size major_version minor_version alpha_sizetransparent_framebufferz No standard config is available.rrrapp)1r rLr _event_queuepygletr get_displayget_default_screenr rget_best_configr(rr is_completecreate_contextcurrent_contextrrrr[rr_displayrrr_set_fullscreen_moderrrrrrroptionsrrsysargvrrwindowsrr_create switch_to_create_projection set_visibleactivate)r9rrrrrrrrrrrrrrrtransparent_fbtemplate_configmsgrs r$rLzBaseWindow.__init__sZJ  &&&!GG 3n0022G 2//11F 6J"N222 !% 1\]%/YYY 1\]%/YYY $  #33ODDFE,D 18+C000 1222$%!15.!!## 4++F33F @++B,>??G  }+  4< * * "<.DLL!DL ,  .}&*&94;O&O# 55dE6JJME6& 4&+Vm#}+~-  %!'#% >' " . .1DKKDK%.38A;     !!!     T " " " MMOOOOO  s$B;; CCctjtj|jdtj|jd|_|jjd|_ddg| R|_ | \}}t|_ tjd|d|dd|_dS)Nvertexfragment WindowBlockr )r ShaderProgramShader_default_vertex_source_default_fragment_source_default_programuniform_blocks create_ubouboget_framebuffer_sizerget_sizervieworthogonal_projection projectionr9rrs r$rzBaseWindow._create_projectionYs & 4 M$5x @ @ M$7 D D!F!F(7 FQQSSA; 9 9 ; ;;;  vFF 4Qq&%QUVVr#c@ |dS#YdSxYwN)closer9s r$__del__zBaseWindow.__del__fs(  JJLLLLL  DDsc@|jjd|jd|jdS)Nz=(width=z , height=))rvrrrrs r$__repr__zBaseWindow.__repr__os*.)VV4:VV VVVVr#cdSrr"rs r$rzBaseWindow._creaters r#changes Sequence[str]cdS)aDRecreate the window with current attributes. Args: changes: Sequence 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. Nr")r9r%s r$ _recreatezBaseWindow._recreatevr;r#cdS)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. Nr"rs r$rzBaseWindow.activater;r#c\tjtjtjzdS)zClear the window. This is a convenience method for clearing the color and depth buffer. The window must be the active context (see :py:meth:`.switch_to`). N)r glClearGL_COLOR_BUFFER_BITGL_DEPTH_BUFFER_BITr"r#r$clearzBaseWindow.clears% 2)B,BBCCCCCr#cddlm}|jsdS|j||jd|_d|_|jr|jd|t|_ dS)a|Close the window. After closing the window, the GL context will be invalid. The window instance cannot be reused once closed. To reuse windows, see :py:meth:`.set_visible` instead. The :py:meth:`pyglet.app.EventLoop.on_window_close` event is dispatched by the :py:attr:`pyglet.app.event_loop` when this method is called. rrNon_window_close) rrrrremovedestroyr event_loopdispatch_eventrrr9rs r$rzBaseWindow.closes }  F 4      > C N ) )*;T B B B!GGr#argsrc|jr|jrtj|dS|j|dSr)rrrsr4rr\)r9r6rvs r$r4zBaseWindow.dispatch_eventsO' +4+E + "EGG "D ) ) ) )   $ $T * * * * *r#cdS)aYPoll 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 :py:func:`pyglet.app.run`. Nr"rs r$dispatch_eventszBaseWindow.dispatch_eventsr;r#dtfloatc||d|d||dS)aRedraw the Window contents. This method will first call the :py:meth:`~pyglet.window.Window.`switch_to` method to make the GL context current. It then dispatches the :py:meth:`~pyglet.window.Window.on_draw` and :py:meth:`~pyglet.window.Window.on_refresh` events. Finally, it calls the :py:meth:`~pyglet.window.Window.flip` method to swap the front and back OpenGL buffers. on_draw on_refreshN)rr4flipr9r:s r$r:zBaseWindow.drawsO  I&&& L"--- r#c|jjr5|jr0|jr+|j|j|jdSdSdSdS)aWDraw the custom mouse cursor. If the current mouse cursor has ``drawable`` set, this method is called before the buffers are flipped to render it. There is little need to override this method; instead, subclass :py:class:`MouseCursor` and provide your own :py:meth:`~MouseCursor.draw` method. N)rr0rrr:rrrs r$draw_mouse_cursorzBaseWindow.draw_mouse_cursorsp   ) Bd.A BdF[ B   # #DM4= A A A A A B B B B B Br#cdS)aSwap the OpenGL front and back buffers. Call this method on a double-buffered window to update the visible display with the back buffer. Windows are double-buffered by default unless you turn this feature off. The contents of the back buffer are undefined after this operation. The default :py:attr:`~pyglet.app.event_loop` automatically calls this method after the window's :py:meth:`~pyglet.window.Window.on_draw` event. Nr"rs r$r?zBaseWindow.flipr;r#tuple[int, int]c*|S)a5Return 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. Returns: The width and height of the Window's framebuffer, in pixels. rrs r$rzBaseWindow.get_framebuffer_sizes}}r#cdS)zReturn the current position of the window. Returns: The distances of the left and top edges from their respective edges on the virtual desktop, in pixels. Nr"rs r$ get_locationzBaseWindow.get_locationr;r#c|jS)a*Return 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 framebuffer of 1000 x 1000. Fractional values between 1.0 and 2.0, as well as values above 2.0 may also be encountered. :deprecated: Use `Window.scale`. scalers r$get_pixel_ratiozBaseWindow.get_pixel_ratios zr#c|j|jfS)zReturn the current size of the window. This does not include the windows' border or title bar. Returns: The width and height of the window, in pixels. )rrrs r$rzBaseWindow.get_sizes{DL((r#c|j|jfS)zReturn the size of the window without any scaling taken into effect. This does not include the windows' border or title bar. Returns: The width and height of the window, in pixels. )rrrs r$get_requested_sizezBaseWindow.get_requested_sizes$d&<<s "!r#cdS)zMinimize the window.Nr"rs r$minimizezBaseWindow.minimizeMr;r#cdS)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. Nr"rs r$maximizezBaseWindow.maximizeQr;r#cdd|_ddlm}|jjr|dSdS)zDefault on_close handler.TrrN)rrrr3 is_runningrr5s r$on_closezBaseWindow.on_closeZsC  > $  JJLLLLL  r#symbol modifiersr c|tjkrA|tjtjztjzzs|ddSdSdS)zDefault on_key_press handler.rbN)rESCAPE MOD_NUMLOCK MOD_CAPSLOCKMOD_SCROLLLOCKr4r9rcrds r$ on_key_presszBaseWindow.on_key_pressasf SZ  s7:7G8H7:7I8J6K*K     + + + + +   r#c ||}tjddt|ddt|dd|\}}t jdt|ddt|ddd|_|d||dS)Nrr r  on_resize) rr glViewportmaxrrrrr4)r9rrframebuffer_sizewhs r$_on_internal_resizezBaseWindow._on_internal_resizehs4466 aC 0 3Q77=Ma=PRS9T9TUUU}}14QAq 1c!QiiQVX\]] KA.....r#rKdpic |}tjddt|ddt|dd|\}}t jdt|ddt|ddd|_||j _ | d||dS)Nrrmr r on_scale) rr rorprrrr_get_mouse_scalerrKr4)r9rKrurqrrrss r$_on_internal_scalezBaseWindow._on_internal_scaleos4466 aC 0 3Q77=Ma=PRS9T9TUUU}}14QAq 1c!QiiQVX\]]%)%:%:%<%<" Js33333r#cdS)amA default resize event handler. This default handler updates the GL viewport to cover the entire window. The bottom-left corner is (0, 0) and the top-right corner is the width and height of the window's framebuffer. In addition, the projection matrix is set to an orthogonal projection based on the same dimensions. Nr"rs r$rnzBaseWindow.on_resizewr;r#cdS)zA default scale event handler. This default handler is called if the screen or system's DPI changes during runtime. Nr"r9rKrus r$rwzBaseWindow.on_scaler;r#cdS)zSet 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. Nr")r9rs r$ set_captionzBaseWindow.set_captionr;r#cd||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. Args: fullscreen: True if the window should be made fullscreen, False if it should be windowed. 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: The screen will be switched to the given mode. The mode must have been obtained by enumerating :py:meth:`~pyglet.display.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: 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)rrrrrrrHrrrr restore_moder( set_location)r9rrrrrs r$set_fullscreenzBaseWindow.set_fullscreensmP $* * *6T\#9#9%4;"6"66T\#9#9 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 8r#rc|7|j|| |jj}| |jj}n||q|d}|d}|j||}||j|nI|jrd|d|}t |n|jj}|jj}||fS)NrzNo mode matching r2)rset_moderrget_closest_mode get_modesr*)r9rrrrs r$rzBaseWindow._set_fullscreen_modes   K  & & &} )~+  &"4}~;//v>>D $$T****&&(( 5:%::&::/444 5 K%E['Ff}r#cR|dks|dkrd}t|||f|_dS)aaSet 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. Args: width: Minimum width of the window, in pixels. height: Minimum height of the window, in pixels. rmz+Width and height must be positive integers.N) ValueErrorrr9rrrs r$set_minimum_sizezBaseWindow.set_minimum_sizes8& 199 ?CS// !"F]r#cR|dks|dkrd}t|||f|_dS)asSet 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. Args: width: Maximum width of the window, in pixels. height: Maximum height of the window, in pixels. rmz*Width and height must be positive integersN)rrrs r$set_maximum_sizezBaseWindow.set_maximum_size s8( 199 >CS// !"F]r#c|jrd}t||dks|dkrd}t|||c|_|_||c|_|_dS)zResize 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. z%Cannot set size of fullscreen window.rmz*width and height must be positive integersN)rrrrrrrrs r$set_sizezBaseWindow.set_size$sl   '9C!#&& & 199 >CS// !$)6! T\8=v5t555r#r2r4cdS)a/Set the position of the window. Args: x: Distance of the left edge of the window from the left edge of the virtual desktop, in pixels. y: Distance of the top edge of the window from the top edge of the virtual desktop, in pixels. Nr"r8s r$rzBaseWindow.set_location6r;r#c||_dS)zShow or hide the window.Nrr9rs r$rzBaseWindow.set_visibleAs  r#c||_dS)aEnable 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. Nr)r9rs r$ set_vsynczBaseWindow.set_vsyncEs  r#c<||_|dS)zShow 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. N)rset_mouse_platform_visiblers r$set_mouse_visiblezBaseWindow.set_mouse_visibleWs$ & '')))))r#platform_visible bool | Nonect)a.Set 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: :py:meth:`~pyglet.window.Window.set_mouse_visible` instead. Args: platform_visible: 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. rQ)r9rs r$rz%BaseWindow.set_mouse_platform_visible`s "!r#cursorMouseCursor | Nonec|t}||_||j_|dS)a Change the appearance of the mouse cursor. The appearance of the mouse cursor is only changed while it is within this window. Args: cursor: The cursor to set, or ``None`` to restore the default cursor. N)r?rrxrKr)r9rs r$set_mouse_cursorzBaseWindow.set_mouse_cursorrsK >'))F#%)%:%:%<%<" '')))))r#c|jS)zSThe mouse scale factoring in the DPI. On Mac, this is always 1.0. rJrs r$rxzBaseWindow._get_mouse_scales zr# exclusivec||_dS)aHide 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``. N)rr9rs r$set_exclusive_mousezBaseWindow.set_exclusive_mouses!*r#c||_dS)adPrevent 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. N)rrs r$set_exclusive_keyboardz!BaseWindow.set_exclusive_keyboards$-   r#imagesrCcdS)a*Set 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). Nr")r9rs r$set_iconzBaseWindow.set_iconr;r#cdS)aMake this window the current OpenGL rendering context. Only one OpenGL context can be active at a time. This method sets the current window context as the active one. In most cases, you should use this method instead of directly calling :py:meth:`~pyglet.gl.Context.set_current`. The latter will not perform platform-specific state management tasks for you. Nr"rs r$rzBaseWindow.switch_tor;r#c|jS)z&The window caption (title). Read-only.)rrs r$rzBaseWindow.caption }r#c|jS)z+True if the window is resizable. Read-only.)rrs r$ resizeablezBaseWindow.resizeables r#c|jS)zEThe window style; one of the ``WINDOW_STYLE_*`` constants. Read-only.)rrs r$rzBaseWindow.style {r#c|jS)z6True if the window is currently fullscreen. Read-only.)rrs r$rzBaseWindow.fullscreens r#c|jS)z3True if the window is currently visible. Read-only.rrs r$rzBaseWindow.visiblerr#c|jS)zRTrue if buffer flips are synchronised to the screen's vertical retrace. Read-only.rrs r$rzBaseWindow.vsyncrr#rc|jS)z/The display this window belongs to. Read-only.)rrs r$rzBaseWindow.displayrr#rc|jS)z4The screen this window is fullscreen in. Read-only.)rrs r$rzBaseWindow.screen |r#rc|jS)z>A GL config describing the context of this window. Read-only.)rrs r$rzBaseWindow.configrr#rc|jS)z7The OpenGL context attached to this window. Read-only.)rrs r$rzBaseWindow.contextrr#c6|dS)z0The width of the window, in pixels. Read-write.rrFrs r$rzBaseWindow.width}}q!!r# new_widthc<|||jdSr)rr)r9rs r$rzBaseWindow.widths i-----r#c6|dS)z1The height of the window, in pixels. Read-write.rmrFrs r$rzBaseWindow.heightrr# new_heightc<||j|dSr)rr)r9rs r$rzBaseWindow.heights dj*-----r#cDtjjdkr |jdz SdS)zFThe scale of the window factoring in DPI. Read only. realrrH)rr dpi_scalingrrs r$rKzBaseWindow.scales% > % / /9r> !sr#c|jS)z6DPI values of the Window. Read only. )rrs r$ruzBaseWindow.dpis yr#c*|S)z#The size of the window. Read-Write.rFrs r$rzBaseWindow.sizes}}r#new_sizeSequence[int, int]c|j|dSr)r)r9rs r$rzBaseWindow.sizes x    r#c:|\}}||z S)z*The aspect ratio of the window. Read-Only.rF)r9rrrss r$ aspect_ratiozBaseWindow.aspect_ratios}}11u r#c|jS)aThe OpenGL window projection matrix. Read-write. This matrix is used to transform vertices when using any of the built-in drawable classes. `view` is done first, then `projection`. The default projection matrix is orthographic (2D), but a custom :py:class:`~pyglet.math.Mat4` instance can be set. Alternatively, you can supply a flat tuple of 16 values. (2D), but can be changed to any 4x4 matrix desired. :see: :py:class:`~pyglet.math.Mat4`. )rrs r$rzBaseWindow.projections &&r#matrixcj|j5}||jdd<dddn #1swxYwY||_dSr)rrrr9r window_blocks r$rzBaseWindow.projection0sX 0)/L #AAA & 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0#) !%%c|jS)aThe OpenGL window view matrix. Read-write. This matrix is used to transform vertices when using any of the built-in drawable classes. `view` is done first, then `projection`. The default view is an identity matrix, but a custom :py:class:`~pyglet.math.Mat4` instance can be set. Alternatively, you can supply a flat tuple of 16 values. )rrs r$rzBaseWindow.view8s   r#cj|j5}||jdd<dddn #1swxYwY||_dSr)rrrrs r$rzBaseWindow.viewEsX *#)L aaa  * * * * * * * * * * * * * * *#rc|jS)z_The Window viewport. The Window viewport, expressed as (x, y, width, height). )rrs r$viewportzBaseWindow.viewportMs ~r#valuesc ||_|j}|\}}}}tjt ||zt ||zt ||zt ||zdSr)rrKrr ror3)r9rprr2r4rrrss r$rzBaseWindow.viewportUsg Z 1a SR[[#a"f++s1r6{{CBKKPPPPPr#cdS)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: Nr"rs r$ on_activatezBaseWindow.on_activate_r;r#cdS)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: Nr"rs r$rbzBaseWindow.on_closejr;r#cdS)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: Nr"rs r$on_context_lostzBaseWindow.on_context_lostwr;r#cdS)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: Nr"rs r$on_context_state_lostz BaseWindow.on_context_state_lostr;r#cdS)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: Nr"rs r$ on_deactivatezBaseWindow.on_deactivater;r#cdS)arThe window contents should be redrawn. The `EventLoop` will dispatch this event when the `draw` method has been 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 immediately 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. :event: Nr"rs r$r=zBaseWindow.on_drawr;r#cdS)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: Nr"rs r$ on_exposezBaseWindow.on_exposer;r#paths list[str]cdS)aFile(s) were dropped into the window. Args: x: Distance in pixels from the left edge of the window where a drop occurred. y: Distance in pixels from the bottom edge of the window where a drop occurred. paths: File path strings that were dropped into the window. .. versionadded:: 1.5.1 :event: Nr")r9r2r4rs r$ on_file_dropzBaseWindow.on_file_dropr;r#cdS)zThe window was hidden. This event is triggered when a window is minimised or hidden by the user. :event: Nr"rs r$on_hidezBaseWindow.on_hider;r#cdS)aA key on the keyboard was pressed (and held down). Since pyglet 1.1 the default handler dispatches the :py:meth:`~pyglet.window.Window.on_close` event if the ``ESC`` key is pressed. Args: symbol: The key symbol pressed. modifiers: Bitwise combination of the key modifiers active. :event: Nr"rjs r$rkzBaseWindow.on_key_pressr;r#cdS)zA key on the keyboard was released. Args: symbol: The key symbol pressed. modifiers: Bitwise combination of the key modifiers active. :event: Nr"rjs r$on_key_releasezBaseWindow.on_key_releaser;r#dxdycdS)aThe mouse was moved with no buttons held down. Args: x: Distance in pixels from the left edge of the window. y: Distance in pixels from the bottom edge of the window. dx: Relative X position from the previous mouse position. dy: int Relative Y position from the previous mouse position. :event: Nr")r9r2r4rrs r$on_mouse_motionzBaseWindow.on_mouse_motionr;r#buttonscdS)aYThe 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. Args: x: Distance in pixels from the left edge of the window. y: Distance in pixels from the bottom edge of the window. dx: Relative X position from the previous mouse position. dy: Relative Y position from the previous mouse position. buttons: Bitwise combination of the mouse buttons currently pressed. modifiers: Bitwise combination of any keyboard modifiers currently active. :event: Nr")r9r2r4rrrrds r$ on_mouse_dragzBaseWindow.on_mouse_dragr;r#buttoncdS)aA mouse button was pressed (and held down). Args: x: Distance in pixels from the left edge of the window. y: Distance in pixels from the bottom edge of the window. button: The mouse button that was pressed. modifiers: Bitwise combination of any keyboard modifiers currently active. :event: Nr"r9r2r4rrds r$on_mouse_presszBaseWindow.on_mouse_pressr;r#cdS)aA mouse button was released. Args: x: Distance in pixels from the left edge of the window. y: Distance in pixels from the bottom edge of the window. button: The mouse button that was released. modifiers: Bitwise combination of any keyboard modifiers currently active. :event: Nr"rs r$on_mouse_releasezBaseWindow.on_mouse_release$r;r#scroll_xscroll_ycdS)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. Args: x: Distance in pixels from the left edge of the window. y: Distance in pixels from the bottom edge of the window. scroll_x: Amount of movement on the horizontal axis. scroll_y: Amount of movement on the vertical axis. :event: Nr")r9r2r4rrs r$on_mouse_scrollzBaseWindow.on_mouse_scroll4r;r#cdS)zThe mouse was moved into the window. This event will not be triggered if the mouse is currently being dragged. :event: Nr"r8s r$on_mouse_enterzBaseWindow.on_mouse_enterIr;r#cdS)zThe mouse was moved outside the window. This event will not be triggered if the mouse is currently being dragged. .. note: Coordinates of the mouse pointer will be outside the window rectangle. :event: Nr"r8s r$on_mouse_leavezBaseWindow.on_mouse_leaveRr;r#cdS)aThe window was moved. Args: x: Distance from the left edge of the screen to the left edge of the window. y: Distance from the top edge of the screen to the *top* edge of the window. .. note: This is one of few methods in pyglet which use a Y-down coordinate system. :event: Nr"r8s r$on_movezBaseWindow.on_move\r;r#cdS)aThe window contents should be redrawn. The ``EventLoop`` will dispatch this event when the ``draw`` method has been called. The window will already have the GL context, so there is no need to call :py:meth:`~pyglet.window.Window.switch_to`. The window's :py:meth:`~pyglet.window.Window.flip` method will be called immediately 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:: 2.0 :event: Nr"r@s r$r>zBaseWindow.on_refreshjr;r#cdS)zThe window was resized. The window will have the GL context when this event is dispatched; there is no need to call :py:meth:`~pyglet.window.Window.switch_to` in this handler. :event: Nr"rs r$rnzBaseWindow.on_resize|r;r#cdS)zA default scale event handler. This default handler is called if the screen or system's DPI changes during runtime. Nr"r|s r$rwzBaseWindow.on_scaler;r#cdS)zThe window was shown. This event is triggered when a window is restored after being minimised, hidden, or after being displayed for the first time. :event: Nr"rs r$on_showzBaseWindow.on_showr;r#cdS)afThe 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. :event: Nr"rWs r$on_textzBaseWindow.on_textr;r#motioncdS)apThe 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 * MOTION_COPY * MOTION_PASTE :event: Nr"r9r s r$on_text_motionzBaseWindow.on_text_motionr;r#cdS)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 * MOTION_COPY * MOTION_PASTE :event: Nr"r s r$on_text_motion_selectz BaseWindow.on_text_motion_selectr;r#)rrrrrrrr/rrrr/rr/rr/rr/rrrrrrrrrrr5r6r5r6)r5rh)r%r&r5r6)r6rr5r6)r:r;r5r6)r5rD)r5r;)rgrhr5r.)rrhr5r6)rYr/r5r6)rcr3rdr3r5r )rr3rr3r5r6)rKr;rur3r5r6)rr3rr3r5r )rKr;rur3r5r )rrhr5r6)TNNNN) rr/rrrrrrrrr5r6)rrrr3rr3r5rDr<)T)rr/r5r6)rr/r5r6r)rrr5r6)rrr5r6)rr/r5r6)rrCr5r6)r5r/)r5r)r5r)r5r)r5r)r5r3)rr3r5r6)rr3r5r6)rrr5r6)r5r)rrr5r6)r5r)rrr5r6)r5r )r2r3r4r3rrr5r ) r2r3r4r3rr3rr3r5r )r2r3r4r3rr3rr3rr3rdr3r5r ) r2r3r4r3rr3rdr3r5r ) r2r3r4r3rr;rr;r5r )r2r3r4r3r5r )r:r;r5r )rrhr5r )r r3r5r )rrr r!rornr=r{r}rrrrCURSOR_DEFAULTrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmathrrrrrrrrrrr?rrrrrrrrrrrrrrLrr r#rrr(r staticmethodr.rr4r9r:rBr?rrHrLrrOrSrUrXr[r]r_rbrkrtryrnrwr~rrrrrrrrrrrrxrrrrpropertyrrrrrrrrrrrsetterrrKrurrrrr_is_pyglet_doc_runrrrrr=rrrrrrrrrrrrr>rr r rrwrxs@r$rzrzs29<===="&%%%%'''''######/////$11111 )))))N'''''KKIK$N####!0////*))))#43333(''''"21111('''' .---------"33333KK)))))HGDNNNNFGHJ-F----KHFK!G!!!!$(G((((#H####%{//111111))++L+++++5I5555.2N1111155555,0M0000,0M0000 %%%%%G5G4F4H4HMHHHHHHN""""""""""L $$$$$"'''''NO  &*&*'+#(%9$)!%#$)+/)-)-+/+/bbbbbH W W W WWWWW   ^    ^    ^ DDD\D$$$$,++++++    ^     BBBB     ^         ^  ))))===="""""""""""" " " " "###^#   ^ ,,,,////4444           ^ osFJG8G8G8G8G8R0++++2++++4FFFF$   ^      $*****"""""$*****" * * * * *-----         ^  XXX   X XXXXXX """X" \...\."""X" ]...].XXX [!!![!X '''X' )))) ! ! !X ! [###[#X_QQQ_QF                                                      .              *                $                    D        Q FFFFr#rz) metaclassrkrr r rrrrrrrrrbrrtryrnrwrrrrrrrrr=r>cHeZdZUdZdZded< dddZddZddZddZ dS) FPSDisplayabDisplay 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:: from pyglet.window import Window, FPSDisplay 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 ``label`` attribute. 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. g?rlabelrrrwindowpyglet.window.Windowcolorrsamplesr3r5r6cddlm}ddlm}ddlm}ddlm}||_||_|j |j c|_ |_ |ddddd | |_ d |_ ||_|| |_d S)aKCreate an FPS Display. Args: window: The Window you wish to display frame rate for. color: The RGBA color of the text display. Each channel represented as 0-255. samples: How many delta samples are used to calculate the mean FPS. rr)mean)timer rbold)r2r4 font_sizeweightr g)maxlenN) collectionsr statisticsr#r$ pyglet.textr_time_meanr? _hook_flip _window_flipr_elapsed _last_time _delta_times)r9rr r!rr#r$rs r$rLzFPSDisplay.__init__$s &%%%%%######%%%%%%  *0do&6;U2rReTTT  $&&!E111r#c(|}||jz }|xj|z c_|j|||_|j|jkr2d|_d||jz d|j_dSdS)zRecords a new data point at the current time. This method is called automatically when the window buffer is flipped. rrmz.2fN) r.r3r2r4r\ update_periodr/rr)r9tdeltas r$rpzFPSDisplay.update@s JJLLDO#     ''' =D. . .DM!"TZZ0A%B%B!BHHDJOOO / .r#c8|jdS)zDraw the label.N)rr:rs r$r:zFPSDisplay.drawOs r#cV||dSr)rpr1rs r$r0zFPSDisplay._hook_flipSs'  r#N)rr)rrr rr!r3r5r6r) rrr r!r6r=rLrpr:r0r"r#r$rrs2MLLLXl #222228 I I I Ir#rWindow) predicateheadless)HeadlessWindowdarwin) CocoaWindow)win32cygwin) Win32Window) XlibWindow) rrrzr;r.r?rArrr*r&r(r,)rUrr5r r^)Or! __future__rrabcrr+rtypingrrr r rpyglet.window.keypyglet.window.mouser pyglet.eventr r pyglet.graphicsr pyglet.mathr pyglet.windowrrrzr;pyglet.display.baserrr pyglet.glrrrr-rr[rr Exceptionrr&r(r*r,r.r?rAr_rbtyperdregister_event_typerinspectrr getmembers isfunction_ method_objreplacerpyglet.window.headlessr>compat_platformpyglet.window.cocoar@pyglet.window.win32rCpyglet.window.xlibrDmodulesr_create_shadow_window__all__r"r#r$rasXXr#""""" 999999999999 <<<<<<<<""""""$$$$$$$$"??????????8888888888!!!!!!WS"566P3;P<<<<PQQQZZ :","9"A"A,PX"Y"Y Z ~j!<CCCCCCC  8 + +=======  #6 6 6=======;;;;;;K)FMB r#