Пример #1
0
        def __init__(self):
            self.root = None

            self.keycode = 0
            self.modifiers = 0
            self.activated = False
            self.observer = None

            self.acquire_key = 0
            self.acquire_state = HotkeyMgr.ACQUIRE_INACTIVE

            self.tkProcessKeyEvent_old = None

            if getattr(sys, 'frozen', False):
                respath = normpath(
                    join(dirname(sys.executable), os.pardir, 'Resources'))
            elif __file__:
                respath = dirname(__file__)
            else:
                respath = '.'
            self.snd_good = NSSound.alloc(
            ).initWithContentsOfFile_byReference_(
                join(respath, 'snd_good.wav'), False)
            self.snd_bad = NSSound.alloc().initWithContentsOfFile_byReference_(
                join(respath, 'snd_bad.wav'), False)
Пример #2
0
 def loud(self):
     self.snd_warn = NSSound.alloc(
     ).initWithContentsOfFile_byReference_(
         utils2to3.abspathmaker(__file__, 'sounds', 'snd_warn.wav'),
         False)
     self.snd_notify = NSSound.alloc(
     ).initWithContentsOfFile_byReference_(
         utils2to3.abspathmaker(__file__, 'sounds', 'snd_notify.wav'),
         False)
Пример #3
0
 def executeCapture(self):
     self.photoView.setHidden_(False)
     self.captureView.setHidden_(True)
     self.previewButton.setHidden_(False)
     self.countdownCheckbox.setHidden_(True)
     self.captureButton.setHidden_(True)
     self.useButton.setEnabled_(True)
     if self.captureSession is not None:
         self.captureImage()
         NSSound.soundNamed_("Grab").play()
         self.captureSession.stopRunning()
Пример #4
0
 def __init__(self):
     self.pSound = [True]
     for x in range(1,5):
         self.pSound.append(NSSound.alloc())
         print "Loading Player %d sound." %(x,)
         self.pSound[x].initWithContentsOfFile_byReference_("%s/p%d.mp3" % (sound_path, x), True)
     print "Loading Error and Timeout sounds"    
     self.pSoundError = NSSound.alloc()
     self.pSoundError.initWithContentsOfFile_byReference_("%s/erro.mp3" % (sound_path,), True)
     self.pSoundTimeOut = NSSound.alloc()
     self.pSoundTimeOut.initWithContentsOfFile_byReference_("%s/timeout.mp3" % (sound_path,), True)
Пример #5
0
 def executeTimerCapture_(self, timer):
     if self.countdown_counter == 1:
         self.executeCapture()
         self.countdownProgress.stopAnimation_(None)
         self.countdownCheckbox.setHidden_(True)
         self.countdownProgress.setHidden_(True)
         self.timer.invalidate()
         self.timer = None
     else:
         self.countdown_counter = self.countdown_counter - 1
         NSSound.soundNamed_("Tink").play()
         self.countdownProgress.setDoubleValue_(self.countdown_counter)
Пример #6
0
 def executeTimerCapture_(self, timer):
     if self.countdown_counter == 1:
         self.executeCapture()
         self.countdownProgress.stopAnimation_(None)
         self.countdownCheckbox.setHidden_(True)
         self.mirrorButton.setHidden_(True)
         self.countdownProgress.setHidden_(True)
         self.timer.invalidate()
         self.timer = None
     else:
         self.countdown_counter = self.countdown_counter - 1
         NSSound.soundNamed_("Tink").play()
         self.countdownProgress.setDoubleValue_(self.countdown_counter)
Пример #7
0
        def __init__(self):
            self.root = None

            self.keycode = 0
            self.modifiers = 0
            self.activated = False
            self.observer = None

            self.acquire_key = 0
            self.acquire_state = HotkeyMgr.ACQUIRE_INACTIVE

            self.tkProcessKeyEvent_old = None

            self.snd_good = NSSound.alloc().initWithContentsOfFile_byReference_(join(config.respath, 'snd_good.wav'), False)
            self.snd_bad  = NSSound.alloc().initWithContentsOfFile_byReference_(join(config.respath, 'snd_bad.wav'), False)
Пример #8
0
    def _play_sound(cls, file, playing_time=None):
        """
        Utilizes AppKit.NSSound. Tested and known to work with MP3 and WAVE on
        OS X 10.11 with Python 2.7. Probably works with anything QuickTime supports.
        Probably works on OS X 10.5 and newer. Probably works with all versions of
        Python.
        Inspired by (but not copied from) Aaron's Stack Overflow answer here:
        http://stackoverflow.com/a/34568298/901641
        I never would have tried using AppKit.NSSound without seeing his code.
        """
        from AppKit import NSSound
        from Foundation import NSURL

        if '://' not in file:
            if not file.startswith('/'):
                from os import getcwd
                file = f'{getcwd()}/{file}'
            file = f'file://{file}'

        nssound = NSSound.alloc().initWithContentsOfURL_byReference_(NSURL.URLWithString_(file), True)
        if not nssound:
            raise IOError(f'Unable to load sound named: {file}')
        nssound.play()

        if playing_time is None:
            time.sleep(nssound.duration())
        else:
            time.sleep(playing_time)
