psychopy 2024.2.1__py3-none-any.whl → 2024.2.5__py3-none-any.whl

psychopy/tests/test_experiment/test_experiment.py

@@ -101,3 +101,99 @@ class TestExperiment:
             else:
                 assert case['value'] not in unhandledResources
 
+    def test_loaded_namespace(self):
+
+        exp = experiment.Experiment()
+        allRoutines = experiment.getAllStandaloneRoutines(fetchIcons=False) 
+
+        """
+        Case structure
+        ==============
+        file : str
+            Experiment file to load
+        expectedSet : Set[str]
+            The expected names in the user namespace after routines are loaded and added
+        names : List[str]
+            Name of each routine to be added after experiment is loaded, paired with tags
+        tags : List[str]
+            Type of each routine to be added after experiment is loaded, paired with names
+            Can be 'CounterbalanceRoutine', 'EyetrackerCalibrationRoutine', 'EyetrackerValidationRoutine'
+        """
+
+        cases = [
+            {"file": "test_counterbalance.psyexp",
+             "expectedSet": {'trial', 'counterbalance', 'counterbalance_2', 'counterbalance_3',
+                             'counterbalance_4', 'counterbalance_5', 'calibration', 'calibration_2'},
+             "names": ['counterbalance', 'counterbalance', 'calibration', 'calibration'],
+             "tags": ['CounterbalanceRoutine', 'CounterbalanceRoutine', 'EyetrackerCalibrationRoutine',
+                      'EyetrackerCalibrationRoutine']},
+            
+            {"file": "test_counterbalance.psyexp",
+             "expectedSet": {'trial', 'counterbalance', 'counterbalance_2', 'counterbalance_3',
+                             'calibration', 'counterbalance_4', 'calibration_2'},
+             "names": ['calibration', 'counterbalance', 'calibration'],
+             "tags": ['EyetrackerCalibrationRoutine', 'EyetrackerCalibrationRoutine', 'EyetrackerCalibrationRoutine']},
+            
+            {"file": "test_custom_missing.psyexp",
+             "expectedSet": {'trial', 'custom_2', 'counterbalance_2', 'counterbalance',
+                             'counterbalance_3', 'calibration', 'calibration_2'},
+             "names": ['counterbalance', 'counterbalance', 'calibration', 'calibration'],
+             "tags": ['CounterbalanceRoutine', 'CounterbalanceRoutine', 'EyetrackerCalibrationRoutine',
+                      'EyetrackerCalibrationRoutine']},
+            
+            {"file": "test_missing_counterbalance.psyexp",
+             "expectedSet": {'trial', 'counterbalance_2', 'counterbalance', 'counterbalance_3'},
+             "names": ['counterbalance', 'counterbalance'],
+             "tags": ['CounterbalanceRoutine', 'EyetrackerCalibrationRoutine']},
+            
+            {"file": "test_mix_exp.psyexp",
+             "expectedSet": {'trial', 'counterbalance', 'calibration', 'counterbalance_2',
+                             'validation', 'counterbalance_3', 'calibration_2', 'validation_2'},
+             "names": ['counterbalance', 'calibration', 'validation'],
+             "tags": ['CounterbalanceRoutine', 'EyetrackerCalibrationRoutine', 'EyetrackerValidationRoutine']},
+            
+            {"file": "test_mix_missing.psyexp",
+             "expectedSet": {'trial', 'calibration_2', 'counterbalance_2', 'calibration',
+                             'counterbalance', 'calibration_3', 'counterbalance_3'},
+             "names": ['calibration_2', 'counterbalance_2', 'calibration', 'counterbalance'],
+             "tags": ['EyetrackerCalibrationRoutine', 'CounterbalanceRoutine', 'EyetrackerCalibrationRoutine',
+                      'CounterbalanceRoutine']},
+            
+            {"file": "test_mix_name_calibration.psyexp",
+             "expectedSet": {'trial', 'calibration_2', 'custom_2', 'counterbalance_2',
+                             'calibration', 'calibration_3', 'custom_3', 'custom'},
+             "names": ['calibration', 'calibration', 'custom_2', 'custom'],
+             "tags": ['EyetrackerCalibrationRoutine', 'CounterbalanceRoutine', 'CounterbalanceRoutine',
+                      'EyetrackerCalibrationRoutine']},
+        ]
+
+        for case in cases:
+            exp.loadFromXML(Path(TESTS_DATA_PATH) / "test_loaded_namespace" / case['file'])
+
+            # add new routines to the experiment and their names to namespace
+            namespace = exp.namespace
+            for (name, tag) in zip(case["names"], case["tags"]):   
+                routine = allRoutines[tag](exp=exp, name=name)
+                rtGoodName = routine.params['name'].val = namespace.makeValid(
+                    routine.params['name'].val)
+                namespace.add(rtGoodName)
+                exp.addStandaloneRoutine(routineName=rtGoodName, routine=routine)
+
+            actualSet = set(namespace.user)
+            expectedSet = case["expectedSet"]
+            print()
+            print(case['file'])
+            print(actualSet)
+            print(expectedSet)
+            print()
+
+            # check for no duplicate names in the namespace.user list
+            assert len(actualSet) == len(expectedSet)
+
+            # check that expected names in namespace.user list is 
+            # equivalent to the actual names in namespace.user
+            assert len(actualSet) == len(actualSet.intersection(expectedSet))
+
+
+
+

