示例#1
0
文件: pan.py 项目: paulmadore/luckyde
def command_full_up(rect, last_rect, new_img, screen, file, num_imgs, screen_height):
    "scroll image all the way upward to see the very bottom"
    gl.HAND_TOOL = 1
    if rect.bottom > screen_height:
        rect.bottom = screen_height
        screen.blit(new_img, rect)
        update(rect.union(last_rect))
        img_info(screen, gl.files[file], file, num_imgs, new_img, gl.NS_GLOBAL[0])
    drag_hand_cursor()
    return rect
示例#2
0
文件: pan.py 项目: paulmadore/luckyde
def command_full_right(rect, last_rect, new_img, screen, file, num_imgs):
    "scroll image to all the way to the right to see the very left side"
    gl.HAND_TOOL = 1
    if rect.left < 0:
        rect.left = 0
        screen.blit(new_img, rect)
        update(rect.union(last_rect))
        img_info(screen, gl.files[file], file, num_imgs, new_img, gl.NS_GLOBAL[0])
    drag_hand_cursor()
    return rect 
示例#3
0
文件: pan.py 项目: paulmadore/luckyde
def command_full_down(rect, last_rect, new_img, screen, file, num_imgs):
    "scroll image to all the way downward to see the very top"
    gl.HAND_TOOL = 1
    if rect.top < 0:
        rect.top = 0
        screen.blit(new_img, rect)
        update(rect.union(last_rect))
        img_info(screen, gl.files[file], file, num_imgs, new_img, gl.NS_GLOBAL[0])
    drag_hand_cursor()
    return rect
示例#4
0
文件: imgv.py 项目: rkulla/imgv
    def start(self):
        # start with menu open
        self.gfx = command_main_menu(self.gfx)

        # main loop
        while 1:
            self.event = pygame.event.poll()
            pygame.time.wait(1)  # so pygame doesn't use 100% CPU
            cursor = pygame.mouse.get_pos()
            self.last_rect = Rect(self.gfx['rect'])

            # drag image code:
            if gl.HAND_TOOL:
                if left_click(self.event):  # calculate drag coordinates:
                    if gl.IMG_BORDER:
                        self.border_fix()  # erase the current border
                    grab_hand_cursor()
                    self.minus1 = cursor[0] - self.gfx['rect'][0]
                    self.minus2 = cursor[1] - self.gfx['rect'][1]
                    gl.DO_DRAG = 1
                if self.event.type == MOUSEMOTION and gl.DO_DRAG:  # move the image when dragged:
                    grab_hand_cursor()
                    self.gfx['rect'][0] = cursor[0] - self.minus1
                    self.gfx['rect'][1] = cursor[1] - self.minus2
                    self.gfx['screen'].fill(gl.IMGV_COLOR, self.last_rect)
                    self.gfx['screen'].blit(self.gfx['new_img'], self.gfx['rect'])
                    update(self.gfx['rect'].union(self.last_rect))
                if self.event.type == MOUSEBUTTONUP:  # released mouse button, redisplay status bars:
                    drag_hand_cursor()
                    my_update_screen(self.gfx['new_img'], self.gfx['rect'], self.gfx['file'])
                    gl.DO_DRAG = 0

            if self.event.type == VIDEORESIZE:
                self.gfx['screen'] = pygame.display.set_mode(self.event.dict['size'], RESIZABLE)
                self.gfx['rect'] = get_center(self.gfx['screen'], self.gfx['new_img'])
                my_update_screen(self.gfx['new_img'], self.gfx['rect'], self.gfx['file'])
            if self.event.type == KEYDOWN:
                gl.HAND_TOOL = 0
                if self.event.key not in (K_DOWN, K_UP, K_RIGHT, K_LEFT):
                    normal_cursor()  # stop displaying hand tool
                (self.gfx, self.last_rect) = handle_keyboard(self.event, self.gfx, self.last_rect)
            if self.event.type == KEYUP:
                self.stop_auto_repeat()
            check_quit(self.event)

            if self.event.type == MOUSEBUTTONDOWN and right_click(self.event):
                self.open_main_menu()

            # Re-open the purposely closed window that frees up RAM
            if (gl.KEEP_MENU_OPEN == "1" and gl.COUNT_CLICKS == 1) or gl.JUST_RESIZED:
                gl.COUNT_CLICKS = 0
                gl.JUST_RESIZED = 0
                self.gfx = command_main_menu(self.gfx)

            self.start_auto_repeat()
示例#5
0
文件: pan.py 项目: rkulla/imgv
def command_full_left(rect, last_rect, new_img, file):
    "scroll image to all the way to the left to see the very right side"
    screen = get_surface()
    screen_width = screen.get_width()
    gl.HAND_TOOL = 1
    if rect.right > screen_width:
        rect.right = screen_width
        screen.blit(new_img, rect)
        update(rect.union(last_rect))
        img_info(gl.files[file], file, new_img, gl.NS_GLOBAL[0])
    drag_hand_cursor()
    return rect
示例#6
0
文件: pan.py 项目: paulmadore/luckyde
def command_left(rect, last_rect, new_img, screen, file, num_imgs, screen_width):
    "scroll image to the left to see more of its right side"
    if (rect.right - screen_width <= gl.MOVE) and rect.right  > screen_width:
        rect.right = screen_width # snap
        screen.blit(new_img, rect)
        update(rect.union(last_rect))
        img_info(screen, gl.files[file], file, num_imgs, new_img, gl.NS_GLOBAL[0])
    elif (rect.right - gl.MOVE) > screen_width:
        rect.right -= gl.MOVE
        screen.blit(new_img, rect)
        update(rect.union(last_rect))
        img_info(screen, gl.files[file], file, num_imgs, new_img, gl.NS_GLOBAL[0])
    drag_hand_cursor()
    return rect 