Пример #9
0
def play_sound_file(path_to_soundfile):
    path_to_soundfile = check_soundfile_path(path_to_soundfile)
    if path_to_soundfile is None:
        return

    path_to_soundfile = str(path_to_soundfile)
    if sys.platform == 'win32':
        import winsound
        try:
            winsound.PlaySound(path_to_soundfile,
                               winsound.SND_FILENAME|winsound.SND_ASYNC)
        except Exception:
            log.exception('Sound Playback Error')

    elif sys.platform == 'darwin':
        try:
            from AppKit import NSSound
        except ImportError:
            log.exception('Sound Playback Error')
            return

        sound = NSSound.alloc()
        sound.initWithContentsOfFile_byReference_(path_to_soundfile, True)
        sound.play()

    elif app.is_installed('GSOUND'):
        try:
            app.gsound_ctx.play_simple({'media.filename' : path_to_soundfile})
        except GLib.Error as error:
            log.error('Could not play sound: %s', error.message)
Пример #10
0
def _playsoundOSX(sound, block=True):
    '''
    Utilizes AppKit.NSSound. Tested and known to work with MP3 and WAVE on
    OS X 10.11 with Python 2.7. Probably works with anything QuickTime supports.
    Probably works on OS X 10.5 and newer. Probably works with all versions of
    Python.

    Inspired by (but not copied from) Aaron's Stack Overflow answer here:
    http://stackoverflow.com/a/34568298/901641

    I never would have tried using AppKit.NSSound without seeing his code.
    '''
    from AppKit import NSSound
    from Foundation import NSURL
    from time import sleep

    if '://' not in sound:
        if not sound.startswith('/'):
            from os import getcwd
            sound = getcwd() + '/' + sound
        sound = 'file://' + sound
    url = NSURL.URLWithString_(sound)
    nssound = NSSound.alloc().initWithContentsOfURL_byReference_(url, True)
    if not nssound:
        raise IOError('Unable to load sound named: ' + sound)
    nssound.play()

    if block:
        sleep(nssound.duration())
Пример #11
0
 def mac_play(path):
     """
     play a sound using mac api
     """
     macsound = NSSound.alloc()
     macsound.initWithContentsOfFile_byReference_(path, True)
     macsound.play()
Пример #12
0
 def mac_play(self, path):
     """
     play a sound using mac api
     """
     macsound = NSSound.alloc()
     macsound.initWithContentsOfFile_byReference_(path, True)
     macsound.play()
Пример #13
0
 def play(self, fp):
     from AppKit import NSSound
     sound = NSSound.alloc()
     sound.initWithContentsOfFile_byReference_(fp.name, True)
     sound.play()
     while sound.isPlaying():
       time.sleep(1)
Пример #14
0
def playSound():
    import nuke
    import os
    import nukescripts
    macSound = 'PATH/TO/SOUND/FILE'
    winSound = os.path.dirname(
        nuke.env['ExecutablePath']) + '/' + 'plugins/user/user/Beep.WAV'
    if nuke.env["MACOS"]:
        sys.path.append(
            '/System/Library/Frameworks/Python.framework/Versions/2.5/Extras/lib/python'
        )
        sys.path.append(
            '/System/Library/Frameworks/Python.framework/Versions/2.5/Extras/lib/python/PyObjC'
        )
        from AppKit import NSSound
        sound = NSSound.alloc()
        sound.initWithContentsOfFile_byReference_(macSound, True)
        sound.play()
    elif nuke.env["WIN32"]:
        import winsound
        winsound.PlaySound(winSound,
                           winsound.SND_FILENAME | winsound.SND_ASYNC)

# TopDir = os.path.dirname(nuke.env['ExecutablePath']) + '/';
# if nuke.env['MACOS']:
# TopDir = os.path.abspath(TopDir + '../../../') + '/'
#nukescripts.start(TopDir + 'plugins/user/user/Beep.WAV')
Пример #15
0
def _playsoundOSX(sound, block = True):
    '''
    Utilizes AppKit.NSSound. Tested and known to work with MP3 and WAVE on
    OS X 10.11 with Python 2.7. Probably works with anything QuickTime supports.
    Probably works on OS X 10.5 and newer. Probably works with all versions of
    Python.

    Inspired by (but not copied from) Aaron's Stack Overflow answer here:
    http://stackoverflow.com/a/34568298/901641

    I never would have tried using AppKit.NSSound without seeing his code.
    '''
    from AppKit     import NSSound
    from Foundation import NSURL
    from time       import sleep

    if '://' not in sound:
        if not sound.startswith('/'):
            from os import getcwd
            sound = getcwd() + '/' + sound
        sound = 'file://' + sound
    url   = NSURL.URLWithString_(sound)
    nssound = NSSound.alloc().initWithContentsOfURL_byReference_(url, True)
    if not nssound:
        raise IOError('Unable to load sound named: ' + sound)
    nssound.play()

    if block:
        sleep(nssound.duration())
