pyglet 2.0.8__zip → 2.0.10__zip

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/text/layout.py

@@ -127,11 +127,175 @@ from pyglet import graphics
 from pyglet.gl import *
 from pyglet.event import EventDispatcher
 from pyglet.text import runlist
-from pyglet.graphics import shader
 from pyglet.font.base import grapheme_break
 
 _is_pyglet_doc_run = hasattr(sys, "is_pyglet_doc_run") and sys.is_pyglet_doc_run
 
+
+layout_vertex_source = """#version 330 core
+    in vec3 position;
+    in vec4 colors;
+    in vec3 tex_coords;
+    in vec3 translation;
+    in vec2 anchor;
+    in float rotation;
+
+    out vec4 text_colors;
+    out vec2 texture_coords;
+    out vec4 vert_position;
+
+    uniform WindowBlock
+    {
+        mat4 projection;
+        mat4 view;
+    } window;
+
+    mat4 m_rotation = mat4(1.0);
+    mat4 m_anchor = mat4(1.0);
+    mat4 m_neganchor = mat4(1.0);
+
+    void main()
+    {
+        m_anchor[3][0] = anchor.x;
+        m_anchor[3][1] = anchor.y;
+        m_neganchor[3][0] = -anchor.x;
+        m_neganchor[3][1] = -anchor.y;
+        m_rotation[0][0] =  cos(-radians(rotation));
+        m_rotation[0][1] =  sin(-radians(rotation));
+        m_rotation[1][0] = -sin(-radians(rotation));
+        m_rotation[1][1] =  cos(-radians(rotation));
+
+        gl_Position = window.projection * window.view * m_anchor * m_rotation * m_neganchor * vec4(position + translation, 1.0);
+
+        vert_position = vec4(position + translation, 1.0);
+        text_colors = colors;
+        texture_coords = tex_coords.xy;
+    }
+"""
+
+layout_fragment_source = """#version 330 core
+    in vec4 text_colors;
+    in vec2 texture_coords;
+    in vec4 vert_position;
+
+    out vec4 final_colors;
+
+    uniform sampler2D text;
+    uniform bool scissor;
+    uniform vec4 scissor_area;
+
+    void main()
+    {
+        final_colors = vec4(text_colors.rgb, texture(text, texture_coords).a * text_colors.a);
+        if (scissor == true) {
+            if (vert_position.x < scissor_area[0]) discard;                     // left
+            if (vert_position.y < scissor_area[1]) discard;                     // bottom
+            if (vert_position.x > scissor_area[0] + scissor_area[2]) discard;   // right
+            if (vert_position.y > scissor_area[1] + scissor_area[3]) discard;   // top
+        }
+    }
+"""
+
+layout_fragment_image_source = """#version 330 core
+    in vec4 text_colors;
+    in vec2 texture_coords;
+    in vec4 vert_position;
+
+    uniform sampler2D image_texture;
+
+    out vec4 final_colors;
+
+    uniform sampler2D text;
+    uniform bool scissor;
+    uniform vec4 scissor_area;
+
+    void main()
+    {
+        final_colors = texture(image_texture, texture_coords.xy);
+        if (scissor == true) {
+            if (vert_position.x < scissor_area[0]) discard;                     // left
+            if (vert_position.y < scissor_area[1]) discard;                     // bottom
+            if (vert_position.x > scissor_area[0] + scissor_area[2]) discard;   // right
+            if (vert_position.y > scissor_area[1] + scissor_area[3]) discard;   // top
+        }
+    }
+"""
+
+decoration_vertex_source = """#version 330 core
+    in vec3 position;
+    in vec4 colors;
+    in vec3 translation;
+    in vec2 anchor;
+    in float rotation;
+
+    out vec4 vert_colors;
+    out vec4 vert_position;
+
+    uniform WindowBlock
+    {
+        mat4 projection;
+        mat4 view;
+    } window;
+
+    mat4 m_rotation = mat4(1.0);
+    mat4 m_anchor = mat4(1.0);
+    mat4 m_neganchor = mat4(1.0);
+
+    void main()
+    {
+        m_anchor[3][0] = anchor.x;
+        m_anchor[3][1] = anchor.y;
+        m_neganchor[3][0] = -anchor.x;
+        m_neganchor[3][1] = -anchor.y;
+        m_rotation[0][0] =  cos(-radians(rotation));
+        m_rotation[0][1] =  sin(-radians(rotation));
+        m_rotation[1][0] = -sin(-radians(rotation));
+        m_rotation[1][1] =  cos(-radians(rotation));
+
+        gl_Position = window.projection * window.view * m_anchor * m_rotation * m_neganchor * vec4(position + translation, 1.0);
+
+        vert_position = vec4(position + translation, 1.0);
+        vert_colors = colors;
+    }
+"""
+
+decoration_fragment_source = """#version 330 core
+    in vec4 vert_colors;
+    in vec4 vert_position;
+
+    out vec4 final_colors;
+
+    uniform bool scissor;
+    uniform vec4 scissor_area;
+
+    void main()
+    {   
+        final_colors = vert_colors;
+        if (scissor == true) {
+            if (vert_position.x < scissor_area[0]) discard;                     // left
+            if (vert_position.y < scissor_area[1]) discard;                     // bottom
+            if (vert_position.x > scissor_area[0] + scissor_area[2]) discard;   // right
+            if (vert_position.y > scissor_area[1] + scissor_area[3]) discard;   // top
+        }
+    }
+"""
+
+
+def get_default_layout_shader():
+    return pyglet.gl.current_context.create_program((layout_vertex_source, 'vertex'),
+                                                    (layout_fragment_source, 'fragment'))
+
+
+def get_default_image_layout_shader():
+    return pyglet.gl.current_context.create_program((layout_vertex_source, 'vertex'),
+                                                    (layout_fragment_image_source, 'fragment'))
+
+
+def get_default_decoration_shader():
+    return pyglet.gl.current_context.create_program((decoration_vertex_source, 'vertex'),
+                                                    (decoration_fragment_source, 'fragment'))
+
+
 _distance_re = re.compile(r'([-0-9.]+)([a-zA-Z]+)')
 
 