示例#7
0
文件: pan.py 项目: paulmadore/luckyde
def command_right(rect, last_rect, new_img, screen, file, num_imgs):
    "scroll image to the right to see more of its left side"
    if 0 - rect.left <= gl.MOVE:
        rect.left = 0 # snap
        screen.blit(new_img, rect)
        update(rect.union(last_rect))
        img_info(screen, gl.files[file], file, num_imgs, new_img, gl.NS_GLOBAL[0])
    elif (rect.left + gl.MOVE) < 0:
        rect.left += gl.MOVE
        screen.blit(new_img, rect)
        update(rect.union(last_rect))
        img_info(screen, gl.files[file], file, num_imgs, new_img, gl.NS_GLOBAL[0])
    drag_hand_cursor()
    return rect 
示例#8
0
文件: pan.py 项目: paulmadore/luckyde
def command_down(rect, last_rect, new_img, screen, file, num_imgs):
    "scroll image to downward to see more of the top"
    gl.HAND_TOOL = 1
    if (0 - rect.top <= gl.MOVE):
        rect.top = 0
        screen.blit(new_img, rect)
        update(rect.union(last_rect))
        img_info(screen, gl.files[file], file, num_imgs, new_img, gl.NS_GLOBAL[0])
    elif (rect.top + gl.MOVE) < 0:
        rect.top += gl.MOVE
        screen.blit(new_img, rect)
        update(rect.union(last_rect))
        img_info(screen, gl.files[file], file, num_imgs, new_img, gl.NS_GLOBAL[0])
    drag_hand_cursor()
    return rect
示例#9
0
文件: pan.py 项目: paulmadore/luckyde
def command_up(rect, last_rect, new_img, screen, file, num_imgs, screen_height):
    "scroll image upward to see more of the bottom"
    gl.HAND_TOOL = 1
    if (rect.bottom - screen_height <= gl.MOVE) and rect.bottom  > screen_height:
        rect.bottom = screen_height # snap
        screen.blit(new_img, rect)
        update(rect.union(last_rect))
        img_info(screen, gl.files[file], file, num_imgs, new_img, gl.NS_GLOBAL[0])
    elif (rect.bottom - gl.MOVE) > screen_height:
        rect.bottom -= gl.MOVE
        screen.blit(new_img, rect)
        update(rect.union(last_rect))
        img_info(screen, gl.files[file], file, num_imgs, new_img, gl.NS_GLOBAL[0])
    drag_hand_cursor()
    return rect