Пример #16
0
 def play(self, sound_theme,  sound):
     if self.beep and not self.isMac:
         gtk.gdk.beep()
         return
     for theme in (sound_theme, 'default'):
         soundPath = os.path.join(paths.SOUNDS_PATH, sound_theme,
             sound + ".wav")
         if os.path.exists(soundPath):
             break
         else:
             soundPath = ''
     if not soundPath:
         return
     if os.name == "nt":
         winsound.PlaySound(soundPath, 
             winsound.SND_FILENAME | winsound.SND_ASYNC)
     elif os.name == "posix":
         if self.canGstreamer:
             loc = "file://" + soundPath
             self.player.set_property('uri', loc)
             self.player.set_state(gst.STATE_PLAYING)
         elif self.isMac:
             macsound = NSSound.alloc()
             macsound.initWithContentsOfFile_byReference_( \
                 soundPath, True)
             macsound.play()
             while macsound.isPlaying():
                 pass
         else:
             os.popen4(self.command + " " + soundPath)
def _playsoundOSX(sound, block=True):
    from AppKit import NSSound
    from time import sleep

    sound = NSSound.alloc().initWithContentsOfFile_byReference_(sound, True)
    sound.play()

    if block:
        sleep(sound.duration())
Пример #18
0
        def __init__(self):
            self.root = None

            self.keycode = 0
            self.modifiers = 0
            self.activated = False
            self.observer = None

            self.acquire_key = 0
            self.acquire_state = HotkeyMgr.ACQUIRE_INACTIVE

            self.tkProcessKeyEvent_old = None

            self.snd_good = NSSound.alloc(
            ).initWithContentsOfFile_byReference_(
                join(config.respath, 'snd_good.wav'), False)
            self.snd_bad = NSSound.alloc().initWithContentsOfFile_byReference_(
                join(config.respath, 'snd_bad.wav'), False)
Пример #19
0
 def loadSounds(self):
     self._sounds = {}
     directory = self.getSoundDirectory()
     if directory and os.path.exists(directory):
         for fileName in os.listdir(directory):
             path = os.path.join(directory, fileName)
             sound = NSSound.alloc().initWithContentsOfFile_byReference_(
                 path, False)
             if sound is not None:
                 self._sounds[fileName] = sound
Пример #20
0
	def do_play(self):
		if self.playing or not self.queue:
			return
		self.playing = True
		sample = self.queue[0]
		del self.queue[0]
		self.impl = NSSound.alloc()
		data = NSData.alloc().initWithBytes_length_(sample, len(sample))
		self.impl.initWithData_(data)
		self.impl.setDelegate_(self)
		self.impl.play()
Пример #21
0
def _playsoundOSX(sound):

    from AppKit import NSSound
    from Foundation import NSURL
    from time import sleep

    url = NSURL.URLWithString_(sound)
    nssound = NSSound.alloc().initWithContentsOfURL_byReference_(url, True)
    if not nssound:
        raise IOError("Unable to load sound named: " + sound)
    nssound.play()
def play_sound(sound_file):
    """Plays the audio file that is at the fully qualified path `sound_file`"""
    system = platform.system()
    if system == "Windows":
        import winsound
        winsound.PlaySound(sound_file,
                           winsound.SND_FILENAME | winsound.SND_ASYNC)
    elif system == "Darwin":  # macOS
        from AppKit import NSSound
        from Foundation import NSURL
        cwd = os.getcwd()
        url = NSURL.URLWithString_("file://" + sound_file)
        NSSound.alloc().initWithContentsOfURL_byReference_(url, True).play()
    else:  # Linux
        import subprocess
        command = ["aplay", sound_file]
        subprocess.Popen(command,
                         stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE,
                         bufsize=0,
                         universal_newlines=True)
Пример #23
0
        def __init__(self):
            self.root = None

            self.keycode = 0
            self.modifiers = 0
            self.activated = False
            self.observer = None

            self.acquire_key = 0
            self.acquire_state = HotkeyMgr.ACQUIRE_INACTIVE

            self.tkProcessKeyEvent_old = None

            if getattr(sys, 'frozen', False):
                respath = normpath(join(dirname(sys.executable), os.pardir, 'Resources'))
            elif __file__:
                respath = dirname(__file__)
            else:
                respath = '.'
            self.snd_good = NSSound.alloc().initWithContentsOfFile_byReference_(join(respath, 'snd_good.wav'), False)
            self.snd_bad  = NSSound.alloc().initWithContentsOfFile_byReference_(join(respath, 'snd_bad.wav'), False)