@@ -376,18 +540,15 @@ class _GlyphBox(_AbstractBox):
             x1 = x2
 
         if background_vertices:
-            background_indices = []
-            bg_count = len(background_vertices) // 2
+            bg_count = len(background_vertices) // 3
+            background_indices = [(0, 1, 2, 0, 2, 3)[i % 6] for i in range(bg_count * 3)]
             decoration_program = get_default_decoration_shader()
-            for bg_idx in range(bg_count):
-                background_indices.extend([element + (bg_idx * 4) for element in [0, 1, 2, 0, 2, 3]])
-
-            background_list = decoration_program.vertex_list_indexed(bg_count * 4, GL_TRIANGLES, background_indices,
+            background_list = decoration_program.vertex_list_indexed(bg_count, GL_TRIANGLES, background_indices,
                                                                      layout.batch, layout.background_decoration_group,
                                                                      position=('f', background_vertices),
                                                                      colors=('Bn', background_colors),
-                                                                     rotation=('f', (rotation,) * 4),
-                                                                     anchor=('f', (anchor_x, anchor_y) * 4))
+                                                                     rotation=('f', (rotation,) * bg_count),
+                                                                     anchor=('f', (anchor_x, anchor_y) * bg_count))
             context.add_list(background_list)
 
         if underline_vertices:
@@ -503,186 +664,7 @@ class _InvalidRange:
         return self.end > self.start
 
 