示例#10
0
def command_main_menu(refresh_img, screen, file, num_imgs, rect, new_img, img, new_img_width, new_img_height, ns):
    menu_items = []
    i = 23
    cursor = pygame.mouse.get_pos()
    screen_width = screen.get_width()
    screen_height = screen.get_height()
    if screen_height < 600:
        font_size = 10
        gl.MENU_DIVIDER_AMOUNT = 12
    else:
        gl.MENU_DIVIDER_AMOUNT = 14
        font_size = 11
    font = pygame.font.Font(gl.FONT_NAME, font_size)
    font.set_bold(1)
    if gl.MENU_POS == -1:
        gl.MENU_POS = cursor[0]
    main_menu_fg(screen, font, i, menu_items)
    normal_cursor()
    last_rect = Rect(rect)
    new_img_width = new_img.get_width()
    new_img_height = new_img.get_height()
    if gl.REMOTE and not gl.ALREADY_DOWNLOADED:
        download_rect = imgv_button(screen, " Downlo(a)d Image ", None, None, "topright")
    while 1:
        event = pygame.event.poll()
        pygame.time.wait(1)
        check_quit(event)
        cursor2 = pygame.mouse.get_pos()

        if event.type == VIDEORESIZE:#
            gl.JUST_RESIZED = 1
            screen = pygame.display.set_mode(event.dict['size'], RESIZABLE)
            rect = get_center(screen, new_img)
            my_update_screen(new_img, screen, rect, file, len(gl.files))
            return (refresh_img, screen, file, num_imgs, new_img, img, new_img_width, new_img_height, rect)
        if gl.REMOTE and not gl.ALREADY_DOWNLOADED:
            hover_button(download_rect, cursor2, screen, " Downlo(a)d Image ", None, None, "topright")

        if event.type == KEYDOWN:
            if event.key in (K_c, K_h, K_UP, K_DOWN, K_RIGHT, K_LEFT):
                if event.key != K_c:
                    pygame.event.set_allowed(MOUSEMOTION)
                    gl.HAND_TOOL = 1
                    drag_hand_cursor()
                # close the menu
                gl.MENU_POS = -1
                my_update_screen(new_img, screen, rect, file, len(gl.files))
                if event.key == K_c:
                    normal_cursor()
                return (refresh_img, screen, file, num_imgs, new_img, img, new_img_width, new_img_height, rect)
            
            (screen, rect, new_img, img, refresh_img, file, num_imgs,\
            screen_width, screen_height, new_img_width, new_img_height, last_rect) =\
            handle_keyboard(event, screen, rect, new_img, img, refresh_img, file, len(gl.files),\
            screen_width, screen_height, new_img_width, new_img_height, last_rect, ns)
            break
        hover_cursor(cursor2, [x[0] for x in menu_items])
        if left_click(event):
            if gl.REMOTE and not gl.ALREADY_DOWNLOADED:
                if download_rect.collidepoint(cursor2):
                    wait_cursor()
                    save_remote_img(screen, file)
                    break
            for it in menu_items:
                if it[0].collidepoint(cursor2):
                    if it[1] == " Next Image ": 
                        (new_img, img, refresh_img, file, rect) = command_next_img(new_img, screen, file, len(gl.files), rect)
                    elif it[1] == " Previous Image ":
                        (new_img, img, refresh_img, file, rect) = command_prev_img(new_img, screen, file, len(gl.files), rect)        
                    elif it[1] == " Directory Browser ":
                        gl.USING_SCROLL_MENU = 1
                        # save current things in case the user ESCAPES out of show_dirs()
                        gl.LAST_DIR = getcwd()
                        last_files = gl.files
                        (last_new_img, last_img, last_refresh_img, last_num_imgs, last_file, last_rect) =\
                        (new_img, img, refresh_img, num_imgs, file, rect)
                        (new_img, img, refresh_img, num_imgs, file, rect) = command_show_dirs(new_img, img, screen, rect,\
                        file, num_imgs)
                        # user ESCAPED from show_dirs, reset last values
                        if gl.ESCAPED:
                            (new_img, img, refresh_img, num_imgs, file, rect) =\
                            (last_new_img, last_img, last_refresh_img, last_num_imgs, last_file, last_rect)
                            chdir(gl.LAST_DIR)
                            gl.files = last_files
                            gl.USING_SCROLL_MENU = 0
                            my_update_screen(new_img, screen, rect, file, num_imgs)
                        else:
                            gl.REFRESH_IMG_COUNT = 0
                        gl.ESCAPED = 0
                        gl.USING_SCROLL_MENU = 0
                    elif it[1] == " Image Browser ":
                        (new_img, img, refresh_img, file, rect) = command_img_names(screen, new_img, img, file,\
                        num_imgs, rect)
                    elif it[1] == " Thumbnails ":
                        gl.THUMBING = 1
                        gl.CALC_ZOOM = 0
                        zoom_percent = gl.CURRENT_ZOOM_PERCENT
                        real_width = gl.REAL_WIDTH
                        (new_img, img, refresh_img, file, rect) = command_thumbs(screen, new_img, file, ns)
                        if gl.ESCAPED:
                            gl.CURRENT_ZOOM_PERCENT = zoom_percent
                            gl.REAL_WIDTH = real_width
                        gl.ESCAPED = 0
                        gl.THUMBING = 0
                        my_update_screen(new_img, screen, rect, file, num_imgs)
                    elif it[1] == " Image Properties ":
                        transparency = 0
                        if not gl.TOGGLE_TRANSPARENT:
                            gl.TOGGLE_TRANSPARENT = 1
                            transparency = 1
                        command_verbose_info(screen, new_img, rect, file, num_imgs)
                        if transparency:
                            gl.TOGGLE_TRANSPARENT = 0
                        my_update_screen(new_img, screen, rect, file, num_imgs)
                    elif it[1] == " Zoom Out ":
                        if int(gl.N_MILLISECONDS) < gl.MAX_ZOOM_MAX_MS and gl.CURRENT_ZOOM_PERCENT< gl.ZOOM_PERCENT_MAX:
                            try:
                                (new_img, img, rect) = command_zoom_out(new_img, new_img_width, new_img_height, img, screen, file, num_imgs, rect, "normal")
                            except:
                                print 'Out of memory.'
                        else:
                            print "Can't zoom out. Out of memory. Resetting the image."
                            gl.SKIP_FIT = 1
                            gl.ZOOM_EXP = 0
                            start = start_timer()
                            wait_cursor()
                            new_img = load_img(gl.files[file], screen)
                            img = refresh_img = new_img
                            rect = get_center(screen, new_img)
                            ns = check_timer(start)
                            my_update_screen(new_img, screen, rect, file, num_imgs, ns)
                            normal_cursor()
                            gl.N_MILLISECONDS = "0" 
                    elif it[1] == " Zoom In ":
                        if int(gl.N_MILLISECONDS) < gl.MAX_ZOOM_MAX_MS and gl.CURRENT_ZOOM_PERCENT < gl.ZOOM_PERCENT_MAX:
                            try: # triple zoom crash protection
                                (new_img, img, rect) = command_zoom_in(new_img, new_img_width, new_img_height, img, screen, gl.files, file, num_imgs, rect, "normal")
                            except:
                                print 'Zoom max reached.'
                        else:
                            print 'Zoom max reached.'
                    elif it[1] == " Fit to Window ":
                        gl.RESET_FIT = 0
                        gl.SCALE_UP = 1
                        if gl.FIT_IMAGE_VAL:
                            gl.RESET_FIT = 0
                        else:
                            gl.RESET_FIT = 1
                            gl.FIT_IMAGE_VAL = 1
                        start = start_timer()
                        wait_cursor()
                        new_img = load_img(gl.files[file], screen)
                        img = refresh_img = new_img
                        rect = get_center(screen, new_img)
                        ns = check_timer(start)
                        my_update_screen(new_img, screen, rect, file, num_imgs, ns)
                        if gl.RESET_FIT == 1:
                            gl.FIT_IMAGE_VAL = 0
                        normal_cursor()
                    elif it[1] == " Lock Zoom ":
                        gl.PERSISTENT_ZOOM_VAL ^= 1
                        if not gl.PERSISTENT_ZOOM_VAL:
                            gl.ZOOM_EXP = 0
                        my_update_screen(new_img, screen, rect, file, num_imgs, ns)
                    elif it[1] == " Actual Size ":
                        gl.SKIP_FIT = 1
                        gl.ZOOM_EXP = 0
                        start = start_timer()
                        wait_cursor()
                        new_img = load_img(gl.files[file], screen)
                        img = refresh_img = new_img
                        rect = get_center(screen, new_img)
                        ns = check_timer(start)
                        my_update_screen(new_img, screen, rect, file, num_imgs, ns)
                        normal_cursor()
                    elif it[1] == " Close Image ":
                        (new_img, img, refresh_img, file, num_imgs, rect) = command_remove_img(new_img, screen, file, rect)
                    elif it[1] == " Rotate Right ":
                        if int(gl.N_MILLISECONDS) < gl.MAX_ZOOM_MAX_MS and gl.CURRENT_ZOOM_PERCENT < gl.ZOOM_PERCENT_MAX:
                            gl.CALC_ZOOM = 0
                            (new_img, img, rect) = command_rotate_right(new_img, screen, file, num_imgs, rect)
                        else:
                            print "Can't rotate. Out of memory."
                    elif it[1] == " Rotate Left ":
                        if int(gl.N_MILLISECONDS) < gl.MAX_ZOOM_MAX_MS and gl.CURRENT_ZOOM_PERCENT < gl.ZOOM_PERCENT_MAX:
                            gl.CALC_ZOOM = 0
                            (new_img, img, rect) = command_rotate_left(new_img, screen, file, num_imgs, rect)
                        else:
                            print "Can't rotate. Out of memory."
                    elif it[1] == " Four at a Time ":
                        gl.CALC_ZOOM = 0
                        zoom_percent = gl.CURRENT_ZOOM_PERCENT
                        real_width = gl.REAL_WIDTH
                        (file, new_img, img, refresh_img, rect) = command_four(screen, file, new_img, ns)
                        if gl.ESCAPED:
                            gl.CURRENT_ZOOM_PERCENT = zoom_percent
                            gl.REAL_WIDTH = real_width
                        gl.ESCAPED = 0
                        my_update_screen(new_img, screen, rect, file, num_imgs)
                        normal_cursor()
 #                   elif it[1] == " Resize Options ":##
 #                       gl.USING_SCROLL_MENU = 1
 #                       gl.CALC_ZOOM = 0
 #                       zoom_percent = gl.CURRENT_ZOOM_PERCENT
 #                       real_width = gl.REAL_WIDTH
 #                       rect = command_show_res_modes(screen, new_img, file, num_imgs, rect)
 #                       gl.CURRENT_ZOOM_PERCENT = zoom_percent
 #                       gl.REAL_WIDTH = real_width
 #                       gl.USING_SCROLL_MENU = 0
                    elif it[1] == " Refresh ":
                        (new_img, img, rect, file) = command_refresh(refresh_img, screen, gl.files, file, num_imgs)
                    elif it[1] == " First Image ":
                        (new_img, img, refresh_img, file, rect) = command_first_img(new_img, screen, file, len(gl.files), rect)
                    elif it[1] == " Last Image ":
                        (new_img, img, refresh_img, file, rect) = command_last_img(new_img, screen, file, len(gl.files), rect)
                    elif it[1] == " Shuffle ":
                        (new_img, img, refresh_img, rect) = command_shuffle(new_img, img, screen, rect, file, num_imgs)
                    elif it[1] == " Unshuffle ":
                        (new_img, img, refresh_img, rect, file) = command_unshuffle(new_img, img, screen, rect, file, num_imgs)
                    elif it[1] == " Flip Horizontal ":
                        (new_img, img, rect) = command_horiz(new_img, screen, file, num_imgs, rect)
                    elif it[1] == " Flip Vertical ":
                        (new_img, img, rect) = command_vert(new_img, screen, file, num_imgs, rect)
                    elif it[1] == " Slideshow ":
                        (new_img, img, refresh_img, file, rect) = my_slideshow(new_img, img, screen, file, num_imgs, rect)
                        my_update_screen(new_img, screen, rect, file, len(gl.files))
                    elif it[1] == " Playlists ":
                        (new_img, new_img, new_img, file, rect, num_imgs) = command_play_list_options(screen, file)
                        gl.SORT_HIT = 0
                    elif it[1] == " Add to Playlist ":
                        command_add_to_play_list(screen, gl.files[file])
                        gl.SORT_HIT = 0
                        my_update_screen(new_img, screen, rect, file, len(gl.files))
                    elif it[1] == " Edit ":
                        (screen, before_winsize, not_accepted) = adjust_screen(screen)
                        gl.USING_SCROLL_MENU = 1
                        (new_img, img, refresh_img, file, num_imgs, rect) = command_edit_menu(screen, file, new_img, num_imgs, rect)
                        screen = restore_screen(screen, before_winsize, not_accepted, new_img, file, num_imgs, rect)
                        my_update_screen(new_img, screen, rect, file, num_imgs)
                        gl.USING_SCROLL_MENU = 0
                    elif it[1] == " Hide Image ":
                        command_hide(screen, new_img, rect, file, num_imgs)
                    elif it[1] == " Extract from Web ":
                        (screen, before_winsize, not_accepted) = adjust_screen(screen)
                        (new_img, num_imgs) = open_url(screen, img)
                        gl.URL_ERROR = False
                        file = 0
                        img = refresh_img = new_img
                        screen = restore_screen(screen, before_winsize, not_accepted, new_img, file, num_imgs, rect)
                        rect = get_center(screen, new_img)
                        my_update_screen(new_img, screen, rect, file, len(gl.files))
                        normal_cursor()
                    elif it[1] == " Help ":
                        gl.CALC_ZOOM = 0
                        zoom_percent = gl.CURRENT_ZOOM_PERCENT
                        real_width = gl.REAL_WIDTH
                        command_help(screen, new_img, file, rect, num_imgs)
                        if gl.ESCAPED:
                            gl.CURRENT_ZOOM_PERCENT = zoom_percent
                            gl.REAL_WIDTH = real_width
                        gl.ESCAPED = 0
                    elif it[1] == " Close Menu " or it[1] == " Hand Tool ":
                        if it[1] == " Hand Tool ":
                            pygame.event.set_allowed(MOUSEMOTION)
                            gl.HAND_TOOL = 1
                            drag_hand_cursor()
                        gl.MENU_POS = -1
                        my_update_screen(new_img, screen, rect, file, len(gl.files))
                        normal_cursor()
                        return (refresh_img, screen, file, num_imgs, new_img, img, new_img_width, new_img_height, rect)
                    elif it[1] == " Exit ":
                        clean_screen()
                        raise SystemExit
            break
        if event.type == KEYDOWN and event.key not in (K_LALT, K_RALT, K_LCTRL, K_RCTRL, K_TAB):
            return (refresh_img, screen, file, num_imgs, new_img, img, new_img_width, new_img_height, rect)
        if middle_click(event):
            "close the menu upon middle click"
            gl.MENU_POS = -1
            my_update_screen(new_img, screen, rect, file, len(gl.files))
            normal_cursor()
            return (refresh_img, screen, file, num_imgs, new_img, img, new_img_width, new_img_height, rect)
        if right_click(event):
            wait_cursor()
            gl.MENU_POS = -1
            my_update_screen(new_img, screen, rect, file, len(gl.files))
            (refresh_img, screen, file, num_imgs, new_img, img, new_img_width, new_img_height, rect) =\
            command_main_menu(refresh_img, screen, file, num_imgs, rect, new_img, img, new_img_width, new_img_height, ns)
            return (refresh_img, screen, file, num_imgs, new_img, img, new_img_width, new_img_height, rect)

        if event.type == MOUSEBUTTONDOWN: # this needs to be down here to work
            if event.dict['button'] in (4, 5): # scroll wheel activated
                # allow for mouse dragging:
                pygame.event.set_allowed(MOUSEMOTION) 
                gl.HAND_TOOL = 1
                drag_hand_cursor()
                # close menu:
                gl.MENU_POS = -1 
                my_update_screen(new_img, screen, rect, file, len(gl.files))
                return (refresh_img, screen, file, num_imgs, new_img, img, new_img_width, new_img_height, rect)
 

    if gl.KEEP_MENU_OPEN == "1":
        # this code purposely closes the main menu by breaking the recursion to free up RAM memory
        gl.COUNT_CLICKS += 1
        if gl.COUNT_CLICKS == 1: # free up ram every click
            return (refresh_img, screen, file, num_imgs, new_img, img, new_img_width, new_img_height, rect)
        (refresh_img, screen, file, num_imgs, new_img, img, new_img_width, new_img_height, rect) =\
        command_main_menu(refresh_img, screen, file, num_imgs, rect, new_img, img, new_img_width, new_img_height, ns)
    normal_cursor()
    return (refresh_img, screen, file, num_imgs, new_img, img, new_img_width, new_img_height, rect)