Пример #24
0
 def __init__(self, sound):
     self.sound = sound
     if '://' not in self.sound:
         if not self.sound.startswith('/'):
             from os import getcwd
             self.sound = getcwd() + '/' + self.sound
         self.sound = 'file://' + self.sound
     url = NSURL.URLWithString_(self.sound)
     self.nssound = NSSound.alloc().initWithContentsOfURL_byReference_(
         url, True)
     if not self.nssound:
         raise IOError('Unable to load sound named: ' + self.sound)
Пример #25
0
 def play_sound_darwin(self, wav_file_as_byte_array):
     from AppKit import NSSound
     from AppKit import NSObject
     from AppKit import NSData
     
     nssound = NSSound.alloc()
     data = NSData.alloc().initWithBytes_length_(wav_file_as_byte_array, len(wav_file_as_byte_array))
     nssound.initWithData_(data)
     nssound.setDelegate_(self)
     if (not nssound):
         raise IOError('Unable to load sound.')
     nssound.play()
Пример #26
0
    def _playsoundOSX(sound):
        from AppKit     import NSSound
        from Foundation import NSURL

        if '://' not in sound:
            if not sound.startswith('/'):
                sound = os.getcwd() + '/' + sound
            sound = 'file://' + sound
        url   = NSURL.URLWithString_(sound)
        nssound = NSSound.alloc().initWithContentsOfURL_byReference_(url, True)
        if not nssound:
            raise IOError('Unable to load sound named: ' + sound)
        nssound.play()
Пример #27
0
    def generate(self, text, host="", name="Morse" ):
        tmpdir = mkdtemp()
        try:
            filename = os.path.join(tmpdir, "objc.wav")
            fd = open(filename, 'wb')
            self.bytesForStr( text ).tofile(fd)
            fd.close()

            player = NSSound.alloc()
            try:
                player.initWithContentsOfFile_byReference_(filename, False)
                player.play()
                sleep(player.duration() + 1)
            finally:
                del player
        finally:
            rmtree(tmpdir)
Пример #28
0
 def play_path(self, soundPath):
     if os.name == "nt":
         winsound.PlaySound(soundPath, 
             winsound.SND_FILENAME | winsound.SND_ASYNC)
     elif os.name == "posix":
         if self.canGstreamer:
             loc = "file://" + soundPath
             self.player.set_property('uri', loc)
             self.player.set_state(gst.STATE_PLAYING)
         elif self.isMac:
             macsound = NSSound.alloc()
             macsound.initWithContentsOfFile_byReference_( \
                 soundPath, True)
             macsound.play()
             while macsound.isPlaying():
                 pass
         else:
             os.popen4(self.command + " " + soundPath)
Пример #29
0
 def play_path(self, soundPath):
     if os.name == "nt":
         winsound.PlaySound(soundPath, 
             winsound.SND_FILENAME | winsound.SND_ASYNC)
     elif os.name == "posix":
         if self.canGstreamer:
             loc = "file://" + soundPath
             self.player.set_property('uri', loc)
             self.player.set_state(gst.STATE_PLAYING)
         elif self.isMac:
             macsound = NSSound.alloc()
             macsound.initWithContentsOfFile_byReference_( \
                 soundPath, True)
             macsound.play()
             while macsound.isPlaying():
                 pass
         else:
             # os.popen4(self.command + " " + soundPath)
             subprocess.Popen([self.command, soundPath])
Пример #30
0
def _playaudioOSX(sound, block=True):
    '''
    Utilizes AppKit.NSSound.
    '''
    from AppKit import NSSound
    from Foundation import NSURL
    from time import sleep

    if '://' not in sound:
        if not sound.startswith('/'):
            from os import getcwd
            sound = getcwd() + '/' + sound
        sound = 'file://' + sound
    url = NSURL.URLWithString_(sound)
    nssound = NSSound.alloc().initWithContentsOfURL_byReference_(url, True)
    if not nssound:
        raise IOError('Unable to load sound named: ' + sound)
    nssound.play()

    if block:
        sleep(nssound.duration())
Пример #31
0
    def present(self):
        """Present the Alert, giving up after configured time..

        Returns: Int result code, based on PyObjC enums. See NSAlert
            Class reference, but result should be one of:
                User clicked the cancel button:
                    NSAlertFirstButtonReturn = 1000
                Alert timed out:
                    NSRunAbortedResponse = -1001
        """
        if self.timer:
            NSRunLoop.currentRunLoop().addTimer_forMode_(self.timer, NSModalPanelRunLoopMode)
        # Start a Cocoa application by getting the shared app object.
        # Make the python app the active app so alert is noticed.
        app = NSApplication.sharedApplication()
        app.activateIgnoringOtherApps_(True)
        if self.alert_sound:
            sound = NSSound.soundNamed_(self.alert_sound).play()
        result = self.runModal()  # pylint: disable=no-member
        print result
        return result