psychopy/tests/test_hardware/test_CRS_BitsSharp.py.orig

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Thu May  8 10:46:41 2014
+
+@author: jon.peirce
+"""
+import pytest
+from psychopy import visual, core
+from psychopy.hardware import crs
+
+
+def test_bitsSharp():
+    win = visual.Window(screen=1, fullscr=True, useFBO=True, autoLog=True)
+    win.setGamma(1.0) #make sure gfx card LUT is identity
+    #initialise BitsSharp
+    try:
+        bits = crs.BitsSharp(win=win, mode='color++')
+    except ImportError:
+        pytest.skip("crs.BitsSharp: could not initialize. possible:\nfrom serial.tools import list_ports\n"
+           "ImportError: No module named tools")
+
+    if not bits.OK:
+        win.close()
+        pytest.skip("No BitsSharp connected")
+        
+    print(bits.info)
+
+    #switch to status screen (while keeping in mono 'mode')
+    bits.getVideoLine(lineN=1, nPixels=1)
+    core.wait(5) #wait for status mode to take effect
+
+<<<<<<< HEAD
+    #createa  stimulus to check luminance values
+    screenSqr = visual.GratingStim(win, tex=None, mask=None, size=2)
+=======
+    #create a stimulus to check luminance values
+    screenSqr = visual.GratingStim(win,tex=None, mask=None,
+               size=2)
+>>>>>>> release
+
+    print('\n  up from zero:')
+    bit16 = (2.0 ** 16) - 1
+    for frameN in range(5):
+        intensity = frameN / bit16
+        screenSqr.color = intensity * 2 - 1  # psychopy is -1:1
+        screenSqr.draw()
+        win.flip()
+        pixels = bits.getVideoLine(lineN=1, nPixels=2)
+        print(pixels[0], pixels[1], intensity)
+
+    print('\n  down from 1:')
+    for frameN in range(5):
+        intensity = 1 - (frameN / bit16)
+        screenSqr.color = intensity * 2 - 1  # psychopy is -1:1
+        screenSqr.draw()
+        win.flip()
+        pixels = bits.getVideoLine(lineN=1, nPixels=2)
+        print(pixels[0], pixels[1], intensity)
+
+    print('\n  check the middle::')
+    for intensity in [0.5, 0.5 + (1 / bit16)]:
+        screenSqr.color = intensity * 2 - 1  # psychopy is -1:1
+        screenSqr.draw()
+        win.flip()
+        pixels = bits.getVideoLine(lineN=1, nPixels=2)
+        print(pixels[0], pixels[1], intensity)
+
+    bits.mode = "color++" #get out of status screen

psychopy/tests/test_tools/test_arraytools.py

@@ -128,3 +128,115 @@ def test_AliasDict():
     params2.alias("1", alias="one")
     assert "one" not in params.aliases
     assert "1" not in params.aliases
+
+
+class TestIndexDict:
+    def setup_method(self):
+        self.recreateData()
+    
+    def recreateData(self):
+        """
+        Recreate the test index dict from scratch, in case it changed over the course of a test.
+        """
+        self.data = at.IndexDict({
+            'someKey': "abc",
+            'someOtherKey': "def",
+            'anotherOne': "ghi",
+            1: "jkl",
+        })
+    
+    def test_isinstance(self):
+        """
+        Check that an IndexDict is an instance of dict
+        """
+        assert isinstance(self.data, dict)
+    
+    def test_length(self):
+        """
+        Check that an IndexDict reports its length as the number of explicit keys, ignoring 
+        positional indices.
+        """
+        assert len(self.data) == 4
+    
+    def test_get_item(self):
+        """
+        Check that items in an IndexDict can be got as expected, explicit keys should always take 
+        precedence over positional indices.
+        """
+        cases = [
+            # positional indices
+            (0, "abc"),
+            (2, "ghi"),
+            (3, "jkl"),
+            # explicit indices
+            ('someKey', "abc"),
+            ('someOtherKey', "def"),
+            ('anotherOne', "ghi"),
+            # conflicting indices (should favour explicit)
+            (1, "jkl"),
+        ]
+        # iterate through cases
+        for key, value in cases:
+            # check that each key returns the correct value
+            assert self.data[key] == value
+    
+    def test_set_item(self):
+        """
+        Check that items in an IndexDict can be set as expected, should set by position only if the 
+        positional index is not already defined as an explicit key.
+        """
+        cases = [
+            # set by positional index (no conflict)
+            {'set': (0, "mno"), 'get': (0, "mno")},
+            {'set': (0, "mno"), 'get': ('someKey', "mno")},
+            # set by explicit key (no conflict)
+            {'set': ('someKey', "mno"), 'get': (0, "mno")},
+            {'set': ('someKey', "mno"), 'get': ('someKey', "mno")},
+            # set by explicit string (when its positional index is also a key)
+            {'set': ('someOtherKey', "pqr"), 'get': ('someOtherKey', "pqr")},
+            {'set': ('someOtherKey', "mno"), 'get': (1, "jkl")},
+            # set by positional index (when it's also a key)
+            {'set': (1, "pqr"), 'get': ('someOtherKey', "def")},
+            {'set': (1, "pqr"), 'get': (1, "pqr")},
+            # set by explicit key not yet in array
+            {'set': ('newKey', "stu"), 'get': ('newKey', "stu")},
+            {'set': ('newKey', "stu"), 'get': (4, "stu")},
+            # set by positional index not yet in array (should treat as explicit key)
+            {'set': (6, "stu"), 'get': (6, "stu")},
+        ]
+        # iterate through cases
+        for case in cases:
+            # recreate data to clear last changes
+            self.recreateData()
+            # get values to set and expected values to return
+            seti, setval = case['set']
+            geti, getval = case['get']
+            # set value
+            self.data[seti] = setval
+            # check value
+            assert self.data[geti] == getval, (
+                f"After setting data[{repr(seti)}] = {repr(setval)} expected to get data["
+                f"{repr(geti)}] == {repr(getval)}, but instead got data[{repr(geti)}] == "
+                f"{repr(self.data[geti])}"
+            )
+    
+    def test_key_error(self):
+        """
+        Check that supplying an invalid key/index to an IndexDict still errors like a normal 
+        dict/list
+        """
+        cases = [
+            # index bigger than array
+            (4, KeyError, "4 should be out of bounds, but got {}"),
+            # key not in array
+            ('lalala', KeyError, "There shouldn't be a value for 'lalala', but got {}"),
+        ]
+        for i, errType, msg in cases:
+            try:
+                val = self.data[i]
+            except errType as err:
+                # if it errors as expected, good!
+                pass
+            else:
+                # if no error, raise an assertion error with message
+                raise AssertionError(msg.format(val))

psychopy/tests/test_visual/test_image.py.orig

@@ -0,0 +1,219 @@
+from pathlib import Path
+
+from psychopy import visual, colors, core
+from .test_basevisual import _TestUnitsMixin
+from psychopy.tests.test_experiment.test_component_compile_python import _TestBoilerplateMixin
+from .. import utils
+
+from ..utils import TESTS_DATA_PATH
+
+
+class TestImage(_TestUnitsMixin, _TestBoilerplateMixin):
+    """
+    Test that images render as expected. Note: In BaseVisual tests, image colors will look different than
+    seems intuitive as foreColor will be set to `"blue"`.
+    """
+    def setup(self):
+        self.win = visual.Window()
+        self.obj = visual.ImageStim(
+            self.win,
+            str(Path(TESTS_DATA_PATH) / 'testimage.jpg'),
+            colorSpace='rgb1',
+        )
+
+    def test_anchor_flip(self):
+        """
+        Check that flipping the image doesn't flip the direction of the anchor
+        """
+        # Setup obj
+        self.obj.units = "height"
+        self.obj.pos = (0, 0)
+        self.obj.size = (0.5, 0.5)
+        self.obj.anchor = "bottom left"
+        # Flip vertically
+        self.obj.flipVert = True
+        self.obj.flipHoriz = False
+        # Check
+        self.win.flip()
+        self.obj.draw()
+        # self.win.getMovieFrame(buffer='back').save(Path(utils.TESTS_DATA_PATH) / "test_image_flip_anchor_vert.png")
+        utils.compareScreenshot("test_image_flip_anchor_vert.png", self.win, crit=7)
+        # Flip horizontally
+        self.obj.flipVert = False
+        self.obj.flipHoriz = True
+        # Check
+        self.win.flip()
+        self.obj.draw()
+        # self.win.getMovieFrame(buffer='back').save(Path(utils.TESTS_DATA_PATH) / "test_image_flip_anchor_horiz.png")
+        utils.compareScreenshot("test_image_flip_anchor_horiz.png", self.win, crit=7)
+
+<<<<<<< HEAD
+    def test_aspect_ratio(self):
+        """
+        Test that images set with one or both dimensions as None maintain their aspect ratio
+        """
+        cases = [
+            # norm 1:1
+            {"img": "default.png", "aspect": (1, 1),
+             "size": (None, 2), "units": "norm",
+             "tag": "default_xNone_yFull"},
+            {"img": "default.png", "aspect": (1, 1),
+             "size": (2, None), "units": "norm",
+             "tag": "default_xFull_yNone"},
+            {"img": "default.png", "aspect": (1, 1),
+             "size": (None, None), "units": "norm",
+             "tag": "default_xNone_yNone"},
+            {"img": "default.png", "aspect": (1, 1),
+             "size": None, "units": "norm",
+             "tag": "default_None"},
+            # height 1:1
+            {"img": "default.png", "aspect": (1, 1),
+             "size": (None, 1), "units": "height",
+             "tag": "default_xNone_yFull"},
+            {"img": "default.png", "aspect": (1, 1),
+             "size": (1 / self.win.size[1] * self.win.size[0], None), "units": "height",
+             "tag": "default_xFull_yNone"},
+            {"img": "default.png", "aspect": (1, 1),
+             "size": (None, None), "units": "height",
+             "tag": "default_xNone_yNone"},
+            {"img": "default.png", "aspect": (1, 1),
+             "size": None, "units": "height",
+             "tag": "default_None"},
+            # pix 1:1
+            {"img": "default.png", "aspect": (1, 1),
+             "size": (None, self.win.size[1]), "units": "pix",
+             "tag": "default_xNone_yFull"},
+            {"img": "default.png", "aspect": (1, 1),
+             "size": (self.win.size[0], None), "units": "pix",
+             "tag": "default_xFull_yNone"},
+            {"img": "default.png", "aspect": (1, 1),
+             "size": (None, None), "units": "pix",
+             "tag": "default_xNone_yNone"},
+            {"img": "default.png", "aspect": (1, 1),
+             "size": None, "units": "pix",
+             "tag": "default_None"},
+        ]
+        for case in cases:
+            # Set image
+            self.obj.image = case['img']
+            # Set size
+            self.obj.units = case['units']
+            self.obj.size = case['size']
+            # Check that aspect ratio is still correct
+            assert self.obj.aspectRatio == case['aspect']
+            # Check that image looks as expected
+            self.obj.draw()
+            filename = f"test_image_aspect_{case['tag']}.png"
+            # self.win.getMovieFrame(buffer='back').save(Path(utils.TESTS_DATA_PATH) / filename)
+            utils.compareScreenshot(Path(utils.TESTS_DATA_PATH) / filename, self.win, crit=7)
+            self.win.flip()
+=======
+
+class TestImageAnimation:
+    """
+    Tests for using ImageStim to create frame animations
+    """
+    @classmethod
+    def setup_class(cls):
+        nFrames = 16
+        # Define array of sizes/desired frame rates
+        cls.cases = [
+            {'size': 6 ** 2, 'fps': 16},
+            {'size': 8 ** 2, 'fps': 16},
+            {'size': 10 ** 2, 'fps': 8},
+            {'size': 12 ** 2, 'fps': 2},
+        ]
+        # Create frames
+        for i, case in enumerate(cls.cases):
+            size = case['size']
+            # Create window and shapes
+            win = visual.Window(size=(size, size), color='purple')
+            shape1 = visual.ShapeStim(win,
+                                      pos=(0.2, 0.2), size=(0.5, 0.5),
+                                      lineWidth=size * 0.1,
+                                      fillColor='red', lineColor='green',
+                                      )
+            shape2 = visual.ShapeStim(win,
+                                      pos=(-0.2, -0.2), size=(0.5, 0.5),
+                                      lineWidth=size * 0.1,
+                                      fillColor='blue', lineColor='yellow'
+                                      )
+
+            frames = []
+
+            for thisFrame in range(nFrames):
+                # Cycle window hue
+                win.color = colors.Color(
+                    (win._color.hsv[0] + 360 * thisFrame / nFrames, win._color.hsv[1], win._color.hsv[2]),
+                    'hsv'
+                )
+                # Cycle shape hues
+                shape1._fillColor.hsv = (
+                    shape1._fillColor.hsv[0] + 360 * thisFrame / nFrames, shape1._fillColor.hsv[1],
+                    shape1._fillColor.hsv[2]
+                )
+                shape1._borderColor.hsv = (
+                    shape1._borderColor.hsv[0] - 360 * thisFrame / nFrames, shape1._borderColor.hsv[1],
+                    shape1._borderColor.hsv[2]
+                )
+                shape2._fillColor.hsv = (
+                    shape2._fillColor.hsv[0] + 360 * thisFrame / nFrames, shape2._fillColor.hsv[1],
+                    shape2._fillColor.hsv[2]
+                )
+                shape2._borderColor.hsv = (
+                    shape2._borderColor.hsv[0] - 360 * thisFrame / nFrames, shape2._borderColor.hsv[1],
+                    shape2._borderColor.hsv[2]
+                )
+                # Rotate shapes
+                shape1.ori = shape1.ori + 360 * thisFrame / nFrames
+                shape2.ori = shape2.ori - 360 * thisFrame / nFrames
+                # Render
+                win.flip()
+                shape1.draw()
+                shape2.draw()
+                # Get frame
+                frame = win.getMovieFrame(buffer='back')
+                frames.append(
+                    frame
+                )
+
+            # Cleanup
+            win.close()
+            del shape1
+            del shape2
+            # Update case
+            cls.cases[i]['frames'] = frames
+
+    def test_fps(self):
+        """
+        Check that images can be updated sufficiently fast to create frame animations
+        """
+        # Create clock
+        clock = core.Clock()
+        # Try at each size
+        for case in self.cases:
+            size = case['size']
+            # Make window and image
+            win = visual.Window(size=(size, size))
+            img = visual.ImageStim(win, units='pix', size=(size, size))
+            # Iterate through frames
+            refr = []
+            for frame in case['frames']:
+                # Reset clock
+                clock.reset()
+                # Set image contents
+                img.image = frame
+                # Update
+                img.draw()
+                win.flip()
+                # Store time taken
+                refr.append(clock.getTime())
+            # Print frame rate for this size
+            fps = round(1 / max(refr))
+            assert fps > case['fps'], (
+                f"Max frame rate for {size}x{size} animations should be at least {case['fps']}, but was {fps}"
+            )
+            # Cleanup
+            win.close()
+            del img
+>>>>>>> 14bdb82f9dac0abd734f48d14e74d67e0eb3cc50

psychopy/tools/arraytools.py

@@ -21,6 +21,53 @@ import numpy
 import ctypes
 
 
+class IndexDict(dict):
+    """
+    A dict which allows for keys to be accessed by index as well as by key. Can be initialised 
+    from a dict, or from a set of keyword arguments.
+
+    Example
+    -------
+    ```
+    data = IndexDict({
+        'someKey': "abc",
+        'someOtherKey': "def",
+        'anotherOne': "ghi",
+        1: "jkl",
+    })
+    # using a numeric index will return the value for the key at that position
+    print(data[0])  # prints: abc
+    # ...unless that number is already a key
+    print(data[1])  # prints: jkl
+    ```
+    """
+    def __init__(self, arr=None, **kwargs):
+        # initialise dict
+        dict.__init__(self)
+        # if given no dict, use a blank one
+        if arr is None:
+            arr = {}
+        # if given a dict, update kwargs with it
+        kwargs.update(arr)
+        # set every key
+        for key, value in kwargs.items():
+            dict.__setitem__(self, key, value)
+    
+    def __getitem__(self, key):
+        # if key is a valid numeric index not present as a normal key, get matching key
+        if isinstance(key, int) and key < len(self) and key not in self:
+            return list(self.values())[key]
+        # index like normal
+        return dict.__getitem__(self, key)
+    
+    def __setitem__(self, key, value):
+        # if key is a valid numeric index not present as a normal key, get matching key
+        if isinstance(key, int) and key < len(self) and key not in self:
+            key = list(self.keys())[key]
+        # set like normal
+        return dict.__setitem__(self, key, value)
+
+
 def createXYs(x, y=None):
     """Create an Nx2 array of XY values including all combinations of the
     x and y values provided.

