def main():

    num_blocks    = 16    # num_blocks * wordsPerBlock should not exceed 512
    wordsPerBlock = 16     # words displayed (both latin and hebrew) per block
    word_lengths = [4, 5, 6]   # character lengths to select from word_list.txt


    #ensure that video mode is at the maxium FPS
    if sys.platform.startswith("linux"):
        from subprocess import call
        call(["xrandr","-r","144"])

    pygame.init()
    pygame.mouse.set_visible(False)

    #get filepath/name for words displayed text file
    if not os.path.isdir("data"):
        os.mkdir("data")
    num = 0
    while True:
        fn = "data/words_displayed_%02d.txt" % num
        if not os.path.isfile(fn):
            break
        num += 1

    #instantiate some objects
    if not SUPRESS_TXT_OUTPUT:
        words_displayed = open(fn, "w")
    FC = FixationCross(color = "black")
    restScreen = Screen(color = "white", fixation_cross = FC)
    blankScreen = Screen(color = "white")
    text = TextDisplay(font_size = 288,
                             font_type = "FreeMono.ttf",
                             screen_bgColor = "white",
                             )

    # get and randomize a list of latin words from the word_list.txt file
    word_list = []
    with neurodot_present.resources.load_wordlist() as list_file:
        for line in list_file.readlines():
            if len(line.rstrip()) in word_lengths:
                word_list.append(line.rstrip().upper())
    random.shuffle(word_list)

    # get list of dictionaries for latin/hebrew words and randomize
    stim_list = []
    for word in word_list[0:num_blocks*wordsPerBlock/2 + 1]:
        vsync_value = len(word) - 3 #words are 4,5,6 letters long
        latin = {'word': word, 'vsync_value': vsync_value}
        hebrew = {'word': code_hebrew(word), 'vsync_value': vsync_value + 3}
        stim_list.append(latin)
        stim_list.append(hebrew)
    random.shuffle(stim_list)

    try:

        #start sequence
        run_start_sequence()
        restScreen.run(duration = 2, vsync_value = 0)

        block = 0
        while block < num_blocks:
            for stim in stim_list[block*wordsPerBlock : block*wordsPerBlock + wordsPerBlock]:

                if not SUPRESS_TXT_OUTPUT:
                    words_displayed.write(stim['word'].encode("utf8") + "\n")

                text.run(text_content = stim['word'],
                         duration = STIMULUS_DURATION,
                         vsync_value = stim['vsync_value']
                         )
                #print text.textSurface.get_width()

                # display blank screen
                blankScreen.run(duration = STIMULUS_DURATION, vsync_value = 0)

            if block < num_blocks-1:

                # add an empty line to text file to signify between trials
                if not SUPRESS_TXT_OUTPUT:
                    words_displayed.write("\n")

                #rest period
                bell()
                restScreen.run(duration = 3, vsync_value = 0)
                bell()
                restScreen.run(duration = random.uniform(1,3), vsync_value = 0)

            block += 1

    except UserEscape as exc:
        print exc
    except:
        print "Unexpected error:"
        raise
    finally:
        if not SUPRESS_TXT_OUTPUT:
            words_displayed.close()

        # stop sequence
        run_stop_sequence()

    pygame.quit()
    sys.exit()
from neurodot_present.present_lib import Screen, FixationCross, CheckerBoardFlasher, bell, UserEscape, run_start_sequence, run_stop_sequence



pygame.init()

TASK_DURATION = 30  #seconds

FC = FixationCross()
try:
    #start sequence
    run_start_sequence()
    #setup task
    CBF = CheckerBoardFlasher(flash_rate=0) #no flashing
    CBF.setup_checkerboard(64)
    black_SCR = Screen(color = "black",fixation_cross = FC)
    #run sequence
    CBF.run(duration = TASK_DURATION, vsync_value = 1)
    black_SCR.run(duration = 1, vsync_value = 0)
    bell()
    black_SCR.run(duration = 5, vsync_value = 0)
    black_SCR.run(duration = TASK_DURATION, vsync_value = 2)
    black_SCR.run(duration = 1, vsync_value = 0)
    bell()
except UserEscape:
    print "User stopped the sequence"
except Exception, err:
    raise err