Пример #32
0
def main():
	
	# Play a sound
	snd = "paper_shredder.wav"
	sound = NSSound.alloc()
	#sound.initWithContentsOfFile_byReference_('/Users/aleray/Desktop/Paper Shredder.app/Contents/Resources/paper_shredder.wav', True)
	sound.play()
	
	meter = EasyDialogs.ProgressBar('Compressing your images...',
	                                maxval=100,
	                                label='Starting',
	                                )
	for i in xrange(1, 101):
	    phase = '%d %% Completed' % i
	    print phase
	    meter.label(phase)
	    meter.inc()
	    time.sleep(0.01)
	print 'Done with loop'
	time.sleep(1)

	del meter
	print 'The dialog should be gone now'

	for infile in sys.argv[1:]:
		fileName = os.path.basename(sys.argv[1]).split(".")[0]
		fileExt = os.path.basename(sys.argv[1]).split(".")[1]
		outfile = "/Users/aleray/Recycled/Image Compression 1/%s.compressed.%s" % (fileName, fileExt)
		if infile != outfile:
			try:
				im = Image.open(infile)
				xsize, ysize = im.size
				ysize = ysize/20
				im = im.resize([xsize, ysize])
				print im.size
				im.save(outfile, "JPEG")
				im.show()
			except IOError:
				print "cannot create thumbnail for", infile
Пример #33
0
def _playsoundOSX(sound, block = True):
    '''
    Utilizes AppKit.NSSound. Tested and known to work with MP3 and WAVE on
    OS X 10.11 with Python 2.7. Probably works with anything QuickTime supports.
    Probably works on OS X 10.5 and newer. Probably works with all versions of
    Python.

    Inspired by (but not copied from) Aaron's Stack Overflow answer here:
    http://stackoverflow.com/a/34568298/901641

    I never would have tried using AppKit.NSSound without seeing his code.
    '''
    try:
        from AppKit import NSSound
    except ImportError:
        logger.warning("playsound could not find a copy of AppKit - falling back to using macOS's system copy.")
        sys.path.append('/System/Library/Frameworks/Python.framework/Versions/2.7/Extras/lib/python/PyObjC')
        from AppKit import NSSound

    from Foundation import NSURL
    from time       import sleep

    sound = _handlePathOSX(sound)
    url   = NSURL.URLWithString_(sound)
    if not url:
        raise PlaysoundException('Cannot find a sound with filename: ' + sound)

    for i in range(5):
        nssound = NSSound.alloc().initWithContentsOfURL_byReference_(url, True)
        if nssound:
            break
        else:
            logger.debug('Failed to load sound, although url was good... ' + sound)
    else:
        raise PlaysoundException('Could not load sound with filename, although URL was good... ' + sound)
    nssound.play()

    if block:
        sleep(nssound.duration())
Пример #34
0
    def present(self):
        """Present the Alert, giving up after configured time..

        Returns: Int result code, based on PyObjC enums. See NSAlert
            Class reference, but result should be one of:
                User clicked the cancel button:
                    NSAlertFirstButtonReturn = 1000
                Alert timed out:
                    NSRunAbortedResponse = -1001
        """
        if self.timer:
            NSRunLoop.currentRunLoop().addTimer_forMode_(
                self.timer, NSModalPanelRunLoopMode)
        # Start a Cocoa application by getting the shared app object.
        # Make the python app the active app so alert is noticed.
        app = NSApplication.sharedApplication()
        app.activateIgnoringOtherApps_(True)
        if self.alert_sound:
            sound = NSSound.soundNamed_(self.alert_sound).play()
        result = self.runModal()  # pylint: disable=no-member
        print result
        return result
Пример #35
0
def second_time_crate():
    global end_time2
    its_time = False
    while its_time == False:
        its_time = False
        # ------------------------------------------ #
        # ------ Local Time in your country! ------- #
        # ------------------------------------------ #
        Timer = time.asctime(time.localtime(time.time()))
        # ------------------------- #
        # ------ Timer Loop ------- #
        # ------------------------- #
        if Timer == end_time2:
            its_time = True
            print("It's time to take your puppy out!")
        # ----------------------------- #
        # ------ Prepare Sounds ------- #
        # ----------------------------- #
            sound = NSSound.alloc()
            sound.initWithContentsOfFile_byReference_(
                '/Library/Audio/Apple Loops/Apple/01 Hip Hop/Afloat Beat.caf', True)
            sound.play()
        # --------------------------------------------------------------------------------------------- #
        # ------ Add 20 seconds time sleep (time the song play) before to jump to the next part ------- #
        # --------------------------------------------------------------------------------------------- #
            time.sleep(20)
            third_time_crate()
        # --------------------------------------------- #
        # ------ Print this until the time out! ------- #
        # --------------------------------------------- #
        else:
            print("Local current time :", Timer)
            print("\tTimer end at: ", end_time2)
            print("." * 50)
            time.sleep(1)
            its_time = False