psychopy/tools/versionchooser.py

@@ -202,7 +202,7 @@ def getPsychoJSVersionStr(currentVersion, preferredVersion=''):
         # e.g. 2021.1.0 not 2021.1.0.dev3
         useVerStr = '.'.join(useVerStr.split('.')[:3])
     # PsychoJS doesn't have additional rc1 or dev1 releases
-    for versionSuffix in ["rc", "dev", "a", "b"]:
+    for versionSuffix in ["rc", "dev", "post", "a", "b"]:
         if versionSuffix in useVerStr:
             useVerStr = useVerStr.split(versionSuffix)[0]
 

psychopy/visual/backends/pygletbackend.py

@@ -304,6 +304,23 @@ class PygletBackend(BaseBackend):
             except Exception:
                 # pyglet 1.2 with 64bit python?
                 win._hw_handle = self.winHandle._nswindow.windowNumber()
+            # Here we temporarily set the window to the bottom right corner of the
+            # requested screen so the correct screen is always detected for NSWindow.
+            # The actual location is then set below using the pyglet set_location()
+            # method on the CocoaWindow object that wraps the NSWindow as _nswindow.
+            # This is necessary because NSScreen origin is the bottom left corner of
+            # the unshifted main screen and positive up, while pyglet origin is the top
+            # left corner of the shifted main screen and positive down. If thisScreen is
+            # not the main screen, we need to prevent self.winHandle._nswindow.screen()
+            # from returning None, which can happen when the c binding returns nil if the
+            # window is offscreen as a result of flipped y values of origins beween pyglet
+            # and NSWindow coordinate systems.
+            from pyglet.libs.darwin import cocoapy
+            mainScreen_y_from_NSOrigin = allScrs[0].y + allScrs[0].height
+            thisScreen_y_from_NSOrigin = thisScreen.y + thisScreen.height
+            thisScreen_y = mainScreen_y_from_NSOrigin - thisScreen_y_from_NSOrigin
+            temp_origin = cocoapy.NSPoint(thisScreen.x, thisScreen_y)
+            self.winHandle._nswindow.setFrameOrigin_(temp_origin)
         elif sys.platform.startswith('linux'):
             win._hw_handle = self.winHandle._window
             self._frameBufferSize = win.clientSize