finally:
    #stop sequence
    run_stop_sequence()
    FC_left = FixationCross(color = 'black', position = (CBF.xL + 0.5*CBF.board_width, 0.0))
    FC_right = FixationCross(color = 'black', position = (CBF.xR + 0.5*CBF.board_width, 0.0))
    aFC_left = AnimatedFixationCross(position_initial = [0,0],
                                     position_final = [CBF.xL + 0.5*CBF.board_width, 0.0],
                                     movement_duration = MOVEMENT_DURATION,
                                     color = 'black',
                                     dt_threshold = 0.0005,
                                     )
    aFC_right = AnimatedFixationCross(position_initial = [0,0],
                                      position_final = [CBF.xR + 0.5*CBF.board_width, 0.0],
                                      movement_duration = MOVEMENT_DURATION,
                                      color = 'black',
                                      dt_threshold = 0.0005,
                                      )

    SCR_rest = Screen(color = 'neutral-gray', fixation_cross = FC_center)
    SCR_left = Screen(color = 'neutral-gray', fixation_cross = FC_left)
    SCR_right = Screen(color = 'neutral-gray', fixation_cross = FC_right)
    aSCR_left = AnimatedScreen(screen_bgColor = 'neutral-gray', sprite_list = [aFC_left])
    aSCR_right = AnimatedScreen(screen_bgColor = 'neutral-gray', sprite_list = [aFC_right])
    aSCR_both = AnimatedScreen(screen_bgColor = 'neutral-gray', sprite_list = [aFC_left, aFC_right])

    stimAttrs = zip(FLASH_RATES_LEFT, FLASH_RATES_RIGHT, VSYNC_VALUES)

    try:
        #start sequence
        run_start_sequence()

        while BLOCKS > 0:
            # get reversal rates and vsync values for this block
            random.shuffle(stimAttrs)
    FLASH_DURATION = 8       #seconds
    PAUSE_DURATION_RANGE = (2.0,5.0)

    FC = FixationCross()

    #CBFs

    try:
        #start sequence
        run_start_sequence()
        #trials
        for b in range(BLOCKS):
            stims = REPITITIONS*zip(FLASH_RATES, VSYNC_VALUES)
            random.shuffle(stims)
            for flash_rate, vsync_value in stims:
                CBF = CheckerBoardFlasher(flash_rate=flash_rate)
                CBF.setup_checkerboard(nrows = CHECKERBOARD_NROWS, show_fixation_dot = True)
                CBF.run(duration = FLASH_DURATION, vsync_value = vsync_value)
                SCR = Screen(color = "black", fixation_cross = FC)
                pause_duration = random.uniform(*PAUSE_DURATION_RANGE)
                SCR.run(duration = pause_duration, vsync_value = 0)
    except UserEscape as exc:
        print exc
    finally:
        #stop sequence
        run_stop_sequence()
    #exit
    print "Exiting the presentation"
    pygame.quit()
    sys.exit()
import neurodot_present.present_lib as pl
from neurodot_present.present_lib import Screen, CheckerBoard, UserEscape, VsyncPatch

pl.DEBUG = False
################################################################################
if __name__ == "__main__":

    pygame.init()
    pygame.mouse.set_visible(True)

    LOOP_MODE = 2  # 2 is using DoubleCheckerboardFlasher loop structure, 1 is using regular CheckerboardFlasher delay
    DURATION = 20
    flash_rate = 19  # Hz
    display_mode = pygame.display.list_modes()[-1]

    scr = Screen(display_mode = display_mode)
    vsync_patch = VsyncPatch(left   = scr.screen_right - pl.VSYNC_PATCH_WIDTH_DEFAULT,
                                      bottom = scr.screen_bottom,
                                      width  = pl.VSYNC_PATCH_WIDTH_DEFAULT,
                                      height = pl.VSYNC_PATCH_HEIGHT_DEFAULT
                                     )
    cb1 = CheckerBoard(1, color1 = [1.0, 1.0, 1.0], color2 = [0.0, 0.0, 0.0], width = 0.5)
    cb2 = CheckerBoard(1, color1 = [0.0, 0.0, 0.0], color2 = [1.0, 1.0, 1.0], width = 0.5)
    CB_cycle = itertools.cycle((cb2, cb1))
    vvals_cycle = itertools.cycle((0, 15))

    try:

        vsync_value = vvals_cycle.next()
        CB = CB_cycle.next()