Пример #36
0
 def __init__(self, file):
     self._sound = NSSound.alloc()
     self._sound.initWithContentsOfFile_byReference_(file, True)
Пример #37
0
def load_sound(name, loop=False):
    f = os.path.join(basedir, 'sounds', name + '.wav')
    sounds[name] = NSSound.alloc()
    sounds[name].initWithContentsOfFile_byReference_(f, True)
    if loop:
        sounds[name].setLoops_(True)
Пример #38
0
 def __init__(self, path):
     self.sound = NSSound.alloc()
     self.sound.initWithContentsOfFile_byReference_(path, True)
Пример #39
0
 def _load_player(self):
     return NSSound.alloc().initWithContentsOfFile_byReference_(
         self._filename, True)
Пример #40
0
 def __init__(self, path):
     self.sound = NSSound.alloc()
     self.sound.initWithContentsOfFile_byReference_(path, True)
Пример #41
0
    def start_record(self):

        if self.object1.poorSignal!=0:
            print 'signal is poor'
            self.text.insert(INSERT, 'bad signal\n')
        
        else:
            delta = []
            midgamma = []
            lowgamma = []
            theta = []
            highalpha = []
            lowalpha = []
            highbeta = []
            lowbeta = []

            self.text.insert(INSERT,'\n\n')
            self.text.insert(INSERT, 'progress:'+str(self.progress)+':\n')
            self.text.insert(INSERT, 'question:'+str(self.audio_seq[self.progress])+':\n')
            self.text.see(END)
            print str(self.audio_seq[self.progress])

            sound = NSSound.alloc()
            sound.initWithContentsOfFile_byReference_(str(self.audio_seq[self.progress])+'.mp3', True)
            sound.play()


            for i in range(0,RECORD_TIME):
                if self.object1.poorSignal!=0:
                    print "because signal("+str(self.object1.poorSignal)+") is bad, we skip this round."
                    break
                else:
                    delta.append(self.object1.delta)
                    midgamma.append(self.object1.midGamma)
                    lowgamma.append(self.object1.lowGamma)
                    theta.append(self.object1.theta)
                    highalpha.append(self.object1.highAlpha)
                    lowalpha.append(self.object1.lowAlpha)
                    highbeta.append(self.object1.highBeta)
                    lowbeta.append(self.object1.lowBeta)

                    print 'delta:'+str(self.object1.delta)
                    print 'theta:'+str(self.object1.theta)
                    print 'highalpha:'+str(self.object1.highAlpha)
                    print 'midgamma:'+str(self.object1.midGamma)
                    print 'recording'
                    print self.object1.poorSignal
                    time.sleep(1)

            if len(delta)==RECORD_TIME:
                #print "std(delta)="+str(int(np.std(np.array(delta))))
                #print "std(midgamma)="+str(int(np.std(np.array(midgamma))))
                #print "std(lowgamma)="+str(int(np.std(np.array(lowgamma))))
                #print "std(theta)="+str(int(np.std(np.array(theta))))

                self.row_data.append(delta)
                self.row_data.append(theta)
                self.row_data.append(lowalpha)
                self.row_data.append(highalpha)
                self.row_data.append(lowbeta)
                self.row_data.append(highbeta)
                self.row_data.append(lowgamma)
                self.row_data.append(midgamma)
                
                
                
                
                


                print self.row_data

                self.easy_btn['state']='normal'
                self.hard_btn['state']='normal'
                self.sta_btn['state'] = 'disabled'

            
                #for i in range(0,5):
                #    self.row_data.append(int(np.std(np.array(delta[0:RECORD_TIME-i]))))
                #    self.row_data.append(int(np.std(np.array(midgamma[0:RECORD_TIME-i]))))
                #    self.row_data.append(int(np.std(np.array(lowgamma[0:RECORD_TIME-i]))))
                #    self.row_data.append(int(np.std(np.array(theta[0:RECORD_TIME-i]))))

            sound.stop()
Пример #42
0
 def play(self):
     self.ns_sound = NSSound.alloc()
     self.ns_sound.initWithContentsOfFile_byReference_(self.path, True)
     self.ns_sound.play()
Пример #43
0
#!/usr/bin/env python

## MacOS ѕpecific 
# plays an mp3 file

from AppKit import NSSound

sound = NSSound.alloc()
sound.initWithContentsOfFile_byReference_("/Users/wishi/test.mp3", True)
sound.play()
Пример #44
0
    chr(0),
    chr(0),
    chr(0),
    chr(0),
    chr(0),
    chr(0)
]
for t in o:
    b += t