示例#11
0
def handle_keyboard(event, gfx, last_rect):
    screen = gfx['screen']
    rect = gfx['rect']
    new_img = gfx['new_img']
    img = gfx['img']
    refresh_img = gfx['refresh_img']
    file = gfx['file']

    if hit_key(event, K_d):
        gl.USING_SCROLL_MENU = 1
        # save current things in case the user ESCAPES out of show_dirs()
        gl.LAST_DIR = getcwd()
        last_files = gl.files
        (last_new_img, last_img, last_refresh_img, last_file,
         last_rect) = (new_img, img, refresh_img, file, rect)
        (new_img, img, refresh_img, file,
         rect) = command_show_dirs(new_img, img, screen, rect, file)
        # user ESCAPED from show_dirs, reset last values
        if gl.ESCAPED:
            gl.ADDED_DIR_NUMS = 0
            (new_img, img, refresh_img, file, rect) = (last_new_img,
                                                       last_img, last_refresh_img, last_file, last_rect)
            chdir(gl.LAST_DIR)
            gl.files = last_files
            gl.USING_SCROLL_MENU = 0
            my_update_screen(new_img, rect, file)
        else:
            gl.REFRESH_IMG_COUNT = 0
        gl.ESCAPED = 0
        gl.USING_SCROLL_MENU = 0
    if hit_key(event, K_i):
        (new_img, img, refresh_img, file, rect) = command_img_names(screen, new_img, img, file, rect)
    if hit_key(event, K_F1):
        gl.CALC_ZOOM = 0
        zoom_percent = gl.CURRENT_ZOOM_PERCENT
        real_width = gl.REAL_WIDTH
        command_help(screen, new_img, file, rect)
        if gl.ESCAPED:
            gl.CURRENT_ZOOM_PERCENT = zoom_percent
            gl.REAL_WIDTH = real_width
        gl.ESCAPED = 0
    if hit_key(event, K_F2):
        rect = command_640x480(new_img, file, rect)
        normal_cursor()
    if hit_key(event, K_F3):
        rect = command_800x600(new_img, file, rect)
        normal_cursor()
    if hit_key(event, K_F4):
        rect = command_1024x768(new_img, file, rect)
        normal_cursor()
    if hit_key(event, K_F5):
        rect = command_1280x1024(new_img, file, rect)
        normal_cursor()
    if hit_key(event, K_F6):
        screen = command_fullscreen()
        rect = get_center(screen, new_img)
        my_update_screen(new_img, rect, file)
        normal_cursor()
    if event.type == KEYDOWN:  # alt+enter code
        mods = pygame.key.get_mods()
        if ((event.key == K_RETURN and mods & KMOD_ALT)):
            screen = command_fullscreen()
            rect = get_center(screen, new_img)
            my_update_screen(new_img, rect, file)
    if hit_key(event, K_F7):
        gl.USING_SCROLL_MENU = 1
        gl.CALC_ZOOM = 0
        zoom_percent = gl.CURRENT_ZOOM_PERCENT
        real_width = gl.REAL_WIDTH
        rect = command_show_res_modes(screen, new_img, file, rect)
        gl.CURRENT_ZOOM_PERCENT = zoom_percent
        gl.REAL_WIDTH = real_width
        gl.USING_SCROLL_MENU = 0
        my_update_screen(new_img, rect, file)
        normal_cursor()
    if hit_key(event, K_s):
        (new_img, img, refresh_img, rect) = command_shuffle(
            new_img, img, screen, rect, file)
    if hit_key(event, K_u):
        (new_img, img, refresh_img, rect,
         file) = command_unshuffle(new_img, img, screen, rect, file)
    if event.type == KEYDOWN:
        mods = pygame.key.get_mods()
        if event.key == K_r and mods & KMOD_CTRL == 0:
            if gl.CURRENT_ZOOM_PERCENT < gl.ZOOM_PERCENT_MAX:
                gl.CALC_ZOOM = 0
                (new_img, img, rect) = command_rotate_right(new_img, screen, file, rect)
            else:
                print "Can't rotate. Out of memory."
    if event.type == KEYDOWN:
        mods = pygame.key.get_mods()
        if event.key == K_r and mods & KMOD_CTRL:
            if gl.CURRENT_ZOOM_PERCENT < gl.ZOOM_PERCENT_MAX:
                gl.CALC_ZOOM = 0
                (new_img, img, rect) = command_rotate_left(new_img, screen, file, rect)
            else:
                print "Can't rotate. Out of memory."
    if event.type == KEYDOWN:
        mods = pygame.key.get_mods()
        if event.key == K_p and mods & KMOD_CTRL == 0:
            command_add_to_play_list(screen, gl.files[file])
            gl.SORT_HIT = 0
            my_update_screen(new_img, rect, file)
    if event.type == KEYDOWN:
        mods = pygame.key.get_mods()
        if event.key == K_p and mods & KMOD_CTRL:
            (new_img, new_img, new_img, file, rect) = command_play_list_options(screen, file)
            gl.SORT_HIT = 0
    if event.type == KEYDOWN:
        mods = pygame.key.get_mods()
        if event.key == K_x and mods & KMOD_CTRL == 0:
            command_hide(screen, new_img, rect, file)
    if event.type == KEYDOWN:
        mods = pygame.key.get_mods()
        if event.key == K_x and mods & KMOD_CTRL:
            if get_config_val("ON_THE_FLY_EXIF_STATUS_BAR") == 1:
                gl.ON_FLY_EXIF_STATUS_BAR ^= 1
            gl.TOGGLE_STATUS_BAR ^= 1
            my_update_screen(new_img, rect, file)
            normal_cursor()
    if event.type == KEYDOWN:
        mods = pygame.key.get_mods()
        if (event.key == K_MINUS or event.key == K_KP_MINUS) and mods & KMOD_CTRL == 0:
            if gl.CURRENT_ZOOM_PERCENT < gl.ZOOM_PERCENT_MAX:
                try:
                    (new_img, img, rect) = command_zoom_out(new_img, img, file, rect, "normal")
                except:
                    print 'Out of memory.'
            else:
                print "Can't zoom out. Out of memory. Resetting the image."
                gl.SKIP_FIT = 1
                gl.ZOOM_EXP = 0
                wait_cursor()
                new_img = load_img(gl.files[file])
                img = refresh_img = new_img
                rect = get_center(screen, new_img)
                my_update_screen(new_img, rect, file)
                normal_cursor()
    if event.type == KEYDOWN:
        mods = pygame.key.get_mods()
        if (event.key == K_MINUS or event.key == K_KP_MINUS) and mods & KMOD_CTRL:
            try:
                (new_img, img, rect) = command_zoom_out(new_img, img, file, rect, "double")
            except:
                print 'Out of memory.'
    if event.type == KEYDOWN:
        mods = pygame.key.get_mods()
        if (event.key == K_EQUALS or event.key == K_KP_PLUS) and mods & KMOD_CTRL == 0:
            # Zoom in only if there seems to be enough memory
            if gl.CURRENT_ZOOM_PERCENT < gl.ZOOM_PERCENT_MAX:
                try:  # triple zoom crash protection
                    (new_img, img, rect) = command_zoom_in(new_img, img, file, rect, "normal")
                except:
                    print 'Zoom max reached.'
            else:
                print 'Zoom max reached.'
    if event.type == KEYDOWN:  # ctrl+'+' code
        mods = pygame.key.get_mods()
        if (event.key == K_EQUALS or event.key == K_KP_PLUS) and (mods & KMOD_CTRL and mods & KMOD_ALT == 0):
            if gl.CURRENT_ZOOM_PERCENT < gl.ZOOM_PERCENT_MAX:
                try:
                    (new_img, img, rect) = command_zoom_in(new_img, img, file, rect, "double")
                except:
                    print 'Zoom max reached.'
            else:
                print 'Zoom max reached.'
    if event.type == KEYDOWN:
        mods = pygame.key.get_mods()
        if (event.key == K_EQUALS or event.key == K_KP_PLUS) and (mods & KMOD_CTRL and mods & KMOD_ALT):
            try:
                (new_img, img, rect) = command_zoom_in(new_img, new_img, file, rect, "scale2x")
            except:
                print 'Zoom max. Out of memory.'
    if hit_key(event, K_DOWN):
        pygame.event.set_allowed(MOUSEMOTION)
        gl.MY_KEYDOWN = 1
        gl.HAND_TOOL = 1
    if hit_key(event, K_UP):
        pygame.event.set_allowed(MOUSEMOTION)
        gl.MY_KEYUP = 1
        gl.HAND_TOOL = 1
    if hit_key(event, K_RIGHT):
        pygame.event.set_allowed(MOUSEMOTION)
        gl.MY_KEYRIGHT = 1
        gl.HAND_TOOL = 1
    if hit_key(event, K_LEFT):
        pygame.event.set_allowed(MOUSEMOTION)
        gl.MY_KEYLEFT = 1
        gl.HAND_TOOL = 1
    if hit_key(event, K_HOME):
        pygame.event.set_allowed(MOUSEMOTION)
        command_full_right(rect, last_rect, new_img, file)
        if gl.IMG_BORDER:
            img_border(new_img, rect)
    if hit_key(event, K_END):
        pygame.event.set_allowed(MOUSEMOTION)
        command_full_left(rect, last_rect, new_img, file)
        if gl.IMG_BORDER:
            img_border(new_img, rect)
    if hit_key(event, K_PAGEDOWN):
        pygame.event.set_allowed(MOUSEMOTION)
        command_full_up(rect, last_rect, new_img, file)
        if gl.IMG_BORDER:
            img_border(new_img, rect)
    if hit_key(event, K_PAGEUP):
        pygame.event.set_allowed(MOUSEMOTION)
        command_full_down(rect, last_rect, new_img, file)
        if gl.IMG_BORDER:
            img_border(new_img, rect)
    if hit_key(event, K_m):
        (new_img, img, rect) = command_horiz(new_img, screen, file, rect)
    if hit_key(event, K_v):
        (new_img, img, rect) = command_vert(new_img, screen, file, rect)
    if event.type == KEYDOWN:
        mods = pygame.key.get_mods()
        if (event.key == K_TAB and mods & KMOD_CTRL) or hit_key(event, K_SPACE) or\
                hit_key(event, K_n):
            (new_img, img, refresh_img, file,
             rect) = command_next_img(new_img, screen, file, rect)
    if event.type == KEYDOWN:
        mods = pygame.key.get_mods()
        if (hit_key(event, K_BACKSPACE) or hit_key(event, K_b)) and mods & KMOD_CTRL == 0:
            (new_img, img, refresh_img, file,
             rect) = command_prev_img(new_img, screen, file, rect)
    if event.type == KEYDOWN:
        mods = pygame.key.get_mods()
        if event.key == K_b and mods & KMOD_CTRL:
            gl.IMG_BORDER ^= 1
            my_update_screen(new_img, rect, file)
            normal_cursor()
    if hit_key(event, K_o):
        (screen, before_winsize, not_accepted) = adjust_screen(screen)
        new_img = open_url(screen, img)
        gl.URL_ERROR = False
        file = 0
        img = refresh_img = new_img
        screen = restore_screen(
            screen, before_winsize, not_accepted, new_img, file, rect)
        rect = get_center(screen, new_img)
        my_update_screen(new_img, rect, file)
        normal_cursor()
    if hit_key(event, K_ESCAPE):
        (new_img, img, rect, file) = command_refresh(refresh_img, screen, gl.files, file)
        my_update_screen(new_img, rect, file)
    if event.type == KEYDOWN:  # Ctrl+0 (Fit to Window) code
        mods = pygame.key.get_mods()
        if event.key == K_0 and mods & KMOD_CTRL:
            gl.RESET_FIT = 0
            gl.SCALE_UP = 1
            if gl.FIT_IMAGE_VAL:
                gl.RESET_FIT = 0
            else:
                gl.RESET_FIT = 1
                gl.FIT_IMAGE_VAL = 1
            wait_cursor()
            new_img = load_img(gl.files[file])
            img = refresh_img = new_img
            rect = get_center(screen, new_img)
            my_update_screen(new_img, rect, file)
            if gl.RESET_FIT == 1:
                gl.FIT_IMAGE_VAL = 0
            normal_cursor()
    if event.type == KEYDOWN:  # Alt+0 (Actual Size) code
        mods = pygame.key.get_mods()
        if ((event.key == K_0 and mods & KMOD_ALT)):
            gl.SKIP_FIT = 1
            gl.ZOOM_EXP = 0
            wait_cursor()
            new_img = load_img(gl.files[file])
            img = refresh_img = new_img
            rect = get_center(screen, new_img)
            my_update_screen(new_img, rect, file)
            normal_cursor()
    if hit_key(event, K_1) or hit_key(event, K_KP1):
        #gl.SCALE_UP = 1
        if gl.FIT_IMAGE_VAL:
            gl.FIT_IMAGE_VAL = 0
            gl.RESET_FIT = 1
        else:
            gl.SKIP_FIT = 0
            gl.FIT_IMAGE_VAL = 1
            gl.RESET_FIT = 0
        wait_cursor()
        if new_img.get_width() > screen.get_width() or new_img.get_height() > screen.get_height() or gl.RESET_FIT:
            new_img = load_img(gl.files[file])
            img = refresh_img = new_img
            rect = get_center(screen, new_img)
        if gl.RESET_FIT:
            gl.FIT_IMAGE_VAL = 0
        my_update_screen(new_img, rect, file)
        normal_cursor()
    if hit_key(event, K_f):
        (new_img, img, refresh_img, file,
         rect) = command_first_img(new_img, screen, file, rect)
    if event.type == KEYDOWN:
        mods = pygame.key.get_mods()
        if (event.key == K_l and mods & KMOD_CTRL == 0):
            (new_img, img, refresh_img, file,
             rect) = command_last_img(new_img, screen, file, rect)
    if event.type == KEYDOWN:
        mods = pygame.key.get_mods()
        if (event.key == K_l and mods & KMOD_CTRL):
            gl.PERSISTENT_ZOOM_VAL ^= 1
            if not gl.PERSISTENT_ZOOM_VAL:
                gl.ZOOM_EXP = 0
            my_update_screen(new_img, rect, file)
    if event.type == KEYDOWN:
        mods = pygame.key.get_mods()
        if (event.key == K_DELETE and mods & KMOD_CTRL == 0) or\
                (event.key == K_KP_PERIOD and mods & KMOD_CTRL == 0) or\
                (event.key == K_w and mods & KMOD_CTRL):
            (new_img, img, refresh_img, file,
             rect) = command_remove_img(new_img, screen, file, rect)
    if event.type == KEYDOWN:
        mods = pygame.key.get_mods()
        if (event.key == K_DELETE and mods & KMOD_CTRL) or\
           (event.key == K_KP_PERIOD and mods & KMOD_CTRL):
            fn = gl.files[file]
            answer = get_confirmation(
                screen, "Delete %s? [y/n]" % basename(fn))
            if answer == "yes":
                (new_img, img, refresh_img, file, rect) = command_delete_img(
                    fn, new_img, screen, file, rect)
            my_update_screen(new_img, rect, file)
    if event.type == KEYDOWN:
        mods = pygame.key.get_mods()
        if (event.key == K_w and mods & KMOD_CTRL == 0) and hit_key(event, K_w):
            (new_img, img, refresh_img, file,
             rect) = my_slideshow(new_img, img, screen, file, rect)
            my_update_screen(new_img, rect, file)
    if hit_key(event, K_e):
        (screen, before_winsize, not_accepted) = adjust_screen(screen)
        gl.USING_SCROLL_MENU = 1
        zoom_percent = gl.CURRENT_ZOOM_PERCENT
        real_width = gl.REAL_WIDTH
        (new_img, img, refresh_img, file,
         rect) = command_edit_menu(screen, file, new_img, rect)
        if gl.ESCAPED:
            gl.CURRENT_ZOOM_PERCENT = zoom_percent
            gl.REAL_WIDTH = real_width
        screen = restore_screen(screen, before_winsize, not_accepted, new_img, file, rect)
        my_update_screen(new_img, rect, file)
        gl.ESCAPED = 0
        gl.USING_SCROLL_MENU = 0
    if hit_key(event, K_z):
        transparency = 0
        if not gl.TOGGLE_TRANSPARENT:
            gl.TOGGLE_TRANSPARENT = 1
            transparency = 1
        command_verbose_info(screen, new_img, rect, file)
        if transparency:
            gl.TOGGLE_TRANSPARENT = 0
        my_update_screen(new_img, rect, file)
    if hit_key(event, K_4):
        gl.CALC_ZOOM = 0
        zoom_percent = gl.CURRENT_ZOOM_PERCENT
        real_width = gl.REAL_WIDTH
        (file, new_img, img, refresh_img, rect) = command_four(screen, file, new_img)
        if gl.ESCAPED:
            gl.CURRENT_ZOOM_PERCENT = zoom_percent
            gl.REAL_WIDTH = real_width
        gl.ESCAPED = 0
        my_update_screen(new_img, rect, file)
        normal_cursor()
    if event.type == KEYDOWN:
        mods = pygame.key.get_mods()
        if (event.key == K_t and mods & KMOD_CTRL):
            gl.TOGGLE_TRANSPARENT ^= 1
            my_update_screen(new_img, rect, file)
    if event.type == KEYDOWN:
        mods = pygame.key.get_mods()
        if (event.key == K_t and mods & KMOD_CTRL == 0) and hit_key(event, K_t):
            gl.THUMBING = 1
            gl.CALC_ZOOM = 0
            zoom_percent = gl.CURRENT_ZOOM_PERCENT
            real_width = gl.REAL_WIDTH
            (new_img, img, refresh_img, file,
             rect) = command_thumbs(screen, new_img, file)
            if gl.ESCAPED:
                gl.CURRENT_ZOOM_PERCENT = zoom_percent
                gl.REAL_WIDTH = real_width
            gl.ESCAPED = 0
            gl.THUMBING = 0
            my_update_screen(new_img, rect, file)
    if hit_key(event, K_h):
        pygame.event.set_allowed(MOUSEMOTION)
        gl.HAND_TOOL = 1
        drag_hand_cursor()
    if gl.REMOTE and not gl.ALREADY_DOWNLOADED:
        if hit_key(event, K_a):
            save_remote_img(screen, file)

    gfx = {'screen': screen, 'rect': rect, 'new_img': new_img, 'img': img, 'refresh_img': refresh_img, 'file': file}
    return (gfx, last_rect)