-layout_vertex_source = """#version 330 core
-    in vec3 position;
-    in vec4 colors;
-    in vec3 tex_coords;
-    in vec3 translation;
-    in vec2 anchor;
-    in float rotation;
-
-    out vec4 text_colors;
-    out vec2 texture_coords;
-    out vec4 vert_position;
-
-    uniform WindowBlock
-    {
-        mat4 projection;
-        mat4 view;
-    } window;
-
-    mat4 m_rotation = mat4(1.0);
-    mat4 m_anchor = mat4(1.0);
-    mat4 m_neganchor = mat4(1.0);
-
-    void main()
-    {
-        m_anchor[3][0] = anchor.x;
-        m_anchor[3][1] = anchor.y;
-        m_neganchor[3][0] = -anchor.x;
-        m_neganchor[3][1] = -anchor.y;
-        m_rotation[0][0] =  cos(-radians(rotation));
-        m_rotation[0][1] =  sin(-radians(rotation));
-        m_rotation[1][0] = -sin(-radians(rotation));
-        m_rotation[1][1] =  cos(-radians(rotation));
-
-        gl_Position = window.projection * window.view * m_anchor * m_rotation * m_neganchor * vec4(position + translation, 1.0);
-
-        vert_position = vec4(position + translation, 1.0);
-        text_colors = colors;
-        texture_coords = tex_coords.xy;
-    }
-"""
-
-layout_fragment_source = """#version 330 core
-    in vec4 text_colors;
-    in vec2 texture_coords;
-    in vec4 vert_position;
-
-    out vec4 final_colors;
-
-    uniform sampler2D text;
-    uniform bool scissor;
-    uniform vec4 scissor_area;
-
-    void main()
-    {
-        final_colors = vec4(text_colors.rgb, texture(text, texture_coords).a * text_colors.a);
-        if (scissor == true) {
-            if (vert_position.x < scissor_area[0]) discard;                     // left
-            if (vert_position.y < scissor_area[1]) discard;                     // bottom
-            if (vert_position.x > scissor_area[0] + scissor_area[2]) discard;   // right
-            if (vert_position.y > scissor_area[1] + scissor_area[3]) discard;   // top
-        }
-    }
-"""
-
-layout_fragment_image_source = """#version 330 core
-    in vec4 text_colors;
-    in vec2 texture_coords;
-    in vec4 vert_position;
-    
-    uniform sampler2D image_texture;
-
-    out vec4 final_colors;
-
-    uniform sampler2D text;
-    uniform bool scissor;
-    uniform vec4 scissor_area;
-
-    void main()
-    {
-        final_colors = texture(image_texture, texture_coords.xy);
-        if (scissor == true) {
-            if (vert_position.x < scissor_area[0]) discard;                     // left
-            if (vert_position.y < scissor_area[1]) discard;                     // bottom
-            if (vert_position.x > scissor_area[0] + scissor_area[2]) discard;   // right
-            if (vert_position.y > scissor_area[1] + scissor_area[3]) discard;   // top
-        }
-    }
-"""
-
-decoration_vertex_source = """#version 330 core
-    in vec3 position;
-    in vec4 colors;
-    in vec3 translation;
-    in vec2 anchor;
-    in float rotation;
-
-    out vec4 vert_colors;
-    out vec4 vert_position;
-
-    uniform WindowBlock
-    {
-        mat4 projection;
-        mat4 view;
-    } window;
-
-    mat4 m_rotation = mat4(1.0);
-    mat4 m_anchor = mat4(1.0);
-    mat4 m_neganchor = mat4(1.0);
-
-    void main()
-    {
-        m_anchor[3][0] = anchor.x;
-        m_anchor[3][1] = anchor.y;
-        m_neganchor[3][0] = -anchor.x;
-        m_neganchor[3][1] = -anchor.y;
-        m_rotation[0][0] =  cos(-radians(rotation));
-        m_rotation[0][1] =  sin(-radians(rotation));
-        m_rotation[1][0] = -sin(-radians(rotation));
-        m_rotation[1][1] =  cos(-radians(rotation));
-
-        gl_Position = window.projection * window.view * m_anchor * m_rotation * m_neganchor * vec4(position + translation, 1.0);
-
-        vert_position = vec4(position + translation, 1.0);
-        vert_colors = colors;
-    }
-"""
-
-decoration_fragment_source = """#version 330 core
-    in vec4 vert_colors;
-    in vec4 vert_position;
-
-    out vec4 final_colors;
-
-    uniform bool scissor;
-    uniform vec4 scissor_area;
-
-    void main()
-    {   
-        final_colors = vert_colors;
-        if (scissor == true) {
-            if (vert_position.x < scissor_area[0]) discard;                     // left
-            if (vert_position.y < scissor_area[1]) discard;                     // bottom
-            if (vert_position.x > scissor_area[0] + scissor_area[2]) discard;   // right
-            if (vert_position.y > scissor_area[1] + scissor_area[3]) discard;   // top
-        }
-    }
-"""
-
-
-def get_default_layout_shader():
-    try:
-        return pyglet.gl.current_context.pyglet_text_layout_shader
-    except AttributeError:
-        pyglet.gl.current_context.pyglet_text_layout_shader = shader.ShaderProgram(
-            shader.Shader(layout_vertex_source, 'vertex'),
-            shader.Shader(layout_fragment_source, 'fragment'),
-        )
-        return pyglet.gl.current_context.pyglet_text_layout_shader
-
-
-def get_default_image_layout_shader():
-    try:
-        return pyglet.gl.current_context.pyglet_text_layout_image_shader
-    except AttributeError:
-        pyglet.gl.current_context.pyglet_text_layout_image_shader = shader.ShaderProgram(
-            shader.Shader(layout_vertex_source, 'vertex'),
-            shader.Shader(layout_fragment_image_source, 'fragment'),
-        )
-        return pyglet.gl.current_context.pyglet_text_layout_image_shader
-
-
-def get_default_decoration_shader():
-    try:
-        return pyglet.gl.current_context.pyglet_text_decoration_shader
-    except AttributeError:
-        pyglet.gl.current_context.pyglet_text_decoration_shader = shader.ShaderProgram(
-            shader.Shader(decoration_vertex_source, 'vertex'),
-            shader.Shader(decoration_fragment_source, 'fragment'),
-        )
-        return pyglet.gl.current_context.pyglet_text_decoration_shader
+# ####################
 
 
 class TextLayoutGroup(graphics.Group):

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/util.py