o = chr(0) * 5512
for n in s:
    t = ''
    g = .125 * h**n
    for y in range(2756):
        v = int(2e4 * sin(g * y))
        t += chr((v & 0xff00) >> 8) + chr(v & 0xff)
    b += t
    b += o
aifff = open('1kintro_macosx.aiff', 'wb')
aifff.write(b)
aifff.close()
sound = NSSound.alloc()
sound.initWithContentsOfFile_byReference_("1kintro_macosx.aiff", True)
try:
    sound.setLoops_(True)
    sound.play()
except AttributeError:
    Thread(target=k).start()
z = time()
glutMainLoop()
Пример #45
0
def main():
		
	# Play a sound
	snd = "paper_shredder.wav"
	#os.system("/Users/aleray//bin/mplayer %s < /dev/tty1 >| ~/error.log" % snd)
	#os.system("/Users/aleray/bin/mplayer %s >| ~/error.log" % snd)
	#os.system("/Applications/VLC.app/Contents/MacOS/VLC -I ncurses %s &" % snd)
	sound = NSSound.alloc()
	sound.initWithContentsOfFile_byReference_('/Users/aleray/Desktop/Paper Shredder.app/Contents/Resources/paper_shredder.wav', True)
	sound.play()
	
	meter = EasyDialogs.ProgressBar('Shredding your file...',
	                                maxval=100,
	                                label='Starting',
	                                )
	for i in xrange(1, 101):
	    phase = '%d %% Completed' % i
	    print phase
	    meter.label(phase)
	    meter.inc()
	    time.sleep(0.01)
	print 'Done with loop'
	time.sleep(1)

	del meter
	print 'The dialog should be gone now'
	
	
	# Nombre de caractères par ligne du fichier original, Nombre de caractère pas ligne des fichiers générés
	nc = 40
	nf = 5
	
	# Récupère le premier argument et le formate
	f = open(sys.argv[1],'r')
	g = f.read()
	f.close()
	g = wrap(g,nc)
	
	# À revoir car supprime n'importe quel type de fichier
	cmd = "rm %s" % sys.argv[1]
	os.system(cmd)
	
	# Récupère le chemin relatif de l'argument sans son extension
	basePath = os.path.splitext(sys.argv[1])[0]
	fileName = os.path.basename(sys.argv[1]).split(".")[0]
	fileExt = os.path.basename(sys.argv[1]).split(".")[1]
	destinationPath = "/Users/aleray/Recycled/Paper Shredder/"
	
	# liste des fichiers généré
	createdDocs = []
	
	# Découpe ligne par ligne le fichier original et cré des "bandes"
	for i in range(nc/nf):
		newContent=""
		for line in g.split("\n"):
		    newContent += line[i*nf:(i*nf)+nf]+"\n"
		newPath = '%s%s_%s.%s' % (destinationPath, fileName, i, fileExt)
		createdDocs.append(newPath)
		newFile = open(newPath, 'w')
		newFile.write(newContent)
	
	te = app('TextEdit')
	te.activate()
	
	for i in range(len(createdDocs)):
		te.open(Alias(createdDocs[i]))
		te.windows[0].bounds.set([100+35*i, 100, 200+35*i, 800])
		
	# fait une petite pause avant de tout refermer
	time.sleep(2)
	
	for window in te.windows.get()[::-1]:
		window.close()