示例#12
0
def main():
    pygame.time.delay(5) # to make start_timer() work initially
    start = start_timer()
    num_imgs = len(gl.files) 
    pygame.init() # needed for Mac OSX?
    init_screen()
    wait_cursor()
    screen = pygame.display.set_mode(gl.DEFAULT_RES, RESIZABLE)
    set_caption(gl.TITLE)
    if gl.REMOTE == 1:
        show_message(screen, "Loading image. Please wait..", 34, 42)
    file = 0
    if num_imgs < 1:
        gl.files = [gl.IMGV_LOGO]
        num_imgs = 1 
        img = load_img(gl.files[file], screen)
    else:
        img = load_img(gl.files[file], screen)
    wait_cursor()
    img_width = img.get_width()
    img_height = img.get_height()
    refresh_img = img
    new_img = img
    rect = get_center(screen, new_img)
    ns = check_timer(start)
    my_update_screen(new_img, screen, rect, file, num_imgs, ns)
    normal_cursor()
    if gl.START_FULLSCREEN:
        command_fullscreen(screen, new_img, file, num_imgs, rect)
        my_update_screen(new_img, screen, rect, file, num_imgs, ns)
    # start with menu open
    screen_width = screen.get_width()
    screen_height = screen.get_height()
    new_img_width = new_img.get_width()
    new_img_height = new_img.get_height()
    (refresh_img, screen, file, num_imgs, new_img, img,\
    new_img_width, new_img_height, rect) = command_main_menu(refresh_img, screen,\
    file, len(gl.files), rect, new_img, img, new_img_width, new_img_height, ns)
    minus1 = minus2 = 0

    # main loop
    while 1:
        event = pygame.event.poll()
        pygame.time.wait(1) # so pygame doesn't use 100% CPU
        cursor = pygame.mouse.get_pos()
        last_rect = Rect(rect)
        screen_width = screen.get_width()
        screen_height = screen.get_height()
        new_img_width = new_img.get_width()
        new_img_height = new_img.get_height()

        # drag image code:
        if gl.HAND_TOOL:
            if left_click(event): # calculate drag coordinates:
                if gl.IMG_BORDER:
                    border_fix(screen) # erase the current border
                grab_hand_cursor()
                minus1 = cursor[0] - rect[0]
                minus2 = cursor[1] - rect[1]
                gl.DO_DRAG = 1
            if event.type == MOUSEMOTION and gl.DO_DRAG: # move the image when dragged:
                grab_hand_cursor()
                rect[0] = cursor[0] - minus1 
                rect[1] = cursor[1] - minus2
                screen.fill(gl.IMGV_COLOR, last_rect)
                screen.blit(new_img, rect)
                update(rect.union(last_rect))
            if event.type == MOUSEBUTTONUP: # released mouse button, redisplay status bars:
                drag_hand_cursor()
                my_update_screen(new_img, screen, rect, file, num_imgs, ns)
                gl.DO_DRAG = 0

        if event.type == VIDEORESIZE:#
             print 'resize imgv.py'#
             screen = pygame.display.set_mode(event.dict['size'], RESIZABLE)
             rect = get_center(screen, new_img)
             my_update_screen(new_img, screen, rect, file, num_imgs, ns)
        if event.type == KEYDOWN:
            gl.HAND_TOOL = 0
            if event.key not in (K_DOWN, K_UP, K_RIGHT, K_LEFT):
                normal_cursor() # stop displaying hand tool
            (screen, rect, new_img, img, refresh_img, file, num_imgs,\
            screen_width, screen_height, new_img_width, new_img_height, last_rect) =\
            handle_keyboard(event, screen, rect, new_img, img, refresh_img, file, len(gl.files),\
            screen_width, screen_height, new_img_width, new_img_height, last_rect, ns)
        if event.type == KEYUP:
             stop_auto_repeat()
        check_quit(event)

        if event.type == MOUSEBUTTONDOWN: # open main menu:
            if right_click(event):
                gl.HAND_TOOL = 0
                (refresh_img, screen, file, num_imgs, new_img, img,\
                new_img_width, new_img_height, rect) = command_main_menu(refresh_img, screen,\
                file, num_imgs, rect, new_img, img, new_img_width, new_img_height, ns)
        if (gl.KEEP_MENU_OPEN == "1" and gl.COUNT_CLICKS == 1) or gl.JUST_RESIZED: # Re-open the purposely closed window that frees up RAM
            gl.COUNT_CLICKS = 0
            gl.JUST_RESIZED = 0
            (refresh_img, screen, file, num_imgs, new_img, img,\
            new_img_width, new_img_height, rect) = command_main_menu(refresh_img, screen,\
            file, num_imgs, rect, new_img, img, new_img_width, new_img_height, ns)
        start_auto_repeat(rect, last_rect, new_img, screen, file, len(gl.files), screen_width, screen_height, event)
    clean_screen()