@@ -31,37 +31,6 @@ def asstr(s):
     return s.decode("utf-8")
 
 
-def with_metaclass(meta, *bases):
-    """
-    Function from jinja2/_compat.py. License: BSD.
-    Use it like this::
-        class BaseForm:
-            pass
-        class FormType(type):
-            pass
-        class Form(with_metaclass(FormType, BaseForm)):
-            pass
-    This requires a bit of explanation: the basic idea is to make a
-    dummy metaclass for one level of class instantiation that replaces
-    itself with the actual metaclass.  Because of internal type checks
-    we also need to make sure that we downgrade the custom metaclass
-    for one level to something closer to type (that's why __call__ and
-    __init__ comes back from type etc.).
-    This has the advantage over six.with_metaclass of not introducing
-    dummy classes into the final MRO.
-    """
-    class MetaClass(meta):
-        __call__ = type.__call__
-        __init__ = type.__init__
-
-        def __new__(cls, name, this_bases, d):
-            if this_bases is None:
-                return type.__new__(cls, name, (), d)
-            return meta(name, bases, d)
-
-    return MetaClass('temporary_class', None, {})
-
-
 def debug_print(enabled_or_option='debug'):
     """Get a debug printer that is enabled based on a boolean input or a pyglet option.
     The debug print function returned should be used in an assert. This way it can be
@@ -114,8 +83,9 @@ class CodecRegistry:
         will be return if no encoders for that extension are available.
         """
         if filename:
-            extension = os.path.splitext(filename)[1].lower()
-            return self._encoder_extensions.get(extension, [])
+            root, ext = os.path.splitext(filename)
+            extension = ext if ext else root        # If only ".ext" is provided
+            return self._encoder_extensions.get(extension.lower(), [])
         return self._encoders
 
     def get_decoders(self, filename=None):
@@ -124,8 +94,9 @@ class CodecRegistry:
         will be return if no encoders for that extension are available.
         """
         if filename:
-            extension = os.path.splitext(filename)[1].lower()
-            return self._decoder_extensions.get(extension, [])
+            root, ext = os.path.splitext(filename)
+            extension = ext if ext else root        # If only ".ext" is provided
+            return self._decoder_extensions.get(extension.lower(), [])
         return self._decoders
 
     def add_decoders(self, module):

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/window/__init__.py

@@ -99,7 +99,6 @@ from pyglet import gl
 from pyglet.math import Mat4
 from pyglet.event import EventDispatcher
 from pyglet.window import key, event
-from pyglet.util import with_metaclass
 from pyglet.graphics import shader
 
 
@@ -256,7 +255,7 @@ class _WindowMetaclass(type):
         super(_WindowMetaclass, cls).__init__(name, bases, dict)
 
 
-class BaseWindow(with_metaclass(_WindowMetaclass, EventDispatcher)):
+class BaseWindow(EventDispatcher, metaclass=_WindowMetaclass):
     """Platform-independent application window.
 
     A window is a "heavyweight" object occupying operating system resources.
@@ -274,9 +273,10 @@ class BaseWindow(with_metaclass(_WindowMetaclass, EventDispatcher)):
     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.
+    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.
     """
 
     # Filled in by metaclass with the names of all methods on this (sub)class
@@ -639,7 +639,8 @@ class BaseWindow(with_metaclass(_WindowMetaclass, EventDispatcher)):
         """Clear the window.
 
         This is a convenience method for clearing the color and depth
-        buffer.  The window must be the active context (see `switch_to`).
+        buffer.  The window must be the active context (see
+        :py:meth:`.switch_to`).
         """
         gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
 
@@ -647,10 +648,12 @@ class BaseWindow(with_metaclass(_WindowMetaclass, EventDispatcher)):
         """Close the window.
 
         After closing the window, the GL context will be invalid.  The
-        window instance cannot be reused once closed (see also `set_visible`).
+        window instance cannot be reused once closed. To re-use windows,
+        see :py:meth:`.set_visible` instead.
 
-        The `pyglet.app.EventLoop.on_window_close` event is dispatched on
-        `pyglet.app.event_loop` when this method is called.
+        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.
         """
         from pyglet import app
         if not self._context:
@@ -677,10 +680,25 @@ class BaseWindow(with_metaclass(_WindowMetaclass, EventDispatcher)):
         and advanced applications that must integrate their event loop
         into another framework.
 
-        Typical applications should use `pyglet.app.run`.
+        Typical applications should use :py:func:`pyglet.app.run`.
         """
         raise NotImplementedError('abstract')
 