Пример #46
0
def Alarm():
    global list
    end_time1 = input("At what time do you want an alarm?\n(Format 24h: hh:mm:ss)\n>>")
    reminder = input("What's the reminder for?\n>>")
    # --------------------------------------------- #
    # -- Append your reminder in list = [] above -- #
    # --------------------------------------------- #
    all = "Time: " + end_time1 + " Your Reminder is: " + reminder
    list.append(all)
    # ---------------------------------------------------------------------------- #
    # -- Here you append your history to the history file: history_reminder.txt -- #
    # ---------------------------------------------------------------------------- #
    with open("history_reminder.txt", 'a') as output:
        output.write(all + '\n')
            
    Last_reminder = input("Do you want to see your all reminder schedules?\n[yes/no]\n>>")
    if 'yes' in Last_reminder:
        print(list)
        question = input("Are you done?")
        if 'yes' in question:
            pass
    else:
        pass

    its_time = False
    while its_time == False:
        its_time = False
        # ------------------------------------------ #
        # ------ Local Time in your country! ------- #
        # ------------------------------------------ #
        clock = time.localtime()  # get struct_time
        Timer = time.strftime("%a, %b %d %Y, %X%p (%Z)", clock)
        # ------------------------- #
        # ------ Timer Loop ------- #
        # ------------------------- #
        if end_time1 in Timer:
            its_time = True
            print("Your Reminder is:\n(",reminder,")")
            pyttsx3.speak(reminder)  # < ----------------------------------------- Here the script play your reminder text
            # ----------------------------- #
            # ------ Prepare Sounds ------- #
            # ----------------------------- #
            
            # --------------------------------------------- #
            # I couldn't make this part work with Linux so  #
            # just delect this part if you are under linux  #
            # --------------------------------------------- #
            sound = NSSound.alloc()
            sound.initWithContentsOfFile_byReference_(
                'reminder_voice.mp3', True)        # < ------------------------- Here should be your own song.
            sound.play()
            # ----------------------------------------------------------------------------------------------------- #
            # ------ Add 8 seconds time sleep (time the song play for me, you can add more or less for you) ------- #
            # ----------------------------------------------------------------------------------------------------- #
            time.sleep(8)
            while sound.isPlaying():  # < ------------------------------------- Delect this as well if you are under Linux
                another = input("Do you want an other one?\n[yes/no]\n>>") # < ----- Reposition this part is you delect the sound player above
                if another == 'yes':
                    return Alarm()
                else:
                    # -------------------------------------------- #
                    # -- Here you print the history of your day -- #
                    # -------------------------------------------- #
                    print(list)
                    break
            # --------------------------------------------- #
            # ------ Print this until the time out! ------- #
            # --------------------------------------------- #
        else:
            start = time.strftime("%X")
            format = '%H:%M:%S'
            time_left = datetime.strptime(end_time1, format) - datetime.strptime(start, format) # Subtract the time left before end time.
            
            print("Local current time :", Timer)
            print("\tTimer end at: ", end_time1)
            print("\tYour reminder is:", reminder)
            print("\tTime left: ", time_left)
            print("." * 50)
            time.sleep(1)
            os.system('clear')
            its_time = False
Пример #47
0
 def executeCapture(self):
     self.captureView.getSnapshot()
     NSSound.soundNamed_("Grab").play()
Пример #48
0
    def start_record(self):
        if self.progress == 30:
            print 'No more question'
            return 0
        if self.object1.poorSignal!=0:
            print 'signal is poor:'+str(self.object1.poorSignal)
            self.text.insert(INSERT, 'bad signal\n')
            self.sta_btn['state'] = 'normal'
        
        else:
            delta = []
            midgamma = []
            lowgamma = []
            theta = []
            highalpha = []
            lowalpha = []
            highbeta = []
            lowbeta = []

            self.text.insert(INSERT,'\n\n')
            self.text.insert(INSERT, 'progress:'+str(self.progress)+':\n')
            self.text.insert(INSERT, 'question:'+str(self.audio_seq[self.progress])+':\n')
            self.text.see(END)
            print str(self.audio_seq[self.progress])

            sound = NSSound.alloc()
            sound.initWithContentsOfFile_byReference_(str(doc_id)+'-'+str(self.audio_seq[self.progress])+'.mp3', True)
            sound.play()


            for i in range(0,RECORD_TIME):
                if self.object1.poorSignal!=0:
                    print "because signal("+str(self.object1.poorSignal)+") is bad, we skip this round."
                    break
                else:
                    delta.append(self.object1.delta)
                    midgamma.append(self.object1.midGamma)
                    lowgamma.append(self.object1.lowGamma)
                    theta.append(self.object1.theta)
                    highalpha.append(self.object1.highAlpha)
                    lowalpha.append(self.object1.lowAlpha)
                    highbeta.append(self.object1.highBeta)
                    lowbeta.append(self.object1.lowBeta)

                    print 'delta:'+str(self.object1.delta)
                    print 'theta:'+str(self.object1.theta)
                    print 'highalpha:'+str(self.object1.highAlpha)
                    print 'midgamma:'+str(self.object1.midGamma)
                    print 'recording'
                    print self.object1.poorSignal
                    time.sleep(1)
            sound.stop()

            if len(delta)==RECORD_TIME:

                self.row_data.append(delta)
                self.row_data.append(theta)
                self.row_data.append(lowalpha)
                self.row_data.append(highalpha)
                self.row_data.append(lowbeta)
                self.row_data.append(highbeta)
                self.row_data.append(lowgamma)
                self.row_data.append(midgamma)
                print self.row_data
                self.sta_btn['state'] = 'disabled'

                self.difficulty()
            else:
                self.start_record()
Пример #49
0
 def __init__(self, soundFile):
     self.sound = NSSound.alloc()
     try:
         self.sound.initWithContentsOfFile_byReference_(soundFile, True)
     except:
         print 'Error opening sound file: ' + soundFile
Пример #50
0
 def __init__(self):
     self.snd_warn = NSSound.alloc().initWithContentsOfFile_byReference_(os.path.join(os.path.abspath(os.path.dirname(__file__)), 'sounds/snd_warn.wav'), False)
     self.snd_notify = NSSound.alloc().initWithContentsOfFile_byReference_(os.path.join(os.path.abspath(os.path.dirname(__file__)), 'sounds/snd_notify.wav'), False)