@@ -345,14 +362,15 @@ class PygletBackend(BaseBackend):
             # (but need to alter x,y handling then)
             self.winHandle.set_mouse_visible(False)
         if not win.pos:
-            # work out where the centre should be
-            if win.useRetina:
-                win.pos = [(thisScreen.width - win.clientSize[0]/2) / 2,
-                           (thisScreen.height - win.clientSize[1]/2) / 2]
-            else:
-                win.pos = [(thisScreen.width - win.clientSize[0]) / 2,
-                           (thisScreen.height - win.clientSize[1]) / 2]
-        if not win._isFullScr:
+            # work out the location of the top-left corner to place at the screen center
+            win.pos = [(thisScreen.width - win.clientSize[0]) / 2,
+                       (thisScreen.height - win.clientSize[1]) / 2]
+        if sys.platform == 'darwin':
+            # always need to set the cocoa window location due to origin changes
+            screenHeight_offset = thisScreen.height - allScrs[0].height
+            self.winHandle.set_location(int(win.pos[0] + thisScreen.x),
+                                        int(win.pos[1] + thisScreen.y + screenHeight_offset))
+        elif not win._isFullScr:
             # add the necessary amount for second screen
             self.winHandle.set_location(int(win.pos[0] + thisScreen.x),
                                         int(win.pos[1] + thisScreen.y))