+    def draw(self, dt: float):
+        """Redraw 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.
+        """
+        self.switch_to()
+        self.dispatch_event('on_draw')
+        self.dispatch_event('on_refresh', dt)
+        self.flip()
+
     def draw_mouse_cursor(self):
         """Draw the custom mouse cursor.
 
@@ -701,11 +719,14 @@ class BaseWindow(with_metaclass(_WindowMetaclass, EventDispatcher)):
         """Swap 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.
+        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.
 
-        Windows are double-buffered by default.  This method is called
-        automatically by `EventLoop` after the :py:meth:`~pyglet.window.Window.on_draw` event.
+        The default :py:attr:`~pyglet.app.event_loop` automatically
+        calls this method after the window's
+        :py:meth:`~pyglet.window.Window.on_draw` event.
         """
         raise NotImplementedError('abstract')
 
@@ -777,6 +798,25 @@ class BaseWindow(with_metaclass(_WindowMetaclass, EventDispatcher)):
         """
         raise NotImplementedError()
 
+    def get_clipboard_text(self) -> str:
+        """Access the system clipboard and attempt to retrieve text.
+
+        :rtype: `str`
+        :return: A string from the clipboard. String will be empty if no text found.
+        """
+        raise NotImplementedError()
+
+    def set_clipboard_text(self, text: str):
+        """Access the system clipboard and set a text string as the clipboard data.
+
+        This will clear the existing clipboard.
+
+        :Parameters:
+            `text` : str
+                Text you want to place in the clipboard.
+        """
+        raise NotImplementedError()
+
     def minimize(self):
         """Minimize the window.
         """
@@ -1144,10 +1184,13 @@ class BaseWindow(with_metaclass(_WindowMetaclass, EventDispatcher)):
     def switch_to(self):
         """Make 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.
+        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.
         """
         raise NotImplementedError('abstract')
 
@@ -1411,15 +1454,13 @@ class BaseWindow(with_metaclass(_WindowMetaclass, EventDispatcher)):
             """
 
         def on_draw(self):
-            """The window contents must be redrawn.
+            """The window contents should 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.
+            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
@@ -1601,11 +1642,11 @@ class BaseWindow(with_metaclass(_WindowMetaclass, EventDispatcher)):
             """
 
         def on_mouse_leave(self, x, y):
-            """The mouse was moved outside of the window.
+            """The mouse was moved outside 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.
+            outside the window rectangle.
 
             :Parameters:
                 `x` : int
@@ -1632,14 +1673,13 @@ class BaseWindow(with_metaclass(_WindowMetaclass, EventDispatcher)):
             """
 
         def on_refresh(self, dt):
-            """The window contents must be redrawn.
-
-            The `EventLoop` will dispatch this event when the window
-            should be redrawn.
+            """The window contents should be redrawn.
 
-            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.
+            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

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/window/cocoa/__init__.py

@@ -21,6 +21,7 @@ NSColor = cocoapy.ObjCClass('NSColor')
 NSEvent = cocoapy.ObjCClass('NSEvent')
 NSArray = cocoapy.ObjCClass('NSArray')
 NSImage = cocoapy.ObjCClass('NSImage')
+NSPasteboard = cocoapy.ObjCClass('NSPasteboard')
 
 quartz = cocoapy.quartz
 cf = cocoapy.cf
@@ -567,5 +568,32 @@ class CocoaWindow(BaseWindow):
         NSApp = NSApplication.sharedApplication()
         NSApp.setPresentationOptions_(options)
 
+    def set_clipboard_text(self, text: str):
+        with AutoReleasePool():
+            pasteboard = NSPasteboard.generalPasteboard()
+
+            pasteboard.clearContents()
+
+            array = NSArray.arrayWithObject_(cocoapy.NSPasteboardTypeString)
+            pasteboard.declareTypes_owner_(array, None)
+
+            text_nsstring = cocoapy.get_NSString(text)
+
+            pasteboard.setString_forType_(text_nsstring, cocoapy.NSPasteboardTypeString)
+
+    def get_clipboard_text(self) -> str:
+        text = ''
+        with AutoReleasePool():
+            pasteboard = NSPasteboard.generalPasteboard()
+
+            if pasteboard.types().containsObject_(cocoapy.NSPasteboardTypeString):
+                text_obj = pasteboard.stringForType_(cocoapy.NSPasteboardTypeString)
+                if text_obj:
+                    text = text_obj.UTF8String().decode('utf-8')
+
+        return text
+
+
+
 
 __all__ = ["CocoaWindow"]