Пример #1
0
def open_search_menu(window_x, window_y, db_dict, attr_dict=None, attr_list=None, settings=None):

    num_results = 20
    general_display = []

    if attr_dict is None:
        attr_dict = {}

    if attr_list is None:
        attr_list = []

    if settings is None:
        settings = {
            "window": "search",
            "mode": "players",
            "p_db_rg": "player_db",
            "f_db_rg": "formation_db",
            "order_rg": True,
            "messages": {"search": [], "sort": [], "results": []},
        }

    # ========== Window ==========
    win_search = Window()
    win_search.title = search_win_title
    win_search.auto_position = False
    win_search.position = (window_x, window_y)
    win_search.size = (win_width, win_height)
    win_search.resizable = 0
    win_search.name = search_title + " Window"

    # ========== Window Image View ==========
    class FormationsWindowImageView(View):
        def draw(self, c, r):
            c.backcolor = view_backcolor
            c.erase_rect(r)

    view = FormationsWindowImageView(size=win_search.size)

    # ========== Title ==========
    title = Label(text=search_title)
    title.font = title_font
    title.width = title_width
    title.height = title_height
    title.x = (win_width - title_width) / 2
    title.y = top_border
    title.color = title_color
    title.just = "center"
    general_display.append(title)

    # ========== Action Button Declarations ==========
    start_btn = Button("Start")
    back_btn = Button("Back")

    # ========== Search Type Button Declarations ==========
    players_btn = Button("Players")
    formations_btn = Button("Formations")
    teams_btn = Button("Teams")

    search_type_button_list = [players_btn, formations_btn, teams_btn]

    # ========== Tool Button Declarations ==========
    attribute_btn = Button("Add Search Attribute")
    sort_btn = Button("Add Sort Attribute")
    reset_btn = Button("Reset Results")

    # ========== Action Button Functions ==========
    def start_btn_func():
        # Start button corresponds to players
        if settings["mode"] == "players":
            # Search - if no attribute selected, return all
            if len(attr_dict) == 0:
                search_results = db_dict[p_db_radio_group.value][1]
            else:
                search_results = db_dict[p_db_radio_group.value][1].search(attr_dict)
                search_results = PlayerDB.PlayerDB(search_results)

            # Sort - if no attribute selected, use rating
            if len(attr_list) == 0:
                search_results.sort(["rating"], sort_order_radio_group.value)
            else:
                search_results.sort(attr_list, sort_order_radio_group.value)

            # Get attributes list and avoid duplicates
            attributes_list = []

            for attr in attr_list:
                if attributes_list.count(attr) == 0:
                    attributes_list.append(attr)

            for attr_key in attr_dict.iterkeys():
                if attributes_list.count(attr_key) == 0:
                    attributes_list.append(attr_key)

            display_players(search_results, attributes_list, (0, num_results))

        # Start button corresponds to formations
        elif settings["mode"] == "formations":
            # Search - if no attribute selected, return all
            if len(attr_dict) == 0:
                search_results = db_dict[f_db_radio_group.value][1]
            else:
                search_results = db_dict[f_db_radio_group.value][1].search(attr_dict)
                search_results = FormationDB.FormationDB(search_results)

            # Sort - if no attribute selected, use name
            if len(attr_list) == 0:
                search_results.sort(["name"], sort_order_radio_group.value)
            else:
                search_results.sort(attr_list, sort_order_radio_group.value)

            # Get attributes list and avoid duplicates
            attributes_list = []

            for attr in attr_list:
                if attributes_list.count(attr) == 0:
                    attributes_list.append(attr)

            for attr_key in attr_dict.iterkeys():
                if attributes_list.count(attr_key) == 0:
                    attributes_list.append(attr_key)

            display_formations(search_results, attributes_list, (0, num_results))

        # Start button corresponds to teams
        elif settings["mode"] == "teams":
            # Search - if no attribute selected, return all
            if len(attr_dict) == 0:
                search_results = db_dict["team_list"][1]
            else:
                search_results = db_dict["team_list"][1].search(attr_dict)
                search_results = TeamDB.TeamDB(search_results)

            # Sort - if no attribute selected, use rating
            if len(attr_list) == 0:
                search_results.sort(["rating"], sort_order_radio_group.value)
            else:
                search_results.sort(attr_list, sort_order_radio_group.value)

            # Get attributes list and avoid duplicates
            attributes_list = []

            for attr in attr_list:
                if attributes_list.count(attr) == 0:
                    attributes_list.append(attr)

            for attr_key in attr_dict.iterkeys():
                if attributes_list.count(attr_key) == 0:
                    attributes_list.append(attr_key)

            display_teams(search_results, attributes_list, (0, num_results))

        win_search.become_target()

    def back_btn_func():
        win_search.hide()
        StartMenu.open_start_menu(win_search.x, win_search.y, db_dict)

    # ========== Search Type Button Functions ==========
    def players_btn_func():
        for btn in search_type_button_list:
            btn.enabled = 1
        players_btn.enabled = 0
        settings["mode"] = "players"

        # Reset screen
        reset_btn_func()

        view.remove(formation_db_radio_btn)
        view.remove(f_db_file_btn)
        view.remove(formation_list_radio_btn)
        view.remove(f_list_file_btn)
        view.remove(team_list_button)

        view.add(player_db_radio_btn)
        view.add(p_db_file_btn)
        view.add(player_list_radio_btn)
        view.add(p_list_file_btn)

        win_search.become_target()

    def formations_btn_func():
        for btn in search_type_button_list:
            btn.enabled = 1
        formations_btn.enabled = 0
        settings["mode"] = "formations"

        # Reset screen
        reset_btn_func()

        view.remove(player_db_radio_btn)
        view.remove(p_db_file_btn)
        view.remove(player_list_radio_btn)
        view.remove(p_list_file_btn)
        view.remove(team_list_button)

        view.add(formation_db_radio_btn)
        view.add(f_db_file_btn)
        view.add(formation_list_radio_btn)
        view.add(f_list_file_btn)

        win_search.become_target()

    def teams_btn_func():
        for btn in search_type_button_list:
            btn.enabled = 1
        teams_btn.enabled = 0
        settings["mode"] = "teams"

        # Reset screen
        reset_btn_func()

        view.remove(player_db_radio_btn)
        view.remove(p_db_file_btn)
        view.remove(player_list_radio_btn)
        view.remove(p_list_file_btn)
        view.remove(formation_db_radio_btn)
        view.remove(f_db_file_btn)
        view.remove(formation_list_radio_btn)
        view.remove(f_list_file_btn)

        view.add(team_list_button)

        win_search.become_target()

    # ========== Tool Button Functions ==========
    def attribute_btn_func():
        # Delete results
        del settings["messages"]["results"][:]

        # Set type argument
        attr_type = ""
        if settings["mode"] == "players":
            attr_type = "player_search"
        elif settings["mode"] == "formations":
            attr_type = "formation_search"
        elif settings["mode"] == "teams":
            attr_type = "team_search"
        else:
            print "Invalid mode."

        # Open new window and close current window
        win_search.hide()
        AddAttribute.open_attribute_window(
            win_search.x, win_search.y, db_dict, attr_dict, attr_list, attr_type, settings
        )

    def sort_btn_func():
        # Delete results
        del settings["messages"]["results"][:]

        # Set type argument
        attr_type = ""
        if settings["mode"] == "players":
            attr_type = "player_sort"
        elif settings["mode"] == "formations":
            attr_type = "formation_sort"
        elif settings["mode"] == "teams":
            attr_type = "team_sort"
        else:
            print "Invalid mode."

        # Open new window and close current window
        win_search.hide()
        AddAttribute.open_attribute_window(
            win_search.x, win_search.y, db_dict, attr_dict, attr_list, attr_type, settings
        )

    def reset_btn_func():
        # Remove messages off page
        for message in settings["messages"]["search"]:
            view.remove(message)
        for message in settings["messages"]["sort"]:
            view.remove(message)
        for message in settings["messages"]["results"]:
            view.remove(message)

        # Delete the attribute parameters for search and sort
        attr_dict.clear()
        del attr_list[:]
        del settings["messages"]["results"][:]

        win_search.become_target()

    def player_bio_btn_func(player):
        win_search.hide()
        PlayerBio.open_player_bio_window(
            win_search.x,
            win_search.y,
            player,
            win_search,
            db_dict,
            db_dict["player_list"][0],
            db_dict["player_list"][1],
        )
        win_search.become_target()

    def formation_bio_btn_func(formation):
        win_search.hide()
        FormationBio.open_formation_bio_window(
            win_search.x,
            win_search.y,
            formation,
            win_search,
            db_dict["formation_list"][0],
            db_dict["formation_list"][1],
        )
        win_search.become_target()

    def team_bio_btn_func(team):
        win_search.hide()
        TeamBio.open_team_bio_window(
            win_search.x, win_search.y, team, win_search, db_dict["team_list"][0], db_dict["team_list"][1]
        )
        win_search.become_target()

    # ========== Pick DB/List Button Functions ==========
    def pick_file():
        # Remove old messages off page
        for message in settings["messages"]["results"]:
            view.remove(message)
        del settings["messages"]["results"][:]

        settings["file_changes"] = False
        settings["prev_window"] = "search"
        settings["attr_dict"] = attr_dict
        settings["attr_list"] = attr_list
        PickFile.open_pick_file_window(win_search.x, win_search.y, db_dict, settings)
        win_search.hide()

    def pick_p_db_func():
        settings["file_type"] = "current_player_db"
        pick_file()

    def pick_p_list_func():
        settings["file_type"] = "current_player_list"
        pick_file()

    def pick_f_db_func():
        settings["file_type"] = "current_formation_db"
        pick_file()

    def pick_f_list_func():
        settings["file_type"] = "current_formation_list"
        pick_file()

    def pick_t_list_func():
        settings["file_type"] = "current_team_list"
        pick_file()

    # ========== Action Buttons ==========
    start_btn.x = (win_width - 2 * small_button_width - small_button_spacing) / 2
    start_btn.y = title.bottom + small_button_top_spacing
    start_btn.height = small_button_height
    start_btn.width = small_button_width
    start_btn.font = small_button_font
    start_btn.action = start_btn_func
    start_btn.style = "default"
    start_btn.color = small_button_color
    start_btn.just = "right"
    general_display.append(start_btn)

    back_btn.x = start_btn.right + small_button_spacing
    back_btn.y = start_btn.top
    back_btn.height = small_button_height
    back_btn.width = small_button_width
    back_btn.font = small_button_font
    back_btn.action = back_btn_func
    back_btn.style = "default"
    back_btn.color = small_button_color
    back_btn.just = "right"
    general_display.append(back_btn)

    # ========== Search Type Buttons ==========
    players_btn.x = (win_width - 3 * small_button_width - 2 * small_button_spacing) / 2
    players_btn.y = start_btn.bottom + small_button_top_spacing
    players_btn.height = small_button_height
    players_btn.width = small_button_width
    players_btn.font = small_button_font
    players_btn.action = players_btn_func
    players_btn.style = "default"
    players_btn.color = small_button_color
    players_btn.just = "right"
    if settings["mode"] == "players":
        players_btn.enabled = 0
    general_display.append(players_btn)

    formations_btn.x = players_btn.right + small_button_spacing
    formations_btn.y = players_btn.top
    formations_btn.height = small_button_height
    formations_btn.width = small_button_width
    formations_btn.font = small_button_font
    formations_btn.action = formations_btn_func
    formations_btn.style = "default"
    formations_btn.color = small_button_color
    formations_btn.just = "right"
    if settings["mode"] == "formations":
        formations_btn.enabled = 0
    general_display.append(formations_btn)

    teams_btn.x = formations_btn.right + small_button_spacing
    teams_btn.y = players_btn.top
    teams_btn.height = small_button_height
    teams_btn.width = small_button_width
    teams_btn.font = small_button_font
    teams_btn.action = teams_btn_func
    teams_btn.style = "default"
    teams_btn.color = small_button_color
    teams_btn.just = "right"
    if settings["mode"] == "teams":
        teams_btn.enabled = 0
    general_display.append(teams_btn)

    # ========== Tool Buttons ==========
    attribute_btn.x = (win_width - 3 * small_button_width - 2 * small_button_spacing) / 2
    attribute_btn.y = players_btn.bottom + 5
    attribute_btn.height = small_button_height
    attribute_btn.width = small_button_width
    attribute_btn.font = small_button_font
    attribute_btn.action = attribute_btn_func
    attribute_btn.style = "default"
    attribute_btn.color = small_button_color
    attribute_btn.just = "right"
    general_display.append(attribute_btn)

    sort_btn.x = attribute_btn.right + small_button_spacing
    sort_btn.y = attribute_btn.top
    sort_btn.height = small_button_height
    sort_btn.width = small_button_width
    sort_btn.font = small_button_font
    sort_btn.action = sort_btn_func
    sort_btn.style = "default"
    sort_btn.color = small_button_color
    sort_btn.just = "right"
    general_display.append(sort_btn)

    reset_btn.x = sort_btn.right + small_button_spacing
    reset_btn.y = attribute_btn.top
    reset_btn.height = small_button_height
    reset_btn.width = small_button_width
    reset_btn.font = small_button_font
    reset_btn.action = reset_btn_func
    reset_btn.style = "default"
    reset_btn.color = small_button_color
    reset_btn.just = "right"
    general_display.append(reset_btn)

    # ========== DB Radio Buttons ==========
    def get_attribute_p_db_rg():
        settings["p_db_rg"] = p_db_radio_group.value
        win_search.become_target()

    def get_attribute_f_db_rg():
        settings["f_db_rg"] = f_db_radio_group.value
        win_search.become_target()

    p_db_radio_group = RadioGroup(action=get_attribute_p_db_rg)
    f_db_radio_group = RadioGroup(action=get_attribute_f_db_rg)

    db_msg_width = 35
    db_radio_btn_width = 150
    db_file_btn_width = 40
    db_radio_btn_space = 5
    db_file_btn_space = 2

    file_label = Label(text="File:", font=std_tf_font, width=db_msg_width, height=std_tf_height, color=title_color)
    file_label.x = (
        win_search.width
        - 2 * db_radio_btn_width
        - 2 * db_file_btn_width
        - db_radio_btn_space
        - 2 * db_file_btn_space
        - db_msg_width
    ) / 2
    file_label.y = reset_btn.bottom + db_radio_btn_space
    view.add(file_label)

    # Players DB RG
    player_db_radio_btn = RadioButton(db_dict["player_db"][0])
    player_db_radio_btn.width = db_radio_btn_width
    player_db_radio_btn.x = file_label.right
    player_db_radio_btn.y = file_label.top
    player_db_radio_btn.group = p_db_radio_group
    player_db_radio_btn.value = "player_db"

    p_db_file_btn = Button("Pick")
    p_db_file_btn.x = player_db_radio_btn.right + db_file_btn_space
    p_db_file_btn.y = file_label.top
    p_db_file_btn.height = std_tf_height
    p_db_file_btn.width = db_file_btn_width
    p_db_file_btn.font = small_button_font
    p_db_file_btn.action = pick_p_db_func
    p_db_file_btn.style = "default"
    p_db_file_btn.color = small_button_color
    p_db_file_btn.just = "right"

    player_list_radio_btn = RadioButton(db_dict["player_list"][0])
    player_list_radio_btn.width = db_radio_btn_width
    player_list_radio_btn.x = p_db_file_btn.right + db_radio_btn_space
    player_list_radio_btn.y = file_label.top
    player_list_radio_btn.group = p_db_radio_group
    player_list_radio_btn.value = "player_list"

    p_list_file_btn = Button("Pick")
    p_list_file_btn.x = player_list_radio_btn.right + db_file_btn_space
    p_list_file_btn.y = file_label.top
    p_list_file_btn.height = std_tf_height
    p_list_file_btn.width = db_file_btn_width
    p_list_file_btn.font = small_button_font
    p_list_file_btn.action = pick_p_list_func
    p_list_file_btn.style = "default"
    p_list_file_btn.color = small_button_color
    p_list_file_btn.just = "right"

    p_db_radio_group.value = settings["p_db_rg"]

    # Formations DB RG
    formation_db_radio_btn = RadioButton(db_dict["formation_db"][0])
    formation_db_radio_btn.width = db_radio_btn_width
    formation_db_radio_btn.x = file_label.right
    formation_db_radio_btn.y = file_label.top
    formation_db_radio_btn.group = f_db_radio_group
    formation_db_radio_btn.value = "formation_db"

    f_db_file_btn = Button("Pick")
    f_db_file_btn.x = formation_db_radio_btn.right + db_file_btn_space
    f_db_file_btn.y = file_label.top
    f_db_file_btn.height = std_tf_height
    f_db_file_btn.width = db_file_btn_width
    f_db_file_btn.font = small_button_font
    f_db_file_btn.action = pick_f_db_func
    f_db_file_btn.style = "default"
    f_db_file_btn.color = small_button_color
    f_db_file_btn.just = "right"

    formation_list_radio_btn = RadioButton(db_dict["formation_list"][0])
    formation_list_radio_btn.width = db_radio_btn_width
    formation_list_radio_btn.x = f_db_file_btn.right + db_radio_btn_space
    formation_list_radio_btn.y = file_label.top
    formation_list_radio_btn.group = f_db_radio_group
    formation_list_radio_btn.value = "formation_list"

    f_list_file_btn = Button("Pick")
    f_list_file_btn.x = formation_list_radio_btn.right + db_file_btn_space
    f_list_file_btn.y = file_label.top
    f_list_file_btn.height = std_tf_height
    f_list_file_btn.width = db_file_btn_width
    f_list_file_btn.font = small_button_font
    f_list_file_btn.action = pick_f_list_func
    f_list_file_btn.style = "default"
    f_list_file_btn.color = small_button_color
    f_list_file_btn.just = "right"

    f_db_radio_group.value = settings["f_db_rg"]

    # Teams DB Button
    teams_db_msg_width = 2 * db_radio_btn_width + 2 * db_file_btn_width + db_radio_btn_space + 2 * db_file_btn_space

    team_list_button = Button(
        title=db_dict["team_list"][0],
        font=std_tf_font,
        just="left",
        width=teams_db_msg_width,
        height=std_tf_height,
        color=title_color,
    )
    team_list_button.x = file_label.right
    team_list_button.y = reset_btn.bottom + db_radio_btn_space
    team_list_button.action = pick_t_list_func

    if settings["mode"] == "players":
        view.add(player_db_radio_btn)
        view.add(p_db_file_btn)
        view.add(player_list_radio_btn)
        view.add(p_list_file_btn)
    elif settings["mode"] == "formations":
        view.add(formation_db_radio_btn)
        view.add(f_db_file_btn)
        view.add(formation_list_radio_btn)
        view.add(f_list_file_btn)
    elif settings["mode"] == "teams":
        view.add(team_list_button)
    else:
        print "Error: Invalid mode."

    # ========== Sort Order Radio Buttons ==========
    def get_attribute_sort_order_rg():
        settings["order_rg"] = sort_order_radio_group.value
        win_search.become_target()

    sort_order_radio_group = RadioGroup(action=get_attribute_sort_order_rg)

    asc_desc_radio_btn_width = 75
    asc_msg_width = 80
    radio_btn_space = 5

    asc_desc_rg_msg = Label(
        text="Sort Order:", font=std_tf_font, width=asc_msg_width, height=std_tf_height, color=title_color
    )
    asc_desc_rg_msg.x = (win_search.width - 2 * asc_desc_radio_btn_width - radio_btn_space - asc_msg_width) / 2
    asc_desc_rg_msg.y = formation_db_radio_btn.bottom + radio_btn_space
    general_display.append(asc_desc_rg_msg)

    descend_radio_btn = RadioButton("Descending")
    descend_radio_btn.width = asc_desc_radio_btn_width
    descend_radio_btn.x = asc_desc_rg_msg.right
    descend_radio_btn.y = asc_desc_rg_msg.top
    descend_radio_btn.group = sort_order_radio_group
    descend_radio_btn.value = True
    general_display.append(descend_radio_btn)

    ascend_radio_btn = RadioButton("Ascending")
    ascend_radio_btn.width = asc_desc_radio_btn_width
    ascend_radio_btn.x = descend_radio_btn.right + radio_btn_space
    ascend_radio_btn.y = descend_radio_btn.top
    ascend_radio_btn.group = sort_order_radio_group
    ascend_radio_btn.value = False
    general_display.append(ascend_radio_btn)

    sort_order_radio_group.value = settings["order_rg"]

    # ========== Messages ==========
    lowest_msg_l = start_btn.top
    lowest_msg_r = start_btn.top

    attr_msg_offset = 25

    # Attribute Messages
    del settings["messages"]["search"][:]
    del settings["messages"]["sort"][:]

    if len(attr_dict) > 0:
        settings["messages"]["search"].append(
            Label(
                text="Search Attributes:",
                font=title_tf_font,
                width=std_tf_width,
                height=std_tf_height,
                x=attr_msg_offset,
                y=lowest_msg_l,
                color=title_color,
            )
        )
        lowest_msg_l += std_tf_height

        for key, value in attr_dict.iteritems():
            msg_text = format_attr_name(key) + ": "
            if key in ["id", "baseId", "nationId", "leagueId", "clubId"]:
                msg_text += str(value[0])
            elif type(value[0]) is int:
                msg_text += value[1].capitalize() + " " + str(value[0])
            elif value[1] == "not":
                msg_text += value[1].capitalize() + ' "' + str(value[0]) + '"'
            else:
                msg_text += '"' + str(value[0]) + '"'

            attr_label = Label(
                text=msg_text,
                font=std_tf_font,
                width=std_tf_width,
                height=std_tf_height,
                x=attr_msg_offset,
                y=lowest_msg_l,
                color=title_color,
            )
            lowest_msg_l += std_tf_height
            settings["messages"]["search"].append(attr_label)

    if len(attr_list) > 0:
        settings["messages"]["sort"].append(
            Label(
                text="Sort Attributes:",
                font=title_tf_font,
                width=std_tf_width,
                height=std_tf_height,
                x=teams_btn.right + 3 * attr_msg_offset,
                y=lowest_msg_r,
                color=title_color,
            )
        )
        lowest_msg_r += std_tf_height

        for value in attr_list:
            attr_label = Label(
                text=(format_attr_name(value)),
                font=std_tf_font,
                width=std_tf_width,
                height=std_tf_height,
                x=teams_btn.right + 3 * attr_msg_offset,
                y=lowest_msg_r,
                color=title_color,
            )
            lowest_msg_r += std_tf_height
            settings["messages"]["sort"].append(attr_label)

    # ========== Previous, Add to List, Next Buttons ==========
    previous_btn = Button("<<< Previous %d" % num_results)
    add_to_list_btn = Button()
    next_btn = Button("Next %d >>>" % num_results)
    total_num_results_label = Label()
    pages_label = Label()

    def add_to_list_btn_func(input_list, func_type):
        results_list = copy.deepcopy(input_list)
        if func_type == "add all":
            if settings["mode"] == "players":
                added_players = []
                # Add current results to player list
                for player in results_list:
                    if db_dict["player_list"][1].db.count(player) == 0:
                        db_dict["player_list"][1].db.append(player)
                        added_players.append(player)

                # Sort
                db_dict["player_list"][1].sort(["rating"])
                # Save
                db_dict["player_list"][1].save(db_dict["player_list"][0], "list", True)

                # Change button title and action
                add_to_list_btn.title = "Remove Added Players"
                add_to_list_btn.action = (add_to_list_btn_func, results_list, "remove select")

                # Keep track of just added players
                settings["messages"]["players_changed"] = added_players

            elif settings["mode"] == "formations":
                added_formations = []
                # Add current results to formation list
                for formation in results_list:
                    if db_dict["formation_list"][1].db.count(formation) == 0:
                        db_dict["formation_list"][1].db.append(formation)
                        added_formations.append(formation)

                # Sort
                db_dict["formation_list"][1].sort(["name"])
                # Save
                db_dict["formation_list"][1].save(db_dict["formation_list"][0], "list", True)

                # Change button title and action
                add_to_list_btn.title = "Remove Added Forms"
                add_to_list_btn.action = (add_to_list_btn_func, results_list, "remove select")

                # Keep track of just added formations
                settings["messages"]["formations_changed"] = added_formations

        elif func_type == "remove all":
            if settings["mode"] == "players":
                removed_players = []
                # Remove current results from player list
                for player in results_list:
                    if db_dict["player_list"][1].db.count(player) > 0:
                        db_dict["player_list"][1].db.remove(player)
                        removed_players.append(player)

                # Sort
                db_dict["player_list"][1].sort(["rating"])
                # Save
                db_dict["player_list"][1].save(db_dict["player_list"][0], "list", True)

                # Change button title and action
                add_to_list_btn.title = "Add Removed Players"
                add_to_list_btn.action = (add_to_list_btn_func, results_list, "add select")

                # Keep track of just removed players
                settings["messages"]["players_changed"] = removed_players

            elif settings["mode"] == "formations":
                removed_formations = []
                # Remove current results from formation list
                for formation in results_list:
                    if db_dict["formation_list"][1].db.count(formation) > 0:
                        db_dict["formation_list"][1].db.remove(formation)
                        removed_formations.append(formation)

                # Sort
                db_dict["formation_list"][1].sort(["name"])
                # Save
                db_dict["formation_list"][1].save(db_dict["formation_list"][0], "list", True)

                # Change button title and action
                add_to_list_btn.title = "Add Removed Forms"
                add_to_list_btn.action = (add_to_list_btn_func, results_list, "add select")

                # Keep track of just removed players
                settings["messages"]["formations_changed"] = removed_formations

        elif func_type == "add select":
            if settings["mode"] == "players":
                # Add select players back to player list
                for player in settings["messages"]["players_changed"]:
                    if db_dict["player_list"][1].db.count(player) == 0:
                        db_dict["player_list"][1].db.append(player)

                # Sort
                db_dict["player_list"][1].sort(["rating"])
                # Save
                db_dict["player_list"][1].save(db_dict["player_list"][0], "list", True)

                # Change button title and action
                add_to_list_btn.title = "Remove Added Players"
                add_to_list_btn.action = (add_to_list_btn_func, results_list, "remove select")

            elif settings["mode"] == "formations":
                # Add select formations back to formation list
                for formation in settings["messages"]["formations_changed"]:
                    if db_dict["formation_list"][1].db.count(formation) == 0:
                        db_dict["formation_list"][1].db.append(formation)

                # Sort
                db_dict["formation_list"][1].sort(["name"])
                # Save
                db_dict["formation_list"][1].save(db_dict["formation_list"][0], "list", True)

                # Change button title and action
                add_to_list_btn.title = "Remove Added Forms"
                add_to_list_btn.action = (add_to_list_btn_func, results_list, "remove select")

        elif func_type == "remove select":
            if settings["mode"] == "players":
                # Remove select players from player list
                for player in settings["messages"]["players_changed"]:
                    if db_dict["player_list"][1].db.count(player) > 0:
                        db_dict["player_list"][1].db.remove(player)

                # Sort
                db_dict["player_list"][1].sort(["rating"])
                # Save
                db_dict["player_list"][1].save(db_dict["player_list"][0], "list", True)

                # Change button title and action
                add_to_list_btn.title = "Add Removed Players"
                add_to_list_btn.action = (add_to_list_btn_func, results_list, "add select")

            elif settings["mode"] == "formations":
                # Remove select formations from formation list
                for formation in settings["messages"]["formations_changed"]:
                    if db_dict["formation_list"][1].db.count(formation) > 0:
                        db_dict["formation_list"][1].db.remove(formation)

                # Sort
                db_dict["formation_list"][1].sort(["name"])
                # Save
                db_dict["formation_list"][1].save(db_dict["formation_list"][0], "list", True)

                # Change button title and action
                add_to_list_btn.title = "Add Removed Forms"
                add_to_list_btn.action = (add_to_list_btn_func, results_list, "add select")

        win_search.become_target()

    def previous_btn_func(results_list, attributes, index_range):
        # display previous results
        if settings["mode"] == "players":
            display_players(results_list, attributes, index_range)
        elif settings["mode"] == "formations":
            display_formations(results_list, attributes, index_range)
        elif settings["mode"] == "teams":
            display_teams(results_list, attributes, index_range)
        win_search.become_target()

    def next_btn_func(results_list, attributes, index_range):
        # display next results
        if settings["mode"] == "players":
            display_players(results_list, attributes, index_range)
        elif settings["mode"] == "formations":
            display_formations(results_list, attributes, index_range)
        elif settings["mode"] == "teams":
            display_teams(results_list, attributes, index_range)
        win_search.become_target()

    add_to_list_btn.x = attribute_btn.right + small_button_spacing
    add_to_list_btn.y = descend_radio_btn.bottom + 5
    add_to_list_btn.height = tiny_button_height
    add_to_list_btn.width = small_button_width
    add_to_list_btn.font = small_button_font
    add_to_list_btn.style = "default"
    add_to_list_btn.color = small_button_color
    add_to_list_btn.just = "right"

    previous_btn.height = tiny_button_height
    previous_btn.width = small_button_width
    previous_btn.x = add_to_list_btn.left - previous_btn.width - small_button_spacing
    previous_btn.y = add_to_list_btn.top
    previous_btn.font = small_button_font
    previous_btn.style = "default"
    previous_btn.color = small_button_color
    previous_btn.just = "right"

    next_btn.height = tiny_button_height
    next_btn.width = small_button_width
    next_btn.x = add_to_list_btn.right + small_button_spacing
    next_btn.y = add_to_list_btn.top
    next_btn.font = small_button_font
    next_btn.style = "default"
    next_btn.color = small_button_color
    next_btn.just = "right"

    total_num_results_label.font = std_tf_font
    total_num_results_label.width = 100
    total_num_results_label.height = std_tf_height
    total_num_results_label.x = previous_btn.left + -100 - 10
    total_num_results_label.y = add_to_list_btn.top
    total_num_results_label.color = title_color
    total_num_results_label.just = "right"

    pages_label.font = std_tf_font
    pages_label.width = 125
    pages_label.height = std_tf_height
    pages_label.x = next_btn.right + 10
    pages_label.y = add_to_list_btn.top
    pages_label.color = title_color
    pages_label.just = "left"

    # ========== Display players from search ==========
    def display_players(results_list, attributes, index_range):
        # Remove old messages off page
        for message in settings["messages"]["results"]:
            view.remove(message)
        del settings["messages"]["results"][:]

        # Add navigation buttons to page
        if settings["p_db_rg"] == "player_db":
            add_to_list_btn.title = "Add All Players"
            add_to_list_btn.action = (add_to_list_btn_func, results_list.db, "add all")
        elif settings["p_db_rg"] == "player_list":
            add_to_list_btn.title = "Remove All Players"
            add_to_list_btn.action = (add_to_list_btn_func, results_list.db, "remove all")
        else:
            print "Invalid edit type."

        previous_range = (index_range[0] - num_results, index_range[0])
        previous_btn.action = (previous_btn_func, results_list, attributes, previous_range)

        next_range = (index_range[1], index_range[1] + num_results)
        next_btn.action = (next_btn_func, results_list, attributes, next_range)

        total_num_results_label.text = str(len(results_list.db)) + " Players"
        pages_label.text = "Page %d of %d" % (
            int(index_range[1] / num_results),
            math.ceil(len(results_list.db) / float(num_results)),
        )

        if index_range[0] > 0:
            previous_btn.enabled = 1
        else:
            previous_btn.enabled = 0
        if index_range[1] <= len(results_list.db) - 1:
            next_btn.enabled = 1
        else:
            next_btn.enabled = 0

        settings["messages"]["results"].append(add_to_list_btn)
        settings["messages"]["results"].append(previous_btn)
        settings["messages"]["results"].append(next_btn)
        settings["messages"]["results"].append(total_num_results_label)
        settings["messages"]["results"].append(pages_label)

        # Print out labels
        labels = player_info_labels(attributes)
        stat_index = 0
        # Spacing values for each of the stats
        spacing_list = [125, 40, 40, 65, 115, 115, 115, 40]
        # Calculate the maximum number of stat fields that will fit on screen
        max_player_fields = len(spacing_list[:-1]) + (win_search.width - sum(spacing_list[:-1])) / spacing_list[-1]
        # Calculate the left border of the stats based on the number and width of the stats
        left_border = (
            win_width
            - sum(spacing_list[:-1])
            - (len(labels[:max_player_fields]) - len(spacing_list) + 1) * spacing_list[-1]
        ) / 2
        msg_x = left_border
        msg_y = add_to_list_btn.bottom + 5

        for info_label in labels[:max_player_fields]:
            player_label = Label(
                text=info_label,
                font=std_tf_font_bold,
                width=spacing_list[stat_index] - 5,
                height=std_tf_height,
                x=msg_x,
                y=msg_y,
                color=title_color,
            )
            settings["messages"]["results"].append(player_label)
            msg_x += spacing_list[stat_index]

            if stat_index < len(spacing_list) - 1:
                stat_index += 1

        msg_y += std_tf_height + 5

        # Print out players
        for idx, player in enumerate(results_list.db[index_range[0] : index_range[1]]):
            msg_x = left_border
            player_stats = player_info(player, attributes)
            stat_index = 0

            # Check for names that are too long
            name = player_stats[0]
            if len(name) > 20:
                name = player["lastName"]

            bio_btn = Button(
                title=name,
                width=spacing_list[stat_index] - 5,
                height=15,
                x=msg_x,
                y=msg_y,
                action=(player_bio_btn_func, player),
            )
            settings["messages"]["results"].append(bio_btn)
            msg_x += spacing_list[stat_index]
            stat_index += 1

            for player_stat in player_stats[1:max_player_fields]:
                player_label = Label(
                    text=player_stat,
                    font=small_button_font,
                    width=spacing_list[stat_index] - 5,
                    height=std_tf_height,
                    x=msg_x,
                    y=msg_y,
                    color=title_color,
                )

                settings["messages"]["results"].append(player_label)
                msg_x += spacing_list[stat_index]
                if stat_index < len(spacing_list) - 1:
                    stat_index += 1

            msg_y += std_tf_height

        for results_msg in settings["messages"]["results"]:
            view.add(results_msg)

    # ========== Display formations from search ==========
    def display_formations(results_list, attributes, index_range):
        # Remove old messages off page
        for message in settings["messages"]["results"]:
            view.remove(message)
        del settings["messages"]["results"][:]

        # Add navigation buttons to page
        if settings["f_db_rg"] == "formation_db":
            add_to_list_btn.title = "Add All Formations"
            add_to_list_btn.action = (add_to_list_btn_func, results_list.db, "add all")
        elif settings["f_db_rg"] == "formation_list":
            add_to_list_btn.title = "Remove All Formations"
            add_to_list_btn.action = (add_to_list_btn_func, results_list.db, "remove all")
        else:
            print "Invalid edit type."

        previous_range = (index_range[0] - num_results, index_range[0])
        previous_btn.action = (previous_btn_func, results_list, attributes, previous_range)

        next_range = (index_range[1], index_range[1] + num_results)
        next_btn.action = (next_btn_func, results_list, attributes, next_range)

        total_num_results_label.text = str(len(results_list.db)) + " Formations"
        pages_label.text = "Page %d of %d" % (
            int(index_range[1] / num_results),
            math.ceil(len(results_list.db) / float(num_results)),
        )

        if index_range[0] > 0:
            previous_btn.enabled = 1
        else:
            previous_btn.enabled = 0
        if index_range[1] <= len(results_list.db) - 1:
            next_btn.enabled = 1
        else:
            next_btn.enabled = 0

        settings["messages"]["results"].append(add_to_list_btn)
        settings["messages"]["results"].append(previous_btn)
        settings["messages"]["results"].append(next_btn)
        settings["messages"]["results"].append(total_num_results_label)
        settings["messages"]["results"].append(pages_label)

        # Print out labels
        labels = formation_info_labels()
        stat_index = 0
        # Spacing values for each of the stats
        spacing_list = [100, 100, 55, 55, 55, 55, 140, 160]
        # Calculate the left border of the stats based on the number and width of the stats
        left_border = (win_search.width - sum(spacing_list)) / 2
        msg_x = left_border
        msg_y = add_to_list_btn.bottom + 5

        for info_label in labels:
            formation_label = Label(
                text=info_label,
                font=std_tf_font_bold,
                width=spacing_list[stat_index] - 5,
                height=std_tf_height,
                x=msg_x,
                y=msg_y,
                color=title_color,
            )
            settings["messages"]["results"].append(formation_label)
            msg_x += spacing_list[stat_index]

            if stat_index < len(spacing_list) - 1:
                stat_index += 1

        msg_y += std_tf_height + 5

        # Print out formations
        for formation in results_list.db[index_range[0] : index_range[1]]:
            msg_x = left_border
            formation_stats = formation_info(formation)
            stat_index = 0

            bio_btn = Button(
                title=formation_stats[0],
                width=spacing_list[stat_index] - 5,
                height=15,
                x=msg_x,
                y=msg_y,
                action=(formation_bio_btn_func, formation),
            )
            settings["messages"]["results"].append(bio_btn)
            msg_x += spacing_list[stat_index]
            stat_index += 1

            for formation_stat in formation_stats[1:]:
                formation_label = Label(
                    text=formation_stat,
                    font=small_button_font,
                    width=spacing_list[stat_index] - 5,
                    height=std_tf_height,
                    x=msg_x,
                    y=msg_y,
                    color=title_color,
                )

                settings["messages"]["results"].append(formation_label)
                msg_x += spacing_list[stat_index]
                if stat_index < len(spacing_list) - 1:
                    stat_index += 1

            msg_y += std_tf_height

        for results_msg in settings["messages"]["results"]:
            view.add(results_msg)

    # ========== Display teams from search ==========
    def display_teams(results_list, attributes, index_range):
        # Remove old messages off page
        for message in settings["messages"]["results"]:
            view.remove(message)
        del settings["messages"]["results"][:]

        # Add navigation buttons to page
        '''if settings['f_db_rg'] == 'formation_db':
            add_to_list_btn.title = 'Add All Formations'
            add_to_list_btn.action = (add_to_list_btn_func, results_list.db, 'add all')
        elif settings['f_db_rg'] == 'formation_list':
            add_to_list_btn.title = 'Remove All Formations'
            add_to_list_btn.action = (add_to_list_btn_func, results_list.db, 'remove all')
        else:
            print "Invalid edit type."'''
        add_to_list_btn.title = ""
        add_to_list_btn.action = ()

        previous_range = (index_range[0] - num_results, index_range[0])
        previous_btn.action = (previous_btn_func, results_list, attributes, previous_range)

        next_range = (index_range[1], index_range[1] + num_results)
        next_btn.action = (next_btn_func, results_list, attributes, next_range)

        total_num_results_label.text = str(len(results_list.db)) + " Teams"
        pages_label.text = "Page %d of %d" % (
            int(index_range[1] / num_results),
            math.ceil(len(results_list.db) / float(num_results)),
        )

        if index_range[0] > 0:
            previous_btn.enabled = 1
        else:
            previous_btn.enabled = 0
        if index_range[1] <= len(results_list.db) - 1:
            next_btn.enabled = 1
        else:
            next_btn.enabled = 0

        settings["messages"]["results"].append(add_to_list_btn)
        settings["messages"]["results"].append(previous_btn)
        settings["messages"]["results"].append(next_btn)
        settings["messages"]["results"].append(total_num_results_label)
        settings["messages"]["results"].append(pages_label)

        # Print out labels
        labels = team_info_labels(attributes)
        stat_index = 0
        # Spacing values for each of the stats
        spacing_list = [60, 40, 55, 90, 100, 115, 115, 40]
        # Calculate the maximum number of stat fields that will fit on screen
        max_team_fields = len(spacing_list[:-1]) + (win_search.width - sum(spacing_list[:-1])) / spacing_list[-1]
        # Calculate the left border of the stats based on the number and width of the stats
        left_border = (
            win_width
            - sum(spacing_list[:-1])
            - (len(labels[:max_team_fields]) - len(spacing_list) + 1) * spacing_list[-1]
        ) / 2
        msg_x = left_border
        msg_y = add_to_list_btn.bottom + 5

        for info_label in labels[:max_team_fields]:
            team_label = Label(
                text=info_label,
                font=std_tf_font_bold,
                width=spacing_list[stat_index] - 5,
                height=std_tf_height,
                x=msg_x,
                y=msg_y,
                color=title_color,
            )
            settings["messages"]["results"].append(team_label)
            msg_x += spacing_list[stat_index]

            if stat_index < len(spacing_list) - 1:
                stat_index += 1

        msg_y += std_tf_height + 5

        # Print out teams
        for team in results_list.db[index_range[0] : index_range[1]]:
            msg_x = left_border
            team_stats = team_info(team, attributes)
            stat_index = 0

            bio_btn = Button(
                title=team_stats[0],
                width=spacing_list[stat_index] - 5,
                height=15,
                x=msg_x,
                y=msg_y,
                action=(team_bio_btn_func, team),
            )
            settings["messages"]["results"].append(bio_btn)
            msg_x += spacing_list[stat_index]
            stat_index += 1

            for team_stat in team_stats[1:max_team_fields]:
                team_label = Label(
                    text=team_stat,
                    font=small_button_font,
                    width=spacing_list[stat_index] - 5,
                    height=std_tf_height,
                    x=msg_x,
                    y=msg_y,
                    color=title_color,
                )

                settings["messages"]["results"].append(team_label)
                msg_x += spacing_list[stat_index]
                if stat_index < len(spacing_list) - 1:
                    stat_index += 1

            msg_y += std_tf_height

        for results_msg in settings["messages"]["results"]:
            view.add(results_msg)

    # ========== Add components to view and add view to window ==========
    for msg in general_display:
        view.add(msg)
    for msg in settings["messages"]["search"]:
        view.add(msg)
    for msg in settings["messages"]["sort"]:
        view.add(msg)
    for msg in settings["messages"]["results"]:
        view.add(msg)

    win_search.add(view)
    view.become_target()
    win_search.show()
Пример #2
0
def open_pick_formation_window(window_x, window_y, db_dict, win_previous):

    general_display = []

    # ========== Window ==========
    win_pick_formation = Window()
    win_pick_formation.title = pick_formation_win_title
    win_pick_formation.auto_position = False
    win_pick_formation.position = (window_x, window_y)
    win_pick_formation.size = (win_width, win_height)
    win_pick_formation.resizable = 0
    win_pick_formation.name = enter_text_title + " Window"
    win_pick_formation.show()

    # ========== Window Image View ==========
    class StartWindowImageView(View):
        def draw(self, c, r):
            c.backcolor = view_backcolor
            c.erase_rect(r)

    view = StartWindowImageView(size=win_pick_formation.size)

    # ========== Title ==========
    title = Label(text=pick_formation_title)
    title.font = title_font
    title.width = title_width
    title.height = title_height
    title.x = (win_pick_formation.width - title_width) / 2
    title.y = top_border
    title.color = title_color
    title.just = 'center'
    general_display.append(title)

    # ========== Button Functions ==========
    def formation_btn_func(formation):
        win_pick_formation.become_target()
        AssignPlayers.open_assign_players_window(win_pick_formation.x, win_pick_formation.y,
                                                 db_dict, formation, win_pick_formation)
        win_pick_formation.hide()

    def formation_list_btn_func():
        generic_formation = {"style": "Generic",
                             "name": "Generic",
                             "description": "Generic formation for picking players to be used with list of formations.",
                             "num_links": 17,
                             "num_defenders": 4,
                             "num_midfielders": 4,
                             "num_attackers": 2,
                             "positions": {
                                 "11": {"index": 0, "symbol": "11", "name": "Spot 11", "links": []},
                                 "10": {"index": 1, "symbol": "10", "name": "Spot 10", "links": []},
                                 "9": {"index": 2, "symbol": "9", "name": "Spot 9", "links": []},
                                 "8": {"index": 3, "symbol": "8", "name": "Spot 8", "links": []},
                                 "7": {"index": 4, "symbol": "7", "name": "Spot 7", "links": []},
                                 "6": {"index": 5, "symbol": "6", "name": "Spot 6", "links": []},
                                 "5": {"index": 6, "symbol": "5", "name": "Spot 5", "links": []},
                                 "4": {"index": 7, "symbol": "4", "name": "Spot 4", "links": []},
                                 "3": {"index": 8, "symbol": "3", "name": "Spot 3", "links": []},
                                 "2": {"index": 9, "symbol": "2", "name": "Spot 2", "links": []},
                                 "1": {"index": 10, "symbol": "1", "name": "Spot 1", "links": []}}}
        win_pick_formation.become_target()
        AssignPlayers.open_assign_players_window(win_pick_formation.x, win_pick_formation.y,
                                                 db_dict, generic_formation, win_pick_formation)
        win_pick_formation.hide()

    def back_btn_func():
        win_pick_formation.become_target()
        win_previous.show()
        win_pick_formation.hide()

    # ========== Formation Button Declarations ==========
    formation_button_width = 200
    msg_y = title.bottom

    # Sort DB so it is consistent
    db_dict['formation_db'][1].sort(['name'])

    for formation in db_dict['formation_db'][1].db:
        formation_btn = Button(title=formation['name'],
                                  font=std_tf_font,
                                  width=formation_button_width, height=std_tf_height,
                                  x=(win_pick_formation.width - formation_button_width)/2, y=msg_y,
                                  action=(formation_btn_func, formation))
        general_display.append(formation_btn)

        msg_y += std_tf_height + 1

    msg_y += 9

    formation_list_btn = Button(title='Use Formation List',
                                font=std_tf_font,
                                width=formation_button_width, height=std_tf_height,
                                x=(win_pick_formation.width - formation_button_width)/2, y=msg_y,
                                action=formation_list_btn_func)
    general_display.append(formation_list_btn)

    msg_y += std_tf_height + 10

    back_btn = Button('Back',
                      font=std_tf_font_bold,
                      width=button_width, height=button_height,
                      x=(win_pick_formation.width - button_width)/2, y=msg_y,
                      action=back_btn_func)
    general_display.append(back_btn)

    # ========== Add buttons to window ==========
    for item in general_display:
        view.add(item)

    win_pick_formation.add(view)
    view.become_target()
    win_pick_formation.show()
Пример #3
0
def open_start_menu(window_x, window_y, db_dict):

    view_item_list = []

    # Load console type
    settings = {'console_type': ''}
    with open(config_filename, 'r') as f:
        settings["console_type"] = json.load(f)['console_type']
        f.close()

    # ========== Window ==========
    win_start = Window()
    win_start.title = start_win_title
    win_start.auto_position = False
    win_start.position = (window_x, window_y)
    win_start.size = (win_width, win_height)
    win_start.resizable = 0
    win_start.name = start_title + " Window"

    # ========== Window Image View ==========
    class StartWindowImageView(View):
        def draw(self, c, r):
            c.backcolor = view_backcolor
            c.erase_rect(r)
            image_pos = ((win_start.width - start_window_image.width)/2, search_btn.bottom + title_border)
            src_rect = start_window_image.bounds
            dst_rect = Geometry.offset_rect(src_rect, image_pos)
            start_window_image.draw(c, src_rect, dst_rect)

    view = StartWindowImageView(size=win_start.size)

    # ========== Start Window Image ==========
    start_window_image = Image(file='Images/start_menu_image.jpg')

    # ========== Title ==========
    title = Label(text=start_title)
    title.font = title_font
    title.width = title_width
    title.height = title_height
    title.x = (win_width - title_width) / 2
    title.y = top_border
    title.color = title_color
    title.just = 'center'
    view_item_list.append(title)

    # ========== Sort Order Radio Buttons ==========
    def save_console_type():
        """
        Save the console type
        """

        # Load configurations
        from AppConfig import config_filename
        with open(config_filename, 'r') as config_file:
            configurations = json.load(config_file)
            config_file.close()

        # Edit configurations
        configurations['console_type'] = settings["console_type"]

        # Save the settings
        with open(config_filename, 'w') as config_file:
            json.dump(configurations, config_file)
            config_file.close()

    def get_attribute_console_rg():
        settings["console_type"] = console_radio_group.value
        win_start.become_target()
        save_console_type()

    console_radio_group = RadioGroup(action=get_attribute_console_rg)

    console_radio_btn_width = 75
    console_label_width = 80
    radio_btn_space = 5

    console_rg_label = Label(text="Sort Order:", font=std_tf_font, width=console_label_width, height=std_tf_height,
                            color=title_color)
    console_rg_label.x = (win_start.width - 2 * console_radio_btn_width - radio_btn_space - console_label_width) / 2
    console_rg_label.y = title.bottom + radio_btn_space
    view_item_list.append(console_rg_label)

    playstation_radio_btn = RadioButton("PlayStation")
    playstation_radio_btn.width = console_radio_btn_width
    playstation_radio_btn.x = console_rg_label.right
    playstation_radio_btn.y = console_rg_label.top
    playstation_radio_btn.group = console_radio_group
    playstation_radio_btn.value = 'PLAYSTATION'
    view_item_list.append(playstation_radio_btn)

    xbox_radio_btn = RadioButton("Xbox")
    xbox_radio_btn.width = console_radio_btn_width
    xbox_radio_btn.x = playstation_radio_btn.right + radio_btn_space
    xbox_radio_btn.y = playstation_radio_btn.top
    xbox_radio_btn.group = console_radio_group
    xbox_radio_btn.value = 'XBOX'
    view_item_list.append(xbox_radio_btn)

    if settings["console_type"] in ['PLAYSTATION', 'XBOX']:
        console_radio_group.value = settings["console_type"]
    else:
        print "Invalid console type."

    # ========== Button Declarations ==========
    search_btn = Button("Search")
    teams_btn = Button("Teams")
    files_btn = Button("Files")

    button_list = [search_btn,
                   teams_btn,
                   files_btn]

    # ========== Button Functions ==========
    def search_btn_func():
        win_start.hide()
        SearchMenu.open_search_menu(win_start.x, win_start.y, db_dict)

    def teams_btn_func():
        win_start.hide()
        TeamsMenu.open_teams_menu(win_start.x, win_start.y, db_dict)

    def files_btn_func():
        win_start.hide()
        FilesMenu.open_files_menu(win_start.x, win_start.y, db_dict)

    # ========== Buttons ==========
    search_btn.x = (win_width - len(button_list)*button_width - (len(button_list)-1)*button_spacing) / 2
    search_btn.y = console_rg_label.bottom + title_border
    search_btn.height = button_height
    search_btn.width = button_width
    search_btn.font = button_font
    search_btn.action = search_btn_func
    search_btn.style = 'default'
    search_btn.color = button_color
    search_btn.just = 'right'
    view_item_list.append(search_btn)

    teams_btn.x = button_spacing + search_btn.right
    teams_btn.y = search_btn.top
    teams_btn.height = button_height
    teams_btn.width = button_width
    teams_btn.font = button_font
    teams_btn.action = teams_btn_func
    teams_btn.style = 'default'
    teams_btn.color = button_color
    teams_btn.just = 'right'
    view_item_list.append(teams_btn)

    files_btn.x = button_spacing + teams_btn.right
    files_btn.y = search_btn.top
    files_btn.height = button_height
    files_btn.width = button_width
    files_btn.font = button_font
    files_btn.action = files_btn_func
    files_btn.style = 'default'
    files_btn.color = button_color
    files_btn.just = 'right'
    view_item_list.append(files_btn)

    # ========== Add components to view and add view to window ==========
    for item in view_item_list:
        view.add(item)

    win_start.add(view)
    view.become_target()
    win_start.show()
Пример #4
0
def open_enter_text_window(window_x, window_y, db_dict, settings, box_type, fill_text='', file_prefix=''):

    general_display = []

    if box_type == 'rename':
        title = 'Rename File'
        old_file_name = fill_text
        message_text = 'Enter new file name.'
    elif box_type == 'duplicate':
        title = 'Duplicate File'
        old_file_name = fill_text
        message_text = 'Enter new file name.'
    elif box_type == 'download':
        title = 'Download Player Database'
        message_text = 'Enter player database name.'
        download_settings = {'overwrite_counter': 0, 'last_entered_text': ''}
    else:
        title = 'Enter Text'
        message_text = 'Enter text.'

    # ========== Window ==========
    win_enter_text = Window()
    win_enter_text.title = title
    win_enter_text.auto_position = False
    win_enter_text.position = (window_x+100, window_y+100)
    win_enter_text.size = (win_width-200, win_height-400)
    win_enter_text.resizable = 0
    win_enter_text.name = enter_text_title + " Window"
    win_enter_text.show()

    # ========== Window Image View ==========
    class StartWindowImageView(View):
        def draw(self, c, r):
            c.backcolor = view_backcolor
            c.erase_rect(r)

    view = StartWindowImageView(size=win_enter_text.size)

    # ========== Title ==========
    title = Label(text=title)
    title.font = title_font
    title.width = title_width
    title.height = title_height
    title.x = (win_enter_text.width - title_width) / 2
    title.y = top_border
    title.color = title_color
    title.just = 'center'
    general_display.append(title)

    # ========== Message Label ==========
    message = Label(font=title_font_2, width=win_enter_text.width - 50, height=title_height,
                    x=25, y=title.bottom + top_border, color=title_color, just='center')
    message.text = message_text
    general_display.append(message)

    # ========== Button Declarations ==========
    enter_btn = Button("Enter")
    back_btn = Button("Back")

    # ========== Button Functions ==========
    def enter_btn_func():
        # Rename file
        if box_type == 'rename':

            # Get new name
            new_file_name = value_tf.value

            if len(new_file_name) > 0:

                if not isfile('JSONs/' + file_prefix + new_file_name + '.json'):
                    # Rename file
                    rename('JSONs/' + file_prefix + old_file_name + '.json',
                           'JSONs/' + file_prefix + new_file_name + '.json')

                    # Disable pick file back button in case the selected file has changed
                    settings['file_changes'] = True

                    PickFile.open_pick_file_window(window_x, window_y, db_dict, settings)
                    win_enter_text.hide()

                else:
                    message.text = "A file with that name already exists."

            else:
                message.text = "File name must be at least 1 character."

        # Duplicate file
        elif box_type == 'duplicate':

            # Get new name
            duplicate_file_name = value_tf.value

            if len(duplicate_file_name) > 0:

                if not isfile('JSONs/' + file_prefix + duplicate_file_name + '.json'):
                    # Create duplicate file
                    copyfile('JSONs/' + file_prefix + old_file_name + '.json',
                             'JSONs/' + file_prefix + duplicate_file_name + '.json')

                    PickFile.open_pick_file_window(window_x, window_y, db_dict, settings)
                    win_enter_text.hide()

                else:
                    message.text = "A file with that name already exists."

            else:
                message.text = "File name must be at least 1 character."

        elif box_type == 'download':
            valid_name = False

            # Get new player database name
            new_player_db_name = value_tf.value

            if new_player_db_name != download_settings['last_entered_text']:
                download_settings['overwrite_counter'] = 0
                message.text = message_text

            if len(new_player_db_name) > 0:

                if not isfile('JSONs/play_db_' + new_player_db_name + '.json'):
                    valid_name = True

                else:
                    download_settings['last_entered_text'] = new_player_db_name

                    if download_settings['overwrite_counter'] == 0:
                        download_settings['overwrite_counter'] += 1
                        message.text = "File already exists. Overwrite?"
                    elif download_settings['overwrite_counter'] == 1:
                        download_settings['overwrite_counter'] += 1
                        message.text = "Are you sure you want to overwrite?"
                    elif download_settings['overwrite_counter'] == 2:
                        download_settings['overwrite_counter'] += 1
                        message.text = "Really, really, really sure?"
                    elif download_settings['overwrite_counter'] >= 3:
                        valid_name = True

                if valid_name:
                    # Open status window to start download of players
                    StatusWindow.open_status_window(win_enter_text.x, win_enter_text.y, db_dict,
                                                    get_prices=sort_order_radio_group.value,
                                                    file_name=new_player_db_name, settings=settings,
                                                    win_previous=win_enter_text, win_next='FilesMenu')
                    win_enter_text.hide()

            else:
                message.text = "File name must be at least 1 character."

    def back_btn_func():
        if box_type == 'download':
            FilesMenu.open_files_menu(window_x, window_y, db_dict, settings)
        else:
            PickFile.open_pick_file_window(window_x, window_y, db_dict, settings)
        win_enter_text.hide()

    # ========== Buttons ==========
    enter_btn.x = (win_enter_text.width - 2*button_width - button_spacing) / 2
    enter_btn.y = win_enter_text.height - 70
    enter_btn.height = button_height
    enter_btn.width = button_width
    enter_btn.font = button_font
    enter_btn.action = enter_btn_func
    enter_btn.style = 'default'
    enter_btn.color = button_color
    enter_btn.just = 'right'
    general_display.append(enter_btn)

    back_btn.x = enter_btn.right + button_spacing
    back_btn.y = enter_btn.top
    back_btn.height = button_height
    back_btn.width = button_width
    back_btn.font = button_font
    back_btn.action = back_btn_func
    back_btn.style = 'default'
    back_btn.color = button_color
    back_btn.just = 'right'
    general_display.append(back_btn)

    # ========== Value Textfield ==========
    value_tf = TextField()
    value_tf.width = 200
    value_tf.x = (win_enter_text.width - value_tf.width) / 2
    value_tf.y = enter_btn.top - 65
    value_tf.height = 25
    value_tf.font = std_tf_font
    value_tf.value = fill_text
    general_display.append(value_tf)

    def get_attribute_sort_order_rg():
        settings['order_rg'] = sort_order_radio_group.value
        win_enter_text.become_target()

    sort_order_radio_group = RadioGroup(action=get_attribute_sort_order_rg)

    prices_label_width = 85
    prices_button_width = 50
    prices_label = Label(text="Get Prices?:", font=std_tf_font, width=prices_label_width, height=std_tf_height,
                         color=title_color)
    prices_label.x = (win_enter_text.width - 2*prices_button_width - 10 - prices_label_width) / 2
    prices_label.y = enter_btn.top - 38
    prices_label.just = 'center'

    prices_yes = RadioButton("Yes")
    prices_yes.width = prices_button_width
    prices_yes.x = prices_label.right + 5
    prices_yes.y = prices_label.top
    prices_yes.group = sort_order_radio_group
    prices_yes.value = True

    prices_no = RadioButton("No")
    prices_no.width = prices_button_width
    prices_no.x = prices_yes.right + 5
    prices_no.y = prices_label.top
    prices_no.group = sort_order_radio_group
    prices_no.value = False

    sort_order_radio_group.value = True

    if box_type == 'download':
        value_tf.y = enter_btn.top - 75

        general_display.append(prices_label)
        general_display.append(prices_yes)
        general_display.append(prices_no)

    # ========== Add buttons to window ==========
    for item in general_display:
        view.add(item)

    win_enter_text.add(view)
    view.become_target()
    win_enter_text.show()
Пример #5
0
def open_player_bio_window(window_x, window_y, player, win_previous, db_dict=None, file_name=None, current_list=None,
                           roster=None, pos_symbol=None, input_formation=None, pick_formations_page=None):

    if current_list is None:
        current_list = PlayerDB.PlayerDB()

    # ========== Window ==========
    win_player_bio = Window()
    win_player_bio.title = player_bio_win_title
    win_player_bio.auto_position = False
    win_player_bio.position = (window_x, window_y)
    win_player_bio.size = (win_width, win_height)
    win_player_bio.resizable = 0
    win_player_bio.name = player_bio_title + " Window"
    win_player_bio.show()

    # ========== Window Image View ==========
    class PlayerBioWindowImageView(View):
        def draw(self, c, r):
            c.backcolor = view_backcolor
            c.erase_rect(r)

            # Background image
            image_pos = ((player_name_label.left - player_background.width)/2, 5)
            src_rect = player_background.bounds
            dst_rect = Geometry.offset_rect(src_rect, image_pos)
            player_background.draw(c, src_rect, dst_rect)

            # Lines between summary stats
            c.forecolor = stat_line_color
            c.fill_rect((dst_rect[0]+22, dst_rect[1]+stat_line_y,
                         dst_rect[2]-22, dst_rect[1]+stat_line_y+1))
            c.fill_rect((dst_rect[0]+22, dst_rect[1]+stat_line_y+stat_line_spacing,
                         dst_rect[2]-22, dst_rect[1]+stat_line_y+stat_line_spacing+1))

            # Headshot
            image_pos = (image_pos[0]+player_headshot_pos[0], player_headshot_pos[1])
            src_rect = player_headshot.bounds
            headshot_dst_rect = Geometry.offset_rect(src_rect, image_pos)
            player_headshot.draw(c, src_rect, headshot_dst_rect)

            # Club
            if 'normal' in player['club']['imageUrls']:
                image_url = player['club']['imageUrls']['normal']['large']
            # FIFA 15 compatibility
            elif 'dark' in player['club']['imageUrls']:
                image_url = player['club']['imageUrls']['dark']['large']
            ratio = 0.75
            image_file_name = 'club_' + str(player['club']['id']) + '_' + str(ratio)
            image_file_name = save_small_image(image_url, image_file_name, ratio)
            club_image = Image(file=image_file_name)
            club_image_pos = club_pos
            club_rect = club_image.bounds
            club_dst_rect = Geometry.offset_rect(club_rect, club_image_pos)
            club_image.draw(c, club_rect, club_dst_rect)

            # Nation
            if 'imageUrls' in player['nation']:
                image_url = player['nation']['imageUrls']['large']
            # FIFA 15 compatibility
            elif 'imageUrl' in player['nation']:
                image_url = player['nation']['imgUrl']
            ratio = 0.75
            image_file_name = 'nation_' + str(player['nation']['id']) + '_' + str(ratio)
            image_file_name = save_small_image(image_url, image_file_name, ratio)
            nation_image = Image(file=image_file_name)
            nation_image_pos = (club_image_pos[0], club_image_pos[1]+club_image.size[1]+nation_spacing)
            nation_rect = nation_image.bounds
            nation_dst_rect = Geometry.offset_rect(nation_rect, nation_image_pos)
            nation_image.draw(c, nation_rect, nation_dst_rect)

            # Coins symbol
            image_file_name = 'Images/coins.png'
            coins_image = Image(file=image_file_name)
            coins_image_pos = coins_pos
            coins_rect = coins_image.bounds
            coins_dst_rect = Geometry.offset_rect(coins_rect, coins_image_pos)
            coins_image.draw(c, coins_rect, coins_dst_rect)

    view = PlayerBioWindowImageView(size=win_player_bio.size)

    # ========== Player Headshot ==========
    image_url = player['headshotImgUrl']
    image_file_name = player['id'] + '_full'
    # FIFA 15 compatibility
    if "130x130" in image_url:
        ratio = 120.0/130.0
        image_file_name = save_small_image(image_url, image_file_name, ratio)
    elif "120x120" in image_url:
        image_file_name = save_image(image_url, image_file_name)
    player_headshot = Image(file=image_file_name)

    # ========== Player Background ==========
    # Assign player background card
    if player['color'] in ['award_winner', 'bronze', 'confederation_champions_motm', 'easports', 'fut_champions_bronze',
                           'fut_champions_gold', 'fut_champions_silver', 'gold', 'green', 'halloween', 'legend', 'motm',
                           'motm_2', 'movember', 'ones_to_watch', 'pink_gold', 'pink', 'purple', 'rare_bronze',
                           'rare_gold', 'rare_silver', 'red_blue', 'silver', 'sbc_base', 'squad_building_challenge',
                           'teal', 'tott', 'tots_bronze', 'tots_gold', 'tots_silver', 'totw_bronze', 'totw_gold',
                           'totw_silver', 'toty']:
        background_file = 'Images/Cards/' + player['color'] + '.png'
    else:
        background_file = 'Images/Cards/idk.png'

    player_background = Image(file=background_file)

    # Assign positioning for player card based on type
    if player['color'] in ['legend']:
        player_headshot_pos = (43, 15)
        club_pos = (51, 76)
        nation_spacing = 2
        coins_pos = (155, 222)
        stat_line_y = 173
        stat_line_spacing = 21
        name_y = 138
        rating_pos = (33, 35)
        stats_y = 159
        card_rating_pos_color = black
        card_name_color = black
        card_stat_color = black
        stat_line_color = barely_darker
        coins_color = black

    elif player['color'] in ['green', 'movember', 'pink_gold']:
        player_headshot_pos = (43, 15)
        club_pos = (51, 76)
        nation_spacing = 1
        coins_pos = (155, 222)
        stat_line_y = 173
        stat_line_spacing = 21
        name_y = 138
        rating_pos = (33, 35)
        stats_y = 159
        card_rating_pos_color = black
        card_name_color = black
        card_stat_color = white
        stat_line_color = barely_lighter
        coins_color = black

    elif player['color'] in ['tott']:
        player_headshot_pos = (43, 15)
        club_pos = (51, 76)
        nation_spacing = 1
        coins_pos = (155, 222)
        stat_line_y = 173
        stat_line_spacing = 21
        name_y = 138
        rating_pos = (33, 35)
        stats_y = 159
        card_rating_pos_color = black
        card_name_color = white
        card_stat_color = black
        stat_line_color = barely_darker
        coins_color = black

    elif player['color'] in ['confederation_champions_motm', 'motm', 'motm_2', 'pink', 'purple', 'teal']:
        player_headshot_pos = (43, 15)
        club_pos = (51, 76)
        nation_spacing = 1
        coins_pos = (155, 222)
        stat_line_y = 173
        stat_line_spacing = 21
        name_y = 138
        rating_pos = (33, 35)
        stats_y = 159
        card_rating_pos_color = black
        card_name_color = white
        card_stat_color = white
        stat_line_color = barely_lighter
        coins_color = white

    elif player['color'] in ['halloween', 'easports', 'ones_to_watch', 'sbc_base', 'toty']:
        player_headshot_pos = (43, 15)
        club_pos = (51, 76)
        nation_spacing = 1
        coins_pos = (155, 222)
        stat_line_y = 173
        stat_line_spacing = 21
        name_y = 138
        rating_pos = (33, 35)
        stats_y = 159
        card_rating_pos_color = white
        card_name_color = white
        card_stat_color = white
        stat_line_color = barely_lighter
        coins_color = white

    elif player['color'] in ['award_winner', 'tots_gold', 'tots_silver', 'tots_bronze']:
        player_headshot_pos = (43, 15)
        club_pos = (51, 76)
        nation_spacing = 1
        coins_pos = (155, 222)
        stat_line_y = 173
        stat_line_spacing = 21
        name_y = 138
        rating_pos = (33, 35)
        stats_y = 159
        card_rating_pos_color = white
        card_name_color = black
        card_stat_color = white
        stat_line_color = barely_lighter
        coins_color = black

    elif player['color'] in ['totw_gold', 'totw_silver', 'totw_bronze']:
        player_headshot_pos = (43, 15)
        club_pos = (51, 76)
        nation_spacing = 1
        coins_pos = (155, 222)
        stat_line_y = 173
        stat_line_spacing = 21
        name_y = 138
        rating_pos = (33, 35)
        stats_y = 159
        card_rating_pos_color = black
        card_name_color = white
        card_stat_color = white
        stat_line_color = barely_lighter
        coins_color = white

    elif player['color'] in ['rare_gold', 'rare_silver', 'rare_bronze']:
        player_headshot_pos = (43, 15)
        club_pos = (51, 76)
        nation_spacing = 1
        coins_pos = (155, 222)
        stat_line_y = 172
        stat_line_spacing = 21
        name_y = 138
        rating_pos = (33, 35)
        stats_y = 158
        card_rating_pos_color = black
        card_name_color = black
        card_stat_color = black
        stat_line_color = barely_darker
        coins_color = black

    elif player['color'] in ['gold', 'silver', 'bronze']:
        player_headshot_pos = (43, 15)
        club_pos = (51, 76)
        nation_spacing = 3
        coins_pos = (155, 222)
        stat_line_y = 173
        stat_line_spacing = 21
        name_y = 138
        rating_pos = (33, 35)
        stats_y = 159
        card_rating_pos_color = black
        card_name_color = black
        card_stat_color = black
        stat_line_color = barely_darker
        coins_color = black

    else:
        player_headshot_pos = (43, 15)
        club_pos = (51, 76)
        nation_spacing = 1
        coins_pos = (155, 222)
        stat_line_y = 173
        stat_line_spacing = 21
        name_y = 138
        rating_pos = (33, 35)
        stats_y = 159
        card_rating_pos_color = black
        card_name_color = black
        card_stat_color = black
        stat_line_color = barely_darker
        coins_color = black

    # ========== Button Declarations ==========
    add_player_btn = Button()
    back_btn = Button("Back")
    update_price_btn = Button("Update")

    # ========== Button Functions ==========
    def add_player_btn_func():
        # Assign player to roster if that is the current process
        if roster is not None and pos_symbol is not None and input_formation is not None:
            roster[pos_symbol] = player

            win_player_bio.hide()
            AssignPlayers.open_assign_players_window(win_player_bio.x, win_player_bio.y, db_dict,
                                                     input_formation, pick_formations_page, roster)

        # Check if player is already on selected players list
        # Remove player from list
        elif player in current_list.db:
            # Remove
            current_list.db.remove(player)
            # Save
            current_list.sort(['rating'])
            current_list.save(file_name, 'list', True)

            # Switch button title
            add_player_btn.title = "Add Player to List"

        # Add player to the list
        else:
            # Add
            current_list.db.append(player)
            # Save
            current_list.sort(['rating'])
            current_list.save(file_name, 'list', True)

            # Switch button title
            add_player_btn.title = "Remove Player from List"

        win_player_bio.become_target()

    def back_btn_func():
        win_player_bio.hide()
        win_previous.show()

    def update_price_btn_func():
        if db_dict is not None:
            # Get index in player list and player db
            if player in db_dict['player_list'][1].db:
                list_index = db_dict['player_list'][1].db.index(player)
            else:
                list_index = -1
            if player in db_dict['player_db'][1].db:
                db_index = db_dict['player_db'][1].db.index(player)
            else:
                db_index = -1

            # Load console type
            settings = {'console_type': ''}
            with open(config_filename, 'r') as f:
                settings["console_type"] = json.load(f)['console_type']
                f.close()

            # Get updated price
            new_price = Player.Player(player).get_price(settings["console_type"])

            # Update price displayed
            new_price_str = str(new_price)
            if new_price > 999999:
                new_price_str = new_price_str[:-6] + ',' + new_price_str[-6:-3] + ',' + new_price_str[-3:]
            elif new_price > 999:
                new_price_str = new_price_str[:-3] + ',' + new_price_str[-3:]
            elif new_price < 1:
                new_price_str = '?'
            price_label.text = str(new_price_str)

            # Assigned updated price
            if list_index > -1:
                updated_player = db_dict['player_list'][1].db[list_index]
                updated_player['price'] = new_price
                db_dict['player_list'][1].db[list_index] = updated_player
            if db_index > -1:
                updated_player = db_dict['player_db'][1].db[db_index]
                updated_player['price'] = new_price
                db_dict['player_db'][1].db[db_index] = updated_player
            player['price'] = new_price

            # Save
            if list_index > -1:
                db_dict['player_list'][1].sort(['rating'])
                db_dict['player_list'][1].save(db_dict['player_list'][0], 'list', True)
            if db_index > -1:
                db_dict['player_db'][1].sort(['rating'])
                db_dict['player_db'][1].save(db_dict['player_db'][0], 'db', True)

        win_player_bio.become_target()

    # ========== Buttons ==========
    button_x_offset = 85

    add_player_btn.x = win_player_bio.width - button_width - button_x_offset
    add_player_btn.y = top_border
    add_player_btn.height = small_button_height
    add_player_btn.width = button_width
    add_player_btn.font = small_button_font
    add_player_btn.action = add_player_btn_func
    add_player_btn.style = 'default'
    add_player_btn.color = small_button_color
    # Disable button if no lists selected
    if file_name is None and roster is None:
        add_player_btn.enabled = 0

    if roster is not None and pos_symbol is not None and input_formation is not None:
        add_player_btn.title = "Assign Player to Roster"

        # Get list of player base IDs
        base_ids = []
        for player_value in roster.itervalues():
            base_ids.append(player_value['baseId'])

        # Make sure any version player isn't already on team
        if player['baseId'] in base_ids:
            add_player_btn.title = "Player Already on Roster"
            add_player_btn.enabled = 0

    # Check if player is already on selected players list
    elif player in current_list.db:
        add_player_btn.title = "Remove Player from List"
    else:
        add_player_btn.title = "Add Player to List"

    back_btn.x = add_player_btn.left
    back_btn.y = add_player_btn.bottom
    back_btn.height = small_button_height
    back_btn.width = button_width
    back_btn.font = small_button_font
    back_btn.action = back_btn_func
    back_btn.style = 'default'
    back_btn.color = small_button_color

    update_price_btn.x = add_player_btn.right
    update_price_btn.y = add_player_btn.top
    update_price_btn.height = small_button_height*2
    update_price_btn.width = button_width/3
    update_price_btn.font = small_button_font
    update_price_btn.action = update_price_btn_func
    update_price_btn.style = 'default'
    update_price_btn.color = small_button_color
    if db_dict is None:
        update_price_btn.enabled = 0

    # ========== Player Info Labels ==========
    # Get attribute lists
    with open(config_filename, 'r') as f:
        attribute_lists = json.load(f)['player_attributes']
        f.close()

    labels_list = []

    name_width = 300
    rating_big_width = 70

    traits_offset_left = 25
    traits_label_width = 100
    traits_list_label_width = 500 - traits_label_width

    section_label_width = 115

    # ========== Name ==========
    player_name_label = Label(font=title_font, width=name_width, height=title_height, x=(win_width - name_width)/2,
                              y=top_border, color=title_color, just='center')
    labels_list.append(player_name_label)
    player_full_name_label = Label(font=title_tf_font, width=name_width, height=std_tf_height,
                                   x=(win_width - name_width)/2, y=player_name_label.bottom - title_border,
                                   color=title_color, just='center')
    labels_list.append(player_full_name_label)

    # ========== Name on Card ==========
    name_on_card_label = Label(font=std_tf_font_bold, width=player_background.width, height=std_tf_height,
                               x=(player_name_label.left - player_background.width)/2,
                               y=name_y, color=card_name_color, just='center')
    labels_list.append(name_on_card_label)

    # ========== Rating and Position ==========
    rating_big_label = Label(font=title_font_3, width=rating_big_width, height=title_height,
                             x=rating_pos[0], y=rating_pos[1],
                             color=card_rating_pos_color, just='center')
    labels_list.append(rating_big_label)
    position_big_label = Label(font=title_font_6, width=rating_big_width, height=title_height,
                               x=rating_big_label.left, y=rating_big_label.bottom-27,
                               color=card_rating_pos_color, just='center')
    labels_list.append(position_big_label)

    # ========== Traits and Specialities ==========
    traits_label = Label(font=std_tf_font_bold, width=traits_label_width, height=std_tf_height,
                         x=player_full_name_label.left - traits_offset_left,
                         y=player_full_name_label.bottom+title_border*2, color=title_color, just='right')
    labels_list.append(traits_label)
    traits_list_label = Label(font=small_tf_font, width=traits_list_label_width, height=std_tf_height,
                              x=traits_label.right + small_button_spacing,
                              y=traits_label.top+3, color=title_color, just='left')
    labels_list.append(traits_list_label)
    traits_list_label_2 = Label(font=small_tf_font, width=traits_list_label_width, height=std_tf_height,
                                x=traits_label.right + small_button_spacing,
                                y=traits_list_label.bottom, color=title_color, just='left')
    labels_list.append(traits_list_label_2)
    specialities_label = Label(font=std_tf_font_bold, width=traits_label_width, height=std_tf_height,
                               x=traits_label.left,
                               y=traits_list_label_2.bottom, color=title_color, just='right')
    labels_list.append(specialities_label)
    specialities_list_label = Label(font=small_tf_font, width=traits_list_label_width, height=std_tf_height,
                                    x=specialities_label.right + small_button_spacing,
                                    y=specialities_label.top+3, color=title_color, just='left')
    labels_list.append(specialities_list_label)
    specialities_list_label_2 = Label(font=small_tf_font, width=traits_list_label_width, height=std_tf_height,
                                      x=specialities_label.right + small_button_spacing,
                                      y=specialities_list_label.bottom, color=title_color, just='left')
    labels_list.append(specialities_list_label_2)

    # ========== Attributes Under Picture Section ==========
    attr_title_label_width = 35
    attr_label_width = 20
    attribute_x_offset = 30
    label_x = (player_name_label.left - player_background.width)/2 + player_background.width/2 - attribute_x_offset - 10
    label_y = stats_y

    for idx, attr in enumerate(player['attributes']):
        if idx == 3:
            label_x += 2*attribute_x_offset + 10
            label_y = stats_y

        stat_label = Label(font=std_tf_font_bold, width=attr_label_width, height=std_tf_height,
                           x=label_x-attr_label_width-2, y=label_y, color=card_stat_color, just='right')
        stat_label.text = str(attr['value'])
        labels_list.append(stat_label)

        stat_title_label = Label(font=std_tf_font, width=attr_title_label_width, height=std_tf_height,
                                 x=label_x+1, y=label_y, color=card_stat_color, just='left')
        stat_title_label.text = format_attr_name(attr['name'][-3:])
        labels_list.append(stat_title_label)

        label_y += std_tf_height + 1

    # ========== Price Section ==========
    price_width = 80
    price = str(player['price'])
    if player['price'] > 999999:
        price = price[:-6] + ',' + price[-6:-3] + ',' + price[-3:]
    elif player['price'] > 999:
        price = price[:-3] + ',' + price[-3:]
    elif player['price'] < 1:
        price = '?'

    coins_pos = (coins_pos[0] - (9 - len(price)) * 3, coins_pos[1])

    price_label = Label(text=price,font=std_tf_font_bold, width=price_width, height=std_tf_height,
                              x=coins_pos[0] - price_width - 3,
                              y=coins_pos[1], color=coins_color, just='right')
    labels_list.append(price_label)

    # ========== Database Info Section ==========
    db_info_label = Label(font=std_tf_font_bold, width=section_label_width, height=std_tf_height,
                          x=win_player_bio.width * 5 / 50,
                          y=specialities_list_label_2.bottom + int(7.3*title_border), color=title_color, just='center')
    db_info_label.text = "Database Info"
    labels_list.append(db_info_label)

    db_info_title_label_width = 80
    db_info_label_width = 55
    attribute_x_offset = 40
    label_x = db_info_label.left + section_label_width/2 - attribute_x_offset
    label_y = db_info_label.bottom

    for idx, db_info in enumerate(attribute_lists['db']):
        if idx == 5:
            attribute_x_offset = 85
            db_info_title_label_width = 60
            db_info_label_width = 50
            label_x = db_info_label.left + section_label_width/2 + attribute_x_offset
            label_y = db_info_label.bottom

        if db_info == 'modelName':
                db_info_label_width = 95

        stat_title_label = Label(font=small_tf_font, width=db_info_title_label_width, height=std_tf_height,
                                 x=label_x-db_info_title_label_width, y=label_y, color=title_color, just='right')
        stat_title_label.text = format_attr_name(db_info) + ':'
        labels_list.append(stat_title_label)

        stat_label = Label(font=small_tf_font, width=db_info_label_width, height=std_tf_height,
                           x=label_x, y=label_y, color=title_color, just='right')
        if db_info in ['clubId', 'leagueId', 'nationId']:
            stat_label.text = str(player[db_info[:-2]]['id'])
        else:
            stat_label.text = str(player[db_info])
        labels_list.append(stat_label)

        label_y += std_tf_height

    # ========== Personal Section ==========
    personal_label = Label(font=std_tf_font_bold, width=section_label_width, height=std_tf_height,
                           x=win_player_bio.width * 29 / 50,
                           y=specialities_list_label_2.bottom + top_border, color=title_color, just='center')
    personal_label.text = "Personal"
    labels_list.append(personal_label)

    personal_title_stat_width = 100
    personal_stat_width = 65
    personal_stat_just = 'right'
    personal_x_offset = personal_stat_width + 60
    label_x = personal_label.left + section_label_width/2 - personal_x_offset
    label_y = personal_label.bottom

    for idx, personal in enumerate(attribute_lists['personal']):
        if idx == 7:
            personal_title_stat_width = 75
            personal_stat_width = 250
            personal_stat_just = 'left'
            personal_x_offset = personal_title_stat_width - 55
            label_x = personal_label.left + section_label_width/2 + personal_x_offset
            label_y = personal_label.bottom

        # Skip these since other labels use them
        if personal == 'positionFull':
            continue

        stat_title_label = Label(font=small_tf_font, width=personal_title_stat_width, height=std_tf_height,
                                 x=label_x-personal_title_stat_width, y=label_y, color=title_color, just='right')
        stat_title_label.text = format_attr_name(personal) + ':'
        labels_list.append(stat_title_label)

        color = white
        # Change color for rating and potential
        if personal in ['rating', 'potential']:
            color = attr_color(player[personal])
        # Change color for quality and color
        elif personal in ['quality', 'color', 'playerType']:
            color = quality_color(player[personal])

        stat_label = Label(font=small_tf_font, width=personal_stat_width, height=std_tf_height,
                           x=label_x+5, y=label_y, color=color, just=personal_stat_just)
        if personal == 'height':
            centimeters = player[personal]
            converted_height = convert_height(centimeters, 'string')
            stat_label.text = '%s (%d cm)' % (converted_height, centimeters)
        elif personal == 'weight':
            kilograms = player[personal]
            pounds = convert_weight(kilograms)
            stat_label.text = '%.1f lb (%d kg)' % (pounds, kilograms)
        elif personal in ['club', 'nation']:
            stat_label.text = ascii_text(player[personal]['name'])
        elif personal in ['league']:
            stat_label.text = '%s (%s)' % (ascii_text(player[personal]['name']),
                                           ascii_text(player[personal]['abbrName']))
        elif personal == 'birthdate':
            b_day = format_birthday(player['birthdate'])
            stat_label.text = b_day
        elif personal == 'position':
            stat_label.text = '%s (%s)' % (player['positionFull'], player[personal])
        else:
            stat_label.text = str(player[personal])
        labels_list.append(stat_label)

        label_y += std_tf_height

    # ========== Detailed Attribute Sections ==========
    attribute_group_list = ['characteristics', 'pace', 'shooting', 'passing',
                            'goalkeeping', 'dribbling', 'defending', 'physicality']

    group_spacing = (win_player_bio.width - 4*section_label_width)/5
    group_x = group_spacing
    group_y = personal_label.bottom + 175

    for idx, group in enumerate(attribute_group_list):

        if idx == 4:
            group_x = group_spacing
            group_y += 150

        stat_group_label = Label(font=std_tf_font_bold, width=section_label_width, height=std_tf_height,
                                 x=group_x, y=group_y, color=title_color, just='center')
        stat_group_label.text = group.capitalize()
        if idx in [1, 2, 3, 5, 6, 7] and not player['isGK']:
            stat_group_label.text += ':'
        labels_list.append(stat_group_label)

        if idx in [1, 2, 3, 5, 6, 7] and not player['isGK']:
            rating_offset = [0, 25, 12, 16, 0, 8, 6, 2]
            stat_group_rating_label = Label(font=std_tf_font_bold, width=20, height=std_tf_height,
                                            x=stat_group_label.right - rating_offset[idx],
                                            y=group_y, color=title_color, just='center')
            stat_group_rating_label.text = str(player['attributes'][idx - (1 + int(idx/4))]['value'])
            stat_group_rating_label.color = attr_color(player['attributes'][idx - (1 + int(idx/4))]['value'])
            labels_list.append(stat_group_rating_label)

        # ========== Detailed Attribute Stats Sections ==========
        stat_title_label_width = 110
        stat_width = 25
        label_y = stat_group_label.bottom
        label_x = stat_group_label.left + section_label_width/2 + 25

        if group == 'characteristics':
            stat_width = 60

        for attribute in attribute_lists[group]:
            stat_title_label = Label(font=small_tf_font, width=stat_title_label_width, height=std_tf_height,
                                     x=label_x-stat_title_label_width, y=label_y, color=title_color, just='right')
            stat_title_label.text = format_attr_name(attribute) + ':'
            labels_list.append(stat_title_label)

            color = white
            if type(player[attribute]) is int and attribute not in ['weakFoot', 'skillMoves']:
                color = attr_color(player[attribute])

            elif attribute in ['weakFoot', 'skillMoves']:
                color = attr_color(40 + 10*player[attribute])

            stat_label = Label(font=small_tf_font, width=stat_width, height=std_tf_height,
                               x=label_x, y=label_y, color=color, just='right')
            if attribute in ['weakFoot', 'skillMoves']:
                stat_label.text = '* '*player[attribute]
            else:
                stat_label.text = str(player[attribute])
            labels_list.append(stat_label)

            label_y += std_tf_height

        group_x += section_label_width + group_spacing

    # ========== Label Text ==========
    # Player's normal name
    player_name = ascii_text(player['name'])
    player_name_label.text = player_name
    name_on_card_label.text = player_name

    # Player's name
    player_full_name = ascii_text(player['firstName']) + ' ' + ascii_text(player['lastName'])
    player_full_name_label.text = player_full_name

    # Player's rating
    rating_big_label.text = str(player['rating'])

    # Player's position
    position_big_label.text = player['position']

    # Player's traits
    traits_label.text = 'Traits:'
    traits_list = ''
    traits_list_2 = ''
    if player['traits'] is not None:
        index = 0
        for trait in player['traits']:
            if len(traits_list + trait) < 70:
                traits_list += trait + ', '
                index += 1
            else:
                break
        for trait in player['traits'][index:]:
            traits_list_2 += trait + ', '
    else:
        traits_list = 'No traits..'

    if len(traits_list_2) > 0:
        traits_list_label.text = traits_list[:-1]
    else:
        traits_list_label.text = traits_list[:-2]
    traits_list_label_2.text = traits_list_2[:-2]

    # Player's specialities
    specialities_label.text = 'Specialities:'
    specialities_list = ''
    specialities_list_2 = ''
    if player['specialities'] is not None:
        index = 0
        for speciality in player['specialities']:
            if len(specialities_list + speciality) < 70:
                specialities_list += speciality + ', '
                index += 1
            else:
                break
        for speciality in player['specialities'][index:]:
            specialities_list_2 += speciality + ', '
    else:
        specialities_list = 'No specialities..'

    if len(specialities_list_2) > 0:
        specialities_list_label.text = specialities_list[:-1]
    else:
        specialities_list_label.text = specialities_list[:-2]
    specialities_list_label_2.text = specialities_list_2[:-2]

    # ========== Add buttons to window ==========
    view.add(add_player_btn)
    view.add(back_btn)
    view.add(update_price_btn)

    for label in labels_list:
        view.add(label)

    win_player_bio.add(view)
    view.become_target()
    win_player_bio.show()
Пример #6
0
def open_attribute_window(window_x, window_y, db_dict, attr_dict, attr_list, attr_type, settings):

    # ========== Window ==========
    win_attribute = Window()
    win_attribute.title = attribute_win_title
    win_attribute.auto_position = False
    win_attribute.position = (window_x, window_y)
    win_attribute.size = (win_width, 500)
    win_attribute.resizable = 0
    win_attribute.name = attribute_title + " Window"
    win_attribute.show()

    # ========== Window Image View ==========
    class AddAttributeWindowImageView(View):
        def draw(self, c, r):
            c.backcolor = view_backcolor
            c.erase_rect(r)

    view = AddAttributeWindowImageView(size=win_attribute.size)

    attribute_display_list = []

    # ========== Title ==========
    title = Label(text=attribute_title)
    title.font = title_font
    title.width = title_width
    title.height = title_height
    title.x = (win_width - title_width) / 2
    title.y = top_border
    title.color = title_color
    title.just = 'center'
    view.add(title)

    # ========== Button Declarations ==========
    enter_btn = Button("Enter")
    erase_btn = Button("Erase List")
    back_btn = Button("Back")

    # ========== Radio Button Action ==========
    def selection_made():
        enter_btn.enabled = 1
        win_attribute.become_target()

    def comp_selection_made():
        win_attribute.become_target()

    def attribute_button_func(attr_value):
        # Check for doubles
        if attr_list.count(attr_value) == 0:
            attr_list.append(attr_value)

        show_attributes(attribute_display_list)
        erase_btn.enabled = 1
        win_attribute.become_target()

    # ========== Attribute Radio Buttons ==========
    radio_group = RadioGroup(action=selection_made)
    radio_button_list = []
    buttons_per_column = 11

    config_file = '_attributes'
    if attr_type[:4] == 'play':
        config_file = 'player' + config_file
    elif attr_type[:4] == 'form':
        config_file = 'formation' + config_file
    elif attr_type[:4] == 'team':
        config_file = 'team' + config_file
    else:
        print "Invalid attribute type."

    with open(config_filename, 'r') as f:
            attributes_list = json.load(f)[config_file]['all']
            f.close()

    for idx, attribute in enumerate(attributes_list):
        if attr_type[-6:] == 'search':
            button = RadioButton(attribute)
            button.group = radio_group
            button.value = attribute
            button.title = format_attr_name(attribute)
        elif attr_type[-4:] == 'sort':
            button = Button()
            button.action = (attribute_button_func, attribute)
            button.title = format_attr_name(attribute)
        else:
            print "Invalid attribute type."

        if attr_type[:4] == 'play':
            if idx < buttons_per_column:
                button.width = 45
                button.x = (idx / buttons_per_column) * (button.width + 5) + 5
            elif idx < 3*buttons_per_column:
                button.width = 100
                button.x = (idx / buttons_per_column) * (button.width + 5) - 50
            elif idx < 4*buttons_per_column:
                button.width = 110
                button.x = (idx / buttons_per_column) * (button.width + 5) - 80
            else:
                button.width = 100
                button.x = (idx / buttons_per_column) * (button.width + 5) - 40

            button.y = (idx % buttons_per_column) * 25 + title.bottom - 5

            # Added for 81st item
            """if idx == 80:
                button.x = 7 * (button.width + 5) - 40
                button.y = 10 * 25 + title.bottom + 5"""

        elif attr_type[:4] == 'form':
            button.width = 150
            button.x = (win_attribute.width - button.width) / 2
            button.y = idx * 25 + title.bottom + 5

        elif attr_type[:4] == 'team':
            if idx < buttons_per_column:
                button.width = 150
                button.x = win_attribute.width / 2 - (button.width + 5)
            else:
                button.width = 150
                button.x = win_attribute.width / 2 + 5

            button.y = (idx % buttons_per_column) * 25 + title.bottom - 5

        else:
            print "Invalid attribute type."

        radio_button_list.append(button)

    # ========== Button Functions ==========
    def enter_btn_func():
        valid = False
        return_value = None

        # Player
        if attr_type == 'player_search':
            # Value checks
            if radio_group.value in ["PAC", "SHO", "PAS", "DRI", "DEF", "PHY", "DIV", "HAN", "KIC", "REF", "SPD", "POS",
                                     "acceleration", "aggression", "agility", "balance", "ballcontrol", "crossing",
                                     "curve", "dribbling", "finishing", "freekickaccuracy", "gkdiving", "gkhandling",
                                     "gkkicking", "gkpositioning", "gkreflexes", "headingaccuracy", "interceptions",
                                     "jumping", "longpassing", "longshots", "marking", "penalties", "positioning",
                                     "potential", "rating", "reactions", "shortpassing", "shotpower", "skillMoves",
                                     "slidingtackle", "sprintspeed", "stamina", "standingtackle", "strength", "vision",
                                     "volleys", "weakFoot"]:
                # Value should be an integer between 0 and 100
                if value_tf.value.isdigit():
                    return_value = int(value_tf.value)
                    if 0 < return_value < 100:
                        valid = True

            elif radio_group.value in ["age", "baseId", "clubId", "id", "leagueId", "nationId", "price"]:
                # Value should be an integer
                if value_tf.value.isdigit():
                    return_value = int(value_tf.value)
                    valid = True

            elif radio_group.value in ["height"]:
                # Check if value is a decimal
                decimal_value = 0.0
                if '.' in value_tf.value:
                    try:
                        decimal_value = float(value_tf.value)
                        # If value is less than 10, assume unit is feet. Else, assume unit is centimeters.
                        if decimal_value < 10:
                            return_value = int(decimal_value * 30.48)
                        else:
                            return_value = decimal_value
                        valid = True

                    except Exception:
                        print "Invalid attribute value."
                        value_tf.value = "Invalid attribute value."

                elif value_tf.value.isdigit():
                    # If value is less than 10, assume unit is feet. Else, assume unit is centimeters.
                    if int(value_tf.value) < 10:
                        return_value = int(int(value_tf.value) * 30.48)
                    else:
                        return_value = int(value_tf.value)
                    valid = True

            elif radio_group.value in ["weight"]:
                # Value should be an integer
                if value_tf.value.isdigit():
                    # If value is greater than 110, assume unit is pounds. Else, assume unit is kilograms.
                    if int(value_tf.value) > 110:
                        return_value = int(int(value_tf.value) * 0.453592)
                    else:
                        return_value = int(value_tf.value)
                    valid = True

            elif radio_group.value in ["atkWorkRate", "birthdate", "club", "color", "commonName", "defWorkRate",
                                       "firstName", "foot", "itemType", "lastName", "league", "modelName", "name",
                                       "name_custom", "nation", "playStyle", "playerType", "position", "positionFull",
                                       "quality", "specialities", "traits"]:
                # Value should be a string
                if type(value_tf.value) is str:
                    return_value = value_tf.value
                    valid = True

            elif radio_group.value in ["isGK", "isSpecialType"]:
                # Value should be a string
                if value_tf.value.upper() in ['T', 'F', 'TRUE', 'FALSE', 'Y', 'N', 'YES', 'NO']:
                    if value_tf.value.upper()[0] in ['T', 'Y']:
                        return_value = True
                    else:
                        return_value = False
                    valid = True

            if valid:
                attr_dict[radio_group.value] = (return_value, compare_group.value)
                value_tf.value = ''
                show_attributes(attribute_display_list)
                erase_btn.enabled = 1
            else:
                print "Invalid attribute value."
                value_tf.value = "Invalid attribute value."

        # Formation
        elif attr_type == 'formation_search':
            # Value checks
            if radio_group.value in ["num_attackers", "num_midfielders", "num_defenders"]:
                # Value should be an integer between 0 and 10
                if value_tf.value.isdigit():
                    return_value = int(value_tf.value)
                    if 0 < return_value < 10:
                        valid = True

            elif radio_group.value in ["num_links"]:
                # Value should be an integer
                if value_tf.value.isdigit():
                    return_value = int(value_tf.value)
                    valid = True

            elif radio_group.value in ["name", "style", "description", "position_all"]:
                # Value should be a string
                if type(value_tf.value) is str:
                    return_value = value_tf.value
                    valid = True

            if valid:
                attr_dict[radio_group.value] = (return_value, compare_group.value)
                value_tf.value = ''
                show_attributes(attribute_display_list)
                erase_btn.enabled = 1
            else:
                print "Invalid attribute value."
                value_tf.value = "Invalid attribute value."

        # Team
        elif attr_type == 'team_search':
            # Value checks
            if radio_group.value in ["rating", "chemistry", "total_ic"]:
                # Value should be an integer between -1 and 111
                if value_tf.value.isdigit():
                    return_value = int(value_tf.value)
                    if -1 < return_value < 111:
                        valid = True

            elif radio_group.value in ["total_skillMoves"]:
                # Value should be an integer between 10 and 56
                if value_tf.value.isdigit():
                    return_value = int(value_tf.value)
                    if 10 < return_value < 56:
                        valid = True

            elif radio_group.value in ["strength", "total_price", "total_PAC", "total_SHO", "total_PAS", "total_DRI",
                                       "total_DEF", "total_PHY"]:
                # Value should be an integer
                if value_tf.value.isdigit():
                    return_value = int(value_tf.value)
                    valid = True

            elif radio_group.value in ["player", "formation", "manager_league", "manager_nation", "style"]:
                # Value should be a string
                if type(value_tf.value) is str:
                    return_value = value_tf.value
                    valid = True

            if valid:
                attr_dict[radio_group.value] = (return_value, compare_group.value)
                value_tf.value = ''
                show_attributes(attribute_display_list)
                erase_btn.enabled = 1
            else:
                print "Invalid attribute value."
                value_tf.value = "Invalid attribute value."

        else:
            print 'Invalid attr_type for AddAttribute.'

        win_attribute.become_target()

    def erase_btn_func():
        if attr_type[-4:] == 'sort':
            del attr_list[:]
        elif attr_type[-6:] == 'search':
            attr_dict.clear()

        show_attributes(attribute_display_list)

        win_attribute.become_target()
        erase_btn.enabled = 0

    def back_btn_func():
        if settings['window'] == 'search':
            SearchMenu.open_search_menu(win_attribute.x, win_attribute.y, db_dict, attr_dict, attr_list, settings)
        elif settings['window'] == 'edit':
            EditMenu.open_edit_menu(win_attribute.x, win_attribute.y, db_dict, attr_dict, attr_list, settings)
        elif settings['window'] == 'ultimate_player_judging':
            CreateUltimateTeams.open_create_ultimate_teams_window(
                win_attribute.x, win_attribute.y, db_dict, settings['prev_window_value'], player_judge_list=attr_list,
                file_name=settings['file_name'], roster=settings['roster'], input_formation=settings['input_formation'])
        elif settings['window'] == 'ultimate_team_judging':
            CreateUltimateTeams.open_create_ultimate_teams_window(
                win_attribute.x, win_attribute.y, db_dict, settings['prev_window_value'], team_judge_list=attr_list,
                file_name=settings['file_name'], roster=settings['roster'], input_formation=settings['input_formation'])
        elif settings['window'] == 'pick_player':
            PickPlayer.open_pick_player_window(win_attribute.x, win_attribute.y, db_dict,
                                               settings['input_formation'], settings['win_previous'],
                                               settings['roster'], settings['pos_symbol'],
                                               settings['pick_formations_page'], attr_dict, attr_list, settings)
        else:
            print "Invalid window setting."

        win_attribute.become_target()
        win_attribute.hide()

    def attr_btn_func(attr_to_remove):
        # Remove from attribute dict
        if attr_type[-6:] == 'search':
            attr_dict.pop(attr_to_remove, None)
            show_attributes(attribute_display_list)

            if len(attr_dict) < 1:
                erase_btn.enabled = 0

        # Remove from attribute list
        elif attr_type[-4:] == 'sort':
            if attr_to_remove in attr_list:
                attr_list.remove(attr_to_remove)
                show_attributes(attribute_display_list)

            if len(attr_list) < 1:
                erase_btn.enabled = 0

        win_attribute.become_target()

    # ========== Buttons ==========
    custom_button_width = 100

    erase_btn.x = (win_width - custom_button_width) / 2
    erase_btn.y = win_attribute.height - 70
    erase_btn.height = button_height
    erase_btn.width = custom_button_width
    erase_btn.font = button_font
    erase_btn.action = erase_btn_func
    erase_btn.style = 'default'
    erase_btn.color = button_color
    erase_btn.just = 'right'
    if (attr_type[-4:] == 'sort' and len(attr_list) == 0) or \
       (attr_type[-6:] == 'search' and len(attr_dict) == 0):
        erase_btn.enabled = 0
    if attr_type[-4:] == 'sort':
        erase_btn.x = (win_width - 2*custom_button_width - button_spacing) / 2
    view.add(erase_btn)

    enter_btn.x = erase_btn.left - button_spacing - custom_button_width
    enter_btn.y = erase_btn.top
    enter_btn.height = button_height
    enter_btn.width = custom_button_width
    enter_btn.font = button_font
    enter_btn.action = enter_btn_func
    enter_btn.style = 'default'
    enter_btn.color = button_color
    enter_btn.just = 'right'
    enter_btn.enabled = 0
    if attr_type[-6:] == 'search':
        view.add(enter_btn)

    back_btn.x = erase_btn.right + button_spacing
    back_btn.y = erase_btn.top
    back_btn.height = button_height
    back_btn.width = custom_button_width
    back_btn.font = button_font
    back_btn.action = back_btn_func
    back_btn.style = 'default'
    back_btn.color = button_color
    back_btn.just = 'right'
    view.add(back_btn)

    # ========== Value Textfield ==========
    value_tf = TextField()
    value_tf.width = 200
    value_tf.x = (win_width - value_tf.width) / 2
    value_tf.y = erase_btn.top - 35
    value_tf.height = 25
    value_tf.font = std_tf_font

    # ========== Compare Radio Buttons ==========
    compare_group = RadioGroup(action=comp_selection_made)
    comp_button_list = []

    comp_button_width = 55
    comp_button_x = (win_attribute.width - 4*comp_button_width)/2

    for value in ['higher', 'exact', 'lower', 'not']:
        button = RadioButton()
        button.width = comp_button_width
        button.x = comp_button_x
        button.y = value_tf.top - value_tf.height - title_border
        button.group = compare_group
        button.value = value
        button.title = value.capitalize()

        comp_button_x += comp_button_width + 5

        comp_button_list.append(button)

    compare_group.value = 'higher'

    def show_attributes(display_list):

        # Remove old attribute buttons from screen
        for message in display_list:
            view.remove(message)

        del display_list[:]

        # Display new search attributes on screen
        message_x = 10
        message_y = win_attribute.height - 150

        if attr_type[-6:] == 'search':
            display_list.append(Label(text="Search Attributes:", font=title_tf_font, width=std_tf_width,
                                      height=std_tf_height, x=message_x, y=message_y, color=title_color))
            message_y += std_tf_height

            index = 0

            for key, search_value in attr_dict.iteritems():
                if index == 6:
                    message_x = win_attribute.width - std_tf_width - 10
                    message_y = win_attribute.height - 150 + std_tf_height

                msg_text = format_attr_name(key) + ": "
                if key in ['id', 'baseId', 'nationId', 'leagueId', 'clubId']:
                    msg_text += str(search_value[0])
                elif type(search_value[0]) is int:
                    msg_text += search_value[1].capitalize() + ' ' + str(search_value[0])
                elif search_value[1] == 'not':
                    msg_text += search_value[1].capitalize() + ' "' + str(search_value[0]) + '"'
                else:
                    msg_text += '"' + str(search_value[0]) + '"'

                attr_btn = Button(title=msg_text, font=std_tf_font, width=std_tf_width,
                                  height=std_tf_height, x=message_x, y=message_y, color=title_color,
                                  action=(attr_btn_func, key))
                message_y += std_tf_height + 1
                display_list.append(attr_btn)
                index += 1

        # Display new sort attributes on screen
        elif attr_type[-4:] == 'sort':
            display_list.append(Label(text="Sort Attributes:", font=title_tf_font, width=std_tf_width,
                                      height=std_tf_height, x=message_x, y=message_y, color=title_color))
            message_y += std_tf_height

            for index, sort_value in enumerate(attr_list):
                if index == 6:
                    message_x = win_attribute.width - std_tf_width - 10
                    message_y = win_attribute.height - 150 + std_tf_height

                attr_btn = Button(title=(format_attr_name(sort_value)), font=std_tf_font, width=std_tf_width,
                                  height=std_tf_height, x=message_x, y=message_y, color=title_color,
                                  action=(attr_btn_func, sort_value))
                message_y += std_tf_height + 1
                display_list.append(attr_btn)

        for attribute_label in display_list:
            view.add(attribute_label)

    show_attributes(attribute_display_list)

    # ========== Add buttons to window ==========
    # Shows only for getting attribute for search, not sort
    if attr_type[-6:] == 'search':
        view.add(value_tf)

        for button in comp_button_list:
            view.add(button)

    for button in radio_button_list:
        view.add(button)

    win_attribute.add(view)
    view.become_target()
    win_attribute.show()
Пример #7
0
def open_pick_player_window(window_x, window_y, db_dict, input_formation, win_previous, roster, pos_symbol,
                            pick_formations_page, attr_dict=None, attr_list=None, settings=None):

    num_results = 20
    general_display = []

    if attr_dict is None:
        attr_dict = {}

    if attr_list is None:
        attr_list = []

    if settings is None:
        settings = {
            'window': 'pick_player',
            'p_db_rg': 'player_list',
            'pos_search_rg': 'green',
            'order_rg': True,
            'messages': {
                'search': [],
                'sort': [],
                'results': []
            },
            'input_formation': input_formation,
            'roster': roster,
            'pos_symbol': pos_symbol,
            'win_previous': win_previous,
            'pick_formations_page': pick_formations_page}

        # Assign exact position as default position to search for.
        attr_dict['position'] = (input_formation['positions'][pos_symbol]['symbol'], 'exact')

        # Not position dependent - search all.
        if input_formation['name'] == 'Generic':
            settings['pos_search_rg'] = 'red'
            attr_dict.pop('position', None)

    # ========== Window ==========
    win_pick_player = Window()
    win_pick_player.title = pick_player_win_title + ' - ' + pos_symbol
    win_pick_player.auto_position = False
    win_pick_player.position = (window_x, window_y)
    win_pick_player.size = (win_width, win_height)
    win_pick_player.resizable = 0
    win_pick_player.name = pick_player_title + " Window"

    # ========== Window Image View ==========
    class PickPlayerWindowImageView(View):
        def draw(self, c, r):
            c.backcolor = view_backcolor
            c.erase_rect(r)

    view = PickPlayerWindowImageView(size=win_pick_player.size)

    # ========== Title ==========
    title = Label(text=pick_player_title + ' - ' + pos_symbol)
    title.font = title_font
    title.width = title_width
    title.height = title_height
    title.x = (win_width - title_width) / 2
    title.y = top_border
    title.color = title_color
    title.just = 'center'
    general_display.append(title)

    # ========== Action Button Declarations ==========
    start_btn = Button("Start")
    back_btn = Button("Back")

    # ========== Tool Button Declarations ==========
    attribute_btn = Button("Add Search Attribute")
    sort_btn = Button("Add Sort Attribute")
    reset_btn = Button("Reset Results")

    # ========== Action Button Functions ==========
    def start_btn_func():
        # Search - if no attribute selected, return all
        if len(attr_dict) == 0:
            search_results = db_dict[p_db_radio_group.value][1]
        else:
            search_results = db_dict[p_db_radio_group.value][1].search(attr_dict)
            search_results = PlayerDB.PlayerDB(search_results)

        # Sort - if no attribute selected, use rating
        if len(attr_list) == 0:
            search_results.sort(['rating'], sort_order_radio_group.value)
        else:
            search_results.sort(attr_list, sort_order_radio_group.value)

        # Get attributes list and avoid duplicates
        attributes_list = []

        for attr in attr_list:
            if attributes_list.count(attr) == 0:
                attributes_list.append(attr)

        for attr_key in attr_dict.iterkeys():
            if attributes_list.count(attr_key) == 0:
                attributes_list.append(attr_key)

        display_players(search_results, attributes_list, (0, num_results))

        win_pick_player.become_target()

    def back_btn_func():
        win_pick_player.hide()
        win_previous.show()

    # ========== Tool Button Functions ==========
    def attribute_btn_func():
        # Delete results
        del settings['messages']['results'][:]

        # Set type argument
        attr_type = 'player_search'

        # Open new window and close current window
        win_pick_player.hide()
        AddAttribute.open_attribute_window(win_pick_player.x, win_pick_player.y, db_dict,
                                           attr_dict, attr_list, attr_type, settings)

    def sort_btn_func():
        # Delete results
        del settings['messages']['results'][:]

        # Set type argument
        attr_type = 'player_sort'

        # Open new window and close current window
        win_pick_player.hide()
        AddAttribute.open_attribute_window(win_pick_player.x, win_pick_player.y, db_dict,
                                           attr_dict, attr_list, attr_type, settings)

    def reset_btn_func():
        # Remove messages off page
        for message in settings['messages']['search']:
            view.remove(message)
        for message in settings['messages']['sort']:
            view.remove(message)
        for message in settings['messages']['results']:
            view.remove(message)

        # Delete the attribute parameters for search and sort
        attr_dict.clear()
        del attr_list[:]
        del settings['messages']['results'][:]

        win_pick_player.become_target()

    def create_attribute_messages():
        # ========== Messages ==========
        lowest_msg_l = start_btn.top
        lowest_msg_r = start_btn.top

        attr_msg_offset = 25

        # Attribute Messages
        del settings['messages']['search'][:]
        del settings['messages']['sort'][:]

        if len(attr_dict) > 0:
            settings['messages']['search'].append(
                Label(text="Search Attributes:", font=title_tf_font, width=std_tf_width,
                      height=std_tf_height, x=attr_msg_offset, y=lowest_msg_l,
                      color=title_color))
            lowest_msg_l += std_tf_height

            for key, value in attr_dict.iteritems():
                msg_text = format_attr_name(key) + ": "
                if key in ['id', 'baseId', 'nationId', 'leagueId', 'clubId']:
                    msg_text += str(value[0])
                elif type(value[0]) is int:
                    msg_text += value[1].capitalize() + ' ' + str(value[0])
                elif value[1] == 'not':
                    msg_text += value[1].capitalize() + ' "' + str(value[0]) + '"'
                else:
                    msg_text += '"' + str(value[0]) + '"'

                attr_label = Label(text=msg_text, font=std_tf_font, width=std_tf_width,
                                   height=std_tf_height, x=attr_msg_offset, y=lowest_msg_l, color=title_color)
                lowest_msg_l += std_tf_height
                settings['messages']['search'].append(attr_label)

        if len(attr_list) > 0:
            settings['messages']['sort'].append(Label(text="Sort Attributes:", font=title_tf_font, width=std_tf_width,
                                                      height=std_tf_height, x=reset_btn.right + 3 * attr_msg_offset,
                                                      y=lowest_msg_r, color=title_color))
            lowest_msg_r += std_tf_height

            for value in attr_list:
                attr_label = Label(text=(format_attr_name(value)), font=std_tf_font, width=std_tf_width,
                                   height=std_tf_height, x=reset_btn.right + 3 * attr_msg_offset, y=lowest_msg_r,
                                   color=title_color)
                lowest_msg_r += std_tf_height
                settings['messages']['sort'].append(attr_label)

    create_attribute_messages()

    def player_bio_btn_func(player):
        win_pick_player.hide()
        PlayerBio.open_player_bio_window(win_pick_player.x, win_pick_player.y, player, win_pick_player, db_dict,
                                         db_dict['player_list'][0], db_dict['player_list'][1],
                                         roster, pos_symbol, input_formation, pick_formations_page)
        win_pick_player.become_target()

    # ========== Action Buttons ==========
    start_btn.x = (win_width - 2*small_button_width - small_button_spacing) / 2
    start_btn.y = title.bottom + small_button_top_spacing
    start_btn.height = small_button_height
    start_btn.width = small_button_width
    start_btn.font = small_button_font
    start_btn.action = start_btn_func
    start_btn.style = 'default'
    start_btn.color = small_button_color
    start_btn.just = 'right'
    general_display.append(start_btn)

    back_btn.x = start_btn.right + small_button_spacing
    back_btn.y = start_btn.top
    back_btn.height = small_button_height
    back_btn.width = small_button_width
    back_btn.font = small_button_font
    back_btn.action = back_btn_func
    back_btn.style = 'default'
    back_btn.color = small_button_color
    back_btn.just = 'right'
    general_display.append(back_btn)

    # ========== Tool Buttons ==========
    attribute_btn.x = (win_width - 3*small_button_width - 2*small_button_spacing) / 2
    attribute_btn.y = start_btn.bottom + 10
    attribute_btn.height = small_button_height
    attribute_btn.width = small_button_width
    attribute_btn.font = small_button_font
    attribute_btn.action = attribute_btn_func
    attribute_btn.style = 'default'
    attribute_btn.color = small_button_color
    attribute_btn.just = 'right'
    general_display.append(attribute_btn)

    sort_btn.x = attribute_btn.right + small_button_spacing
    sort_btn.y = attribute_btn.top
    sort_btn.height = small_button_height
    sort_btn.width = small_button_width
    sort_btn.font = small_button_font
    sort_btn.action = sort_btn_func
    sort_btn.style = 'default'
    sort_btn.color = small_button_color
    sort_btn.just = 'right'
    general_display.append(sort_btn)

    reset_btn.x = sort_btn.right + small_button_spacing
    reset_btn.y = attribute_btn.top
    reset_btn.height = small_button_height
    reset_btn.width = small_button_width
    reset_btn.font = small_button_font
    reset_btn.action = reset_btn_func
    reset_btn.style = 'default'
    reset_btn.color = small_button_color
    reset_btn.just = 'right'
    general_display.append(reset_btn)

    # ========== Pick DB/List Button Functions ==========
    def pick_file():
        # Remove old messages off page
        for message in settings['messages']['results']:
            view.remove(message)
        del settings['messages']['results'][:]

        settings['file_changes'] = False
        settings['prev_window'] = 'pick_player'
        settings['input_formation'] = input_formation
        settings['win_previous'] = win_previous
        settings['roster'] = roster
        settings['pos_symbol'] = pos_symbol
        settings['pick_formations_page'] = pick_formations_page
        settings['attr_dict'] = attr_dict
        settings['attr_list'] = attr_list
        PickFile.open_pick_file_window(win_pick_player.x, win_pick_player.y, db_dict, settings)
        win_pick_player.hide()

    def pick_p_db_func():
        settings['file_type'] = 'current_player_db'
        pick_file()

    def pick_p_list_func():
        settings['file_type'] = 'current_player_list'
        pick_file()

    # ========== DB Radio Buttons ==========
    def get_attribute_p_db_rg():
        settings['p_db_rg'] = p_db_radio_group.value
        win_pick_player.become_target()

    def get_attribute_pos_search_rg():
        if settings['pos_search_rg'] != pos_search_radio_group.value:
            button_click = True
        else:
            button_click = False

        settings['pos_search_rg'] = pos_search_radio_group.value

        # If new radio button was clicked, clear position in attribute dictionary.
        if button_click:
            attr_dict.pop('position', None)

        # Add position search terms if position and positionFull and not specified and not searching all players.
        if pos_search_radio_group.value != 'red' and button_click:
            temp_team = Team.Team()
            # Get positions of corresponding relevance
            search_positions_list = temp_team.related_positions(
                input_formation['positions'][pos_symbol]['symbol'], pos_search_radio_group.value)

            # Concatenate strings
            search_positions = ""
            for position in search_positions_list:
                search_positions += position + ', '
            search_positions = search_positions[:-2]
            if len(search_positions) < 1:
                search_positions = 'none'
            attr_dict['position'] = (search_positions, 'exact')

        # Erase current search attributes
        for message in settings['messages']['search']:
            view.remove(message)

        # Create new search attributes
        create_attribute_messages()

        # Display search attributes
        for message in settings['messages']['search']:
            view.add(message)

        win_pick_player.become_target()

    p_db_radio_group = RadioGroup(action=get_attribute_p_db_rg)
    pos_search_radio_group = RadioGroup(action=get_attribute_pos_search_rg)

    # File Label
    db_msg_width = 35
    db_radio_btn_width = 150
    db_file_btn_width = 40
    db_radio_btn_space = 5
    db_file_btn_space = 2

    file_label = Label(text="File", font=std_tf_font, width=db_msg_width,
                        height=std_tf_height, color=title_color)
    file_label.x = (win_pick_player.width - 2*db_radio_btn_width - 2*db_file_btn_width - db_radio_btn_space
                    - 2*db_file_btn_space - db_msg_width) / 2
    file_label.y = reset_btn.bottom + db_radio_btn_space

    # Players DB RG
    player_db_radio_btn = RadioButton(db_dict['player_db'][0])
    player_db_radio_btn.width = db_radio_btn_width
    player_db_radio_btn.x = file_label.right
    player_db_radio_btn.y = file_label.top
    player_db_radio_btn.group = p_db_radio_group
    player_db_radio_btn.value = 'player_db'

    player_db_file_btn = Button("Pick")
    player_db_file_btn.x = player_db_radio_btn.right + db_file_btn_space
    player_db_file_btn.y = file_label.top
    player_db_file_btn.height = std_tf_height
    player_db_file_btn.width = db_file_btn_width
    player_db_file_btn.font = small_button_font
    player_db_file_btn.action = pick_p_db_func
    player_db_file_btn.style = 'default'
    player_db_file_btn.color = small_button_color
    player_db_file_btn.just = 'right'

    player_list_radio_btn = RadioButton(db_dict['player_list'][0])
    player_list_radio_btn.width = db_radio_btn_width
    player_list_radio_btn.x = player_db_file_btn.right + db_radio_btn_space
    player_list_radio_btn.y = file_label.top
    player_list_radio_btn.group = p_db_radio_group
    player_list_radio_btn.value = 'player_list'

    player_list_file_btn = Button("Pick")
    player_list_file_btn.x = player_list_radio_btn.right + db_file_btn_space
    player_list_file_btn.y = file_label.top
    player_list_file_btn.height = std_tf_height
    player_list_file_btn.width = db_file_btn_width
    player_list_file_btn.font = small_button_font
    player_list_file_btn.action = pick_p_list_func
    player_list_file_btn.style = 'default'
    player_list_file_btn.color = small_button_color
    player_list_file_btn.just = 'right'

    p_db_radio_group.value = settings['p_db_rg']

    view.add(file_label)
    view.add(player_db_radio_btn)
    view.add(player_db_file_btn)
    view.add(player_list_radio_btn)
    view.add(player_list_file_btn)

    # Position Search RG
    pos_search_radio_btn_width = 60
    pos_search_msg_width = 140

    pos_search_rg_msg = Label(text="Positions to Search:", font=std_tf_font, width=pos_search_msg_width,
                        height=std_tf_height, color=title_color)
    pos_search_rg_msg.x = (win_pick_player.width-4*pos_search_radio_btn_width-db_radio_btn_space-pos_search_msg_width)/2
    pos_search_rg_msg.y = file_label.bottom + db_radio_btn_space

    pos_search_green_radio_btn = RadioButton("Exact")
    pos_search_green_radio_btn.width = pos_search_radio_btn_width
    pos_search_green_radio_btn.x = pos_search_rg_msg.right
    pos_search_green_radio_btn.y = pos_search_rg_msg.top
    pos_search_green_radio_btn.group = pos_search_radio_group
    pos_search_green_radio_btn.value = 'green'

    pos_search_yellow_radio_btn = RadioButton("Similar")
    pos_search_yellow_radio_btn.width = pos_search_radio_btn_width
    pos_search_yellow_radio_btn.x = pos_search_green_radio_btn.right + db_radio_btn_space
    pos_search_yellow_radio_btn.y = pos_search_green_radio_btn.top
    pos_search_yellow_radio_btn.group = pos_search_radio_group
    pos_search_yellow_radio_btn.value = 'yellow'

    pos_search_orange_radio_btn = RadioButton("Related")
    pos_search_orange_radio_btn.width = pos_search_radio_btn_width
    pos_search_orange_radio_btn.x = pos_search_yellow_radio_btn.right + db_radio_btn_space
    pos_search_orange_radio_btn.y = pos_search_yellow_radio_btn.top
    pos_search_orange_radio_btn.group = pos_search_radio_group
    pos_search_orange_radio_btn.value = 'orange'

    pos_search_red_radio_btn = RadioButton("All")
    pos_search_red_radio_btn.width = pos_search_radio_btn_width
    pos_search_red_radio_btn.x = pos_search_orange_radio_btn.right + db_radio_btn_space
    pos_search_red_radio_btn.y = pos_search_orange_radio_btn.top
    pos_search_red_radio_btn.group = pos_search_radio_group
    pos_search_red_radio_btn.value = 'red'

    pos_search_radio_group.value = settings['pos_search_rg']

    view.add(pos_search_rg_msg)
    view.add(pos_search_green_radio_btn)
    view.add(pos_search_yellow_radio_btn)
    view.add(pos_search_orange_radio_btn)
    view.add(pos_search_red_radio_btn)

    if input_formation['name'] == 'Generic':
        pos_search_green_radio_btn.enabled = 0
        pos_search_yellow_radio_btn.enabled = 0
        pos_search_orange_radio_btn.enabled = 0

    # ========== Sort Order Radio Buttons ==========
    def get_attribute_sort_order_rg():
        settings['order_rg'] = sort_order_radio_group.value
        win_pick_player.become_target()

    sort_order_radio_group = RadioGroup(action=get_attribute_sort_order_rg)

    asc_desc_radio_btn_width = 75
    asc_msg_width = 80
    radio_btn_space = 5

    asc_desc_rg_msg = Label(text="Sort Order:", font=std_tf_font, width=asc_msg_width, height=std_tf_height,
                            color=title_color)
    asc_desc_rg_msg.x = (win_pick_player.width - 2*asc_desc_radio_btn_width - radio_btn_space - asc_msg_width) / 2
    asc_desc_rg_msg.y = pos_search_green_radio_btn.bottom + radio_btn_space
    general_display.append(asc_desc_rg_msg)

    descend_radio_btn = RadioButton("Descending")
    descend_radio_btn.width = asc_desc_radio_btn_width
    descend_radio_btn.x = asc_desc_rg_msg.right
    descend_radio_btn.y = asc_desc_rg_msg.top
    descend_radio_btn.group = sort_order_radio_group
    descend_radio_btn.value = True
    general_display.append(descend_radio_btn)

    ascend_radio_btn = RadioButton("Ascending")
    ascend_radio_btn.width = asc_desc_radio_btn_width
    ascend_radio_btn.x = descend_radio_btn.right + radio_btn_space
    ascend_radio_btn.y = descend_radio_btn.top
    ascend_radio_btn.group = sort_order_radio_group
    ascend_radio_btn.value = False
    general_display.append(ascend_radio_btn)

    sort_order_radio_group.value = settings['order_rg']

    # ========== Previous, Add to List, Next Buttons ==========
    previous_btn = Button("<<< Previous %d" % num_results)
    add_to_list_btn = Button("")
    next_btn = Button("Next %d >>>" % num_results)
    total_num_results_label = Label()
    pages_label = Label()

    def previous_btn_func(results_list, attributes, index_range):
        # display previous results
        display_players(results_list, attributes, index_range)
        win_pick_player.become_target()

    def next_btn_func(results_list, attributes, index_range):
        # display next results
        display_players(results_list, attributes, index_range)
        win_pick_player.become_target()

    add_to_list_btn.x = attribute_btn.right + small_button_spacing
    add_to_list_btn.y = descend_radio_btn.bottom + 5
    add_to_list_btn.height = tiny_button_height
    add_to_list_btn.width = small_button_width
    add_to_list_btn.font = small_button_font
    add_to_list_btn.style = 'default'
    add_to_list_btn.color = small_button_color
    add_to_list_btn.just = 'right'
    add_to_list_btn.action = win_pick_player.become_target()

    previous_btn.height = tiny_button_height
    previous_btn.width = small_button_width
    previous_btn.x = add_to_list_btn.left - previous_btn.width - small_button_spacing
    previous_btn.y = add_to_list_btn.top
    previous_btn.font = small_button_font
    previous_btn.style = 'default'
    previous_btn.color = small_button_color
    previous_btn.just = 'right'

    next_btn.height = tiny_button_height
    next_btn.width = small_button_width
    next_btn.x = add_to_list_btn.right + small_button_spacing
    next_btn.y = add_to_list_btn.top
    next_btn.font = small_button_font
    next_btn.style = 'default'
    next_btn.color = small_button_color
    next_btn.just = 'right'

    total_num_results_label.font = std_tf_font
    total_num_results_label.width = 100
    total_num_results_label.height = std_tf_height
    total_num_results_label.x = previous_btn.left + - 100 - 10
    total_num_results_label.y = add_to_list_btn.top
    total_num_results_label.color = title_color
    total_num_results_label.just = 'right'

    pages_label.font = std_tf_font
    pages_label.width = 125
    pages_label.height = std_tf_height
    pages_label.x = next_btn.right + 10
    pages_label.y = add_to_list_btn.top
    pages_label.color = title_color
    pages_label.just = 'left'

    # ========== Display players from search ==========
    def display_players(results_list, attributes, index_range):
        # Remove old messages off page
        for message in settings['messages']['results']:
            view.remove(message)
        del settings['messages']['results'][:]

        previous_range = (index_range[0]-num_results, index_range[0])
        previous_btn.action = (previous_btn_func, results_list, attributes, previous_range)

        next_range = (index_range[1], index_range[1]+num_results)
        next_btn.action = (next_btn_func, results_list, attributes, next_range)

        total_num_results_label.text = str(len(results_list.db)) + " Players"
        pages_label.text = "Page %d of %d" % (int(index_range[1]/num_results),
                                              math.ceil(len(results_list.db)/float(num_results)))

        if index_range[0] > 0:
            previous_btn.enabled = 1
        else:
            previous_btn.enabled = 0
        if index_range[1] <= len(results_list.db) - 1:
            next_btn.enabled = 1
        else:
            next_btn.enabled = 0

        settings['messages']['results'].append(add_to_list_btn)
        settings['messages']['results'].append(previous_btn)
        settings['messages']['results'].append(next_btn)
        settings['messages']['results'].append(total_num_results_label)
        settings['messages']['results'].append(pages_label)

        # Print out labels
        labels = player_info_labels(attributes)
        stat_index = 0
        # Spacing values for each of the stats
        spacing_list = [125, 40, 40, 65, 115, 115, 115, 40]
        # Calculate the maximum number of stat fields that will fit on screen
        max_player_fields = len(spacing_list[:-1]) + (win_pick_player.width - sum(spacing_list[:-1]))/spacing_list[-1]
        # Calculate the left border of the stats based on the number and width of the stats
        left_border = (win_width - sum(spacing_list[:-1]) -
                       (len(labels[:max_player_fields]) - len(spacing_list) + 1) * spacing_list[-1])/2
        msg_x = left_border
        msg_y = add_to_list_btn.bottom + 5

        for info_label in labels[:max_player_fields]:
            player_label = Label(text=info_label, font=std_tf_font_bold, width=spacing_list[stat_index]-5,
                                 height=std_tf_height, x=msg_x, y=msg_y, color=title_color)
            settings['messages']['results'].append(player_label)
            msg_x += spacing_list[stat_index]

            if stat_index < len(spacing_list)-1:
                stat_index += 1

        msg_y += std_tf_height + 5

        # Print out players
        for idx, player in enumerate(results_list.db[index_range[0]:index_range[1]]):
            msg_x = left_border
            player_stats = player_info(player, attributes)
            stat_index = 0

            # Check for names that are too long
            name = player_stats[0]
            if len(name) > 20:
                name = player['lastName']

            bio_btn = Button(title=name, width=spacing_list[stat_index]-5, height=15, x=msg_x, y=msg_y,
                             action=(player_bio_btn_func, player))
            settings['messages']['results'].append(bio_btn)
            msg_x += spacing_list[stat_index]
            stat_index += 1

            for player_stat in player_stats[1:max_player_fields]:
                player_label = Label(text=player_stat, font=small_button_font, width=spacing_list[stat_index]-5,
                                     height=std_tf_height, x=msg_x, y=msg_y, color=title_color)

                settings['messages']['results'].append(player_label)
                msg_x += spacing_list[stat_index]
                if stat_index < len(spacing_list) - 1:
                    stat_index += 1

            msg_y += std_tf_height

        for results_msg in settings['messages']['results']:
            view.add(results_msg)

    # ========== Add components to view and add view to window ==========
    for msg in general_display:
        view.add(msg)
    for msg in settings['messages']['search']:
        view.add(msg)
    for msg in settings['messages']['sort']:
        view.add(msg)
    for msg in settings['messages']['results']:
        view.add(msg)

    win_pick_player.add(view)
    view.become_target()
    win_pick_player.show()
Пример #8
0
def open_confirm_prompt_window(window_x, window_y, db_dict, settings, file_path, file_name):

    # ========== Window ==========
    win_confirm_prompt = Window()
    win_confirm_prompt.title = confirm_prompt_win_title
    win_confirm_prompt.auto_position = False
    win_confirm_prompt.position = (window_x+100, window_y+100)
    win_confirm_prompt.size = (win_width-200, win_height-400)
    win_confirm_prompt.resizable = 0
    win_confirm_prompt.name = confirm_prompt_title + " Window"
    win_confirm_prompt.show()

    # ========== Window Image View ==========
    class StartWindowImageView(View):
        def draw(self, c, r):
            c.backcolor = view_backcolor
            c.erase_rect(r)

    view = StartWindowImageView(size=win_confirm_prompt.size)

    # ========== Title ==========
    title = Label(text=confirm_prompt_title)
    title.font = title_font
    title.width = title_width
    title.height = title_height
    title.x = (win_confirm_prompt.width - title_width) / 2
    title.y = top_border
    title.color = title_color
    title.just = 'center'

    # ========== Message Label ==========
    message = Label(font=title_font_2, width=win_confirm_prompt.width - 50, height=title_height,
                    x=25, y=title.bottom + top_border, color=title_color, just='center')
    message.text = "Delete \"%s\"?" % file_name

    # ========== Button Declarations ==========
    yes_btn = Button("Yes")
    cancel_btn = Button("Cancel")

    # ========== Button Functions ==========
    def yes_btn_func():

        # Disable back button in case the selected file has changed
        settings['file_changes'] = True

        # Delete file
        try:
            remove(file_path)

        except Exception as err:
            message.text = "Error: " + err.args[1]

        PickFile.open_pick_file_window(window_x, window_y, db_dict, settings)
        win_confirm_prompt.hide()

    def cancel_btn_func():
        PickFile.open_pick_file_window(window_x, window_y, db_dict, settings)
        win_confirm_prompt.hide()

    # ========== Buttons ==========
    yes_btn.x = (win_confirm_prompt.width - 2*button_width - button_spacing) / 2
    yes_btn.y = win_confirm_prompt.height - 70
    yes_btn.height = button_height
    yes_btn.width = button_width
    yes_btn.font = button_font
    yes_btn.action = yes_btn_func
    yes_btn.style = 'default'
    yes_btn.color = button_color
    yes_btn.just = 'right'

    cancel_btn.x = yes_btn.right + button_spacing
    cancel_btn.y = yes_btn.top
    cancel_btn.height = button_height
    cancel_btn.width = button_width
    cancel_btn.font = button_font
    cancel_btn.action = cancel_btn_func
    cancel_btn.style = 'default'
    cancel_btn.color = button_color
    cancel_btn.just = 'right'

    # ========== Add buttons to window ==========
    view.add(title)
    view.add(message)
    view.add(yes_btn)
    view.add(cancel_btn)

    win_confirm_prompt.add(view)
    view.become_target()
    win_confirm_prompt.show()
Пример #9
0
def open_pick_file_window(window_x, window_y, db_dict, settings):

    # ========== Window ==========
    win_pick_file = Window()
    win_pick_file.title = pick_file_win_title
    win_pick_file.auto_position = False
    win_pick_file.position = (window_x, window_y)
    win_pick_file.size = (win_width, win_height)
    win_pick_file.resizable = 0
    win_pick_file.name = pick_file_title + " Window"
    win_pick_file.show()

    # ========== Window Image View ==========
    class StartWindowImageView(View):
        def draw(self, c, r):
            c.backcolor = view_backcolor
            c.erase_rect(r)

    view = StartWindowImageView(size=win_pick_file.size)

    display_list = []

    file_type = settings['file_type']

    # ========== Title ==========
    title = Label(text=pick_file_title)
    title.font = title_font
    title.width = title_width
    title.height = title_height
    title.x = (win_width - title_width) / 2
    title.y = top_border
    title.color = title_color
    title.just = 'center'
    display_list.append(title)

    # ========== Sub Title ==========
    def get_sub_title_text():
        if file_type == 'default_player_db':
            text = "default player database"
        elif file_type == 'default_player_list':
            text = "default player list"
        elif file_type == 'default_formation_db':
            text = "default formation database"
        elif file_type == 'default_formation_list':
            text = "default formation list"
        elif file_type == 'default_team_list':
            text = "default team list"
        elif file_type == 'current_player_db':
            text = "current player database"
        elif file_type == 'current_player_list':
            text = "current player list"
        elif file_type == 'current_formation_db':
            text = "current formation database"
        elif file_type == 'current_formation_list':
            text = "current formation list"
        elif file_type == 'current_team_list':
            text = "current team list"
        else:
            text = "a"
        return text

    sub_title = Label(font=title_font_2, width=title_width, height=title_height,
                      x=(win_pick_file.width-title_width)/2, y=title.bottom, color=title_color, just='center')
    sub_title_text = get_sub_title_text()
    sub_title.text = "Select %s file:" % sub_title_text
    display_list.append(sub_title)

    # ========== Display Files ==========
    def display_files():
        file_prefix = HelperFunctions.get_file_prefix(file_type)

        # Get corresponding file names
        all_files = listdir('JSONs/')
        file_list = []
        # Truncate file paths to just the names
        for filename in all_files:
            if filename[:8] == file_prefix:
                filename = filename[8:]
                filename = filename[:-5]
                file_list.append(filename)

        # Button Functions
        def select_file_func(file_name):

            # Save new default to config file
            if file_type[:7] == 'default':
                # Load configs
                from Window.AppConfig import config_filename
                configs = {}
                with open(config_filename, 'r') as config_file:
                    configs = json.load(config_file)
                    config_file.close()

                # Assign new file name to config
                configs['default_databases'][file_type[8:]] = file_name

                # Save configs
                with open(config_file, 'w') as config_file:
                    json.dump(configs, config_file)
                    config_file.close()

            # Load db to db_dict
            elif file_type[:7] == 'current':

                if file_type[8:12] == 'play':
                    load_db = PlayerDB()
                elif file_type[8:12] == 'form':
                    load_db = FormationDB()
                elif file_type[8:12] == 'team':
                    load_db = TeamDB()
                else:
                    load_db = PlayerDB()
                    print "File type is invalid."

                if file_type[-2:] == 'db':
                    load_file_type = 'db'
                elif file_type[-4:] == 'list':
                    load_file_type = 'list'
                else:
                    load_file_type = 'Invalid'

                # Load db
                load_db.load(file_name, load_file_type)

                # Assign db to db_dict
                db_dict[file_type[8:]] = (file_name, load_db)

            else:
                print "File type is invalid."

            # Enable back button
            settings['file_changes'] = False
            settings['file_index'] = 0

            if settings['prev_window'] == 'team_creation':
                CreateUltimateTeams.open_create_ultimate_teams_window(
                    win_pick_file.x, win_pick_file.y, db_dict, settings['prev_window_value'],
                    file_name=settings['create_team_name'], roster=settings['roster'],
                    input_formation=settings['input_formation'])
            elif settings['prev_window'] == 'search':
                SearchMenu.open_search_menu(win_pick_file.x, win_pick_file.y, db_dict,
                                            settings['attr_dict'], settings['attr_list'], settings)
            elif settings['prev_window'] == 'pick_player':
                PickPlayer.open_pick_player_window(win_pick_file.x, win_pick_file.y, db_dict,
                                                   settings['input_formation'], settings['win_previous'],
                                                   settings['roster'], settings['pos_symbol'],
                                                   settings['pick_formations_page'], settings['attr_dict'],
                                                   settings['attr_list'], settings)
            else:
                FilesMenu.open_files_menu(win_pick_file.x, win_pick_file.y, db_dict, settings)
            win_pick_file.hide()

        def rename_file_func(file_name):
            # Get new name
            EnterText.open_enter_text_window(win_pick_file.x, win_pick_file.y, db_dict, settings,
                                             'rename', fill_text=file_name, file_prefix=file_prefix)
            settings['file_changes'] = True
            win_pick_file.hide()

        def edit_file_func(file_name):
            if file_type[8:12] == 'play':
                settings['edit_subject'] = 'players'
            elif file_type[8:12] == 'form':
                settings['edit_subject'] = 'formations'
            elif file_type[8:12] == 'team':
                settings['edit_subject'] = 'teams'
            else:
                print "Invalid file type."

            settings['file_name'] = file_name

            EditMenu.open_edit_menu(win_pick_file.x, win_pick_file.y, db_dict, settings=settings)
            settings['file_changes'] = True
            win_pick_file.hide()

        def update_prices_func(file_name):
            win_pick_file.become_target()
            # Open status window to start updating player prices
            settings['update_prices'] = True
            StatusWindow.open_status_window(win_pick_file.x, win_pick_file.y,
                                            db_dict, file_name, settings=settings, win_previous=win_pick_file)
            settings['file_changes'] = True
            win_pick_file.hide()

        def duplicate_file_func(file_name):
            # Get name for duplicate file and create
            EnterText.open_enter_text_window(win_pick_file.x, win_pick_file.y, db_dict, settings,
                                             'duplicate', fill_text=file_name, file_prefix=file_prefix)
            win_pick_file.hide()

        def delete_file_func(file_name):
            file_path = 'JSONs/' + file_prefix + file_name + '.json'
            ConfirmPrompt.open_confirm_prompt_window(win_pick_file.x, win_pick_file.y,
                                                     db_dict, settings, file_path, file_name)
            win_pick_file.hide()

        # Display appropriate files
        small_file_button_width = 75
        file_y = sub_title.bottom + small_button_top_spacing
        if file_type[:7] == 'default':
            file_x = (win_width - file_btn_width) / 2
        elif file_type[-2:] == 'db' and file_type[8:-3] == 'formation':
            file_x = (win_width - file_btn_width - 3*small_file_button_width - 3*file_btn_spacing) / 2
        elif (file_type[-2:] == 'db' and file_type[8:-3] == 'player') or \
             (file_type[-4:] == 'list' and file_type[8:-5] == 'formation'):
            file_x = (win_width - file_btn_width - 4*small_file_button_width - 4*file_btn_spacing) / 2
        else:
            file_x = (win_width - file_btn_width - 5*small_file_button_width - 5*file_btn_spacing) / 2

        if 'file_index' not in settings:
            settings['file_index'] = 0

        files_per_page = 10
        file_index = settings['file_index']

        # Previous page button function
        def previous_btn_func():
            settings['file_index'] -= files_per_page
            win_pick_file.hide()
            open_pick_file_window(win_pick_file.x, win_pick_file.y, db_dict, settings)

        # Next page button function
        def next_btn_func():
            settings['file_index'] += files_per_page
            win_pick_file.hide()
            open_pick_file_window(win_pick_file.x, win_pick_file.y, db_dict, settings)

        # Previous page button
        previous_btn = Button('<<< Previous Page', height=small_button_height, width=file_btn_width,
                          font=small_button_font, action=previous_btn_func, style='default',
                          x=(win_pick_file.width - 2*file_btn_width - button_spacing)/2, y=file_y,
                          color=small_button_color, just='center')
        display_list.append(previous_btn)

        if file_index < 1:
            previous_btn.enabled = 0

        # Next page button
        next_btn = Button('Next Page >>>', height=small_button_height, width=file_btn_width,
                          font=small_button_font, action=next_btn_func, style='default',
                          x=previous_btn.right + button_spacing, y=file_y,
                          color=small_button_color, just='center')
        display_list.append(next_btn)

        if file_index + files_per_page >= len(file_list):
            next_btn.enabled = 0

        file_y += top_border*2

        for filename in file_list[file_index:file_index + files_per_page]:

            # Select file button with name
            file_btn = Button(filename, height=small_button_height, width=file_btn_width,
                              font=small_button_font, action=(select_file_func, filename), style='default',
                              x=file_x, y=file_y,
                              color=small_button_color, just='center')

            # Rename file button
            rename_btn = Button('Rename', height=small_button_height, width=small_file_button_width,
                                font=small_button_font, action=(rename_file_func, filename), style='default',
                                x=file_btn.right + file_btn_spacing, y=file_y,
                                color=small_button_color, just='center')

            # Edit file button
            edit_btn = Button('Edit', height=small_button_height, width=small_file_button_width,
                              font=small_button_font, action=(edit_file_func, filename), style='default',
                              x=rename_btn.right + file_btn_spacing, y=file_y,
                              color=small_button_color, just='center')
            if file_type[8:12] == 'team':
                edit_btn.enabled = 0

            # Update prices button
            update_prices_btn = Button('Update Prices', height=small_button_height, width=small_file_button_width,
                                       font=small_button_font, action=(update_prices_func, filename), style='default',
                                       x=edit_btn.right + file_btn_spacing, y=file_y,
                                       color=small_button_color, just='center')

            # Duplicate file button
            duplicate_btn = Button('Duplicate', height=small_button_height, width=small_file_button_width,
                                   font=small_button_font, action=(duplicate_file_func, filename), style='default',
                                   x=update_prices_btn.right + file_btn_spacing, y=file_y,
                                   color=small_button_color, just='center')

            # Delete file button
            delete_btn = Button('Delete', height=small_button_height, width=small_file_button_width,
                                font=small_button_font, action=(delete_file_func, filename), style='default',
                                x=duplicate_btn.right + file_btn_spacing, y=file_y,
                                color=small_button_color, just='center')

            # Reposition buttons based on those being shown
            if 'db' in file_type and 'formation' in file_type:
                duplicate_btn.x = rename_btn.right + file_btn_spacing
                delete_btn.x = duplicate_btn.right + file_btn_spacing
            elif 'db' in file_type:
                update_prices_btn.x = rename_btn.right + file_btn_spacing
                duplicate_btn.x = update_prices_btn.right + file_btn_spacing
                delete_btn.x = duplicate_btn.right + file_btn_spacing
            elif 'list' in file_type and 'formation' in file_type:
                duplicate_btn.x = edit_btn.right + file_btn_spacing
                delete_btn.x = duplicate_btn.right + file_btn_spacing

            # Display buttons according to file type
            display_list.append(file_btn)
            if 'current' in file_type:
                display_list.append(rename_btn)
                if 'list' in file_type:
                    display_list.append(edit_btn)
                if 'player' in file_type or 'team' in file_type:
                    display_list.append(update_prices_btn)
                display_list.append(duplicate_btn)
                display_list.append(delete_btn)

            file_y += small_button_height + 3*file_btn_spacing

    # ========== Back Button Declaration ==========
    back_btn = Button("Back")

    def back_btn_func():
        settings['file_index'] = 0

        if settings['prev_window'] == 'team_creation':
            CreateUltimateTeams.open_create_ultimate_teams_window(
                win_pick_file.x, win_pick_file.y, db_dict, settings['prev_window_value'],
                file_name=settings['create_team_name'], roster=settings['roster'],
                input_formation=settings['input_formation'])
        elif settings['prev_window'] == 'search':
            SearchMenu.open_search_menu(win_pick_file.x, win_pick_file.y, db_dict,
                                        settings['attr_dict'], settings['attr_list'], settings)
        elif settings['prev_window'] == 'pick_player':
            PickPlayer.open_pick_player_window(win_pick_file.x, win_pick_file.y, db_dict,
                                               settings['input_formation'], settings['win_previous'],
                                               settings['roster'], settings['pos_symbol'],
                                               settings['pick_formations_page'], settings['attr_dict'],
                                               settings['attr_list'], settings)
        else:
            FilesMenu.open_files_menu(win_pick_file.x, win_pick_file.y, db_dict, settings)
        win_pick_file.hide()

    # ========== Back Button ==========
    back_btn.x = (win_width - button_width) / 2
    back_btn.y = win_pick_file.height - 70
    back_btn.height = button_height
    back_btn.width = button_width
    back_btn.font = button_font
    back_btn.action = back_btn_func
    back_btn.style = 'default'
    back_btn.color = button_color
    back_btn.just = 'right'
    if settings['file_changes']:
        back_btn.enabled = 0
    else:
        back_btn.enabled = 1

    display_list.append(back_btn)

    display_files()

    # ========== Add buttons to window ==========
    for item in display_list:
        view.add(item)

    win_pick_file.add(view)
    view.become_target()
    win_pick_file.show()
Пример #10
0
def open_files_menu(window_x, window_y, db_dict, settings=None):

    general_display_list = []
    lists_display_list = []
    databases_display_list = []
    defaults_display_list = []

    with open(config_filename, 'r') as f:
        default_databases = json.load(f)['default_databases']
        f.close()

    if settings is None:
        settings = {
            'mode': 'lists',
            'file_changes': False
        }

    # ========== Window ==========
    win_files = Window()
    win_files.title = files_win_title
    win_files.auto_position = False
    win_files.position = (window_x, window_y)
    win_files.size = (win_width, win_height)
    win_files.resizable = 0
    win_files.name = "Files Window"

    # ========== Window Image View ==========
    class FormationsWindowImageView(View):
        def draw(self, c, r):
            c.backcolor = view_backcolor
            c.erase_rect(r)

    view = FormationsWindowImageView(size=win_files.size)

    # ========== Title ==========
    title = Label(text=files_title)
    title.font = title_font
    title.width = title_width
    title.height = title_height
    title.x = (win_files.width - title_width) / 2
    title.y = top_border
    title.color = title_color
    title.just = 'center'
    general_display_list.append(title)

    # Subtitle
    subtitle = Label(font=title_font_2, width=title_width, height=title_height,
                     x=(win_files.width - title_width) / 2,
                     color=title_color, just = 'center')
    general_display_list.append(subtitle)

    # ========== Helper Functions ==========
    def remove_old_display():
        """
        Remove previous displayed items
        """
        if settings['mode'] == 'lists':
            for display_item in lists_display_list:
                view.remove(display_item)
        elif settings['mode'] == 'databases':
            for display_item in databases_display_list:
                view.remove(display_item)
        elif settings['mode'] == 'defaults':
            for display_item in defaults_display_list:
                view.remove(display_item)
        else:
            print "Settings mode is invalid."

    def add_new_display():
        """
        Remove previous displayed items
        """
        if settings['mode'] == 'lists':
            subtitle.text = "Current Lists"
            for display_item in lists_display_list:
                view.add(display_item)
        elif settings['mode'] == 'databases':
            subtitle.text = "Current Databases"
            for display_item in databases_display_list:
                view.add(display_item)
        elif settings['mode'] == 'defaults':
            subtitle.text = "Default Files"
            for display_item in defaults_display_list:
                view.add(display_item)
        else:
            print "Settings mode is invalid."

    # ========== Button Toolbar Functions ==========
    def lists_btn_func():
        # Remove previous displayed items
        remove_old_display()

        settings['mode'] = 'lists'

        # Add new display items
        add_new_display()

        for btn in button_list:
            btn.enabled = 1
        lists_btn.enabled = 0

        win_files.become_target()

    def databases_btn_func():
        # Remove previous displayed items
        remove_old_display()

        settings['mode'] = 'databases'

        # Add new display items
        add_new_display()

        for btn in button_list:
            btn.enabled = 1
        databases_btn.enabled = 0

        win_files.become_target()

    def defaults_btn_func():
        # Remove previous displayed items
        remove_old_display()

        settings['mode'] = 'defaults'

        # Add new display items
        add_new_display()

        for btn in button_list:
            btn.enabled = 1
        defaults_btn.enabled = 0

        win_files.become_target()

    def back_btn_func():
        StartMenu.open_start_menu(win_files.x, win_files.y, db_dict)
        win_files.hide()

    # ========== Current Lists Button Functions ==========
    def create_list_btn_func():
        settings['file_type'] = 'create_list'
        CreateList.open_create_list_window(win_files.x, win_files.y, db_dict, settings)
        win_files.hide()

    def player_list_current_btn_func():
        settings['prev_window'] = 'files_menu'
        settings['file_type'] = 'current_player_list'
        PickFile.open_pick_file_window(win_files.x, win_files.y, db_dict, settings)
        win_files.hide()

    def formation_list_current_btn_func():
        settings['prev_window'] = 'files_menu'
        settings['file_type'] = 'current_formation_list'
        PickFile.open_pick_file_window(win_files.x, win_files.y, db_dict, settings)
        win_files.hide()

    def team_list_current_btn_func():
        settings['prev_window'] = 'files_menu'
        settings['file_type'] = 'current_team_list'
        PickFile.open_pick_file_window(win_files.x, win_files.y, db_dict, settings)
        win_files.hide()

    # ========== Current Databases Button Functions ==========
    def download_player_db_btn_func():
        settings['prev_window'] = 'files_menu'
        settings['file_type'] = 'download_player_db'
        EnterText.open_enter_text_window(win_files.x, win_files.y, db_dict, settings, 'download')
        win_files.hide()

    def player_db_current_btn_func():
        settings['prev_window'] = 'files_menu'
        settings['file_type'] = 'current_player_db'
        PickFile.open_pick_file_window(win_files.x, win_files.y, db_dict, settings)
        win_files.hide()

    def formation_db_current_btn_func():
        settings['prev_window'] = 'files_menu'
        settings['file_type'] = 'current_formation_db'
        PickFile.open_pick_file_window(win_files.x, win_files.y, db_dict, settings)
        win_files.hide()

    # ========== Defaults Button Functions ==========
    def player_db_default_btn_func():
        settings['prev_window'] = 'files_menu'
        settings['file_type'] = 'default_player_db'
        PickFile.open_pick_file_window(win_files.x, win_files.y, db_dict, settings)
        win_files.hide()

    def player_list_default_btn_func():
        settings['prev_window'] = 'files_menu'
        settings['file_type'] = 'default_player_list'
        PickFile.open_pick_file_window(win_files.x, win_files.y, db_dict, settings)
        win_files.hide()

    def formation_db_default_btn_func():
        settings['prev_window'] = 'files_menu'
        settings['file_type'] = 'default_formation_db'
        PickFile.open_pick_file_window(win_files.x, win_files.y, db_dict, settings)
        win_files.hide()

    def formation_list_default_btn_func():
        settings['prev_window'] = 'files_menu'
        settings['file_type'] = 'default_formation_list'
        PickFile.open_pick_file_window(win_files.x, win_files.y, db_dict, settings)
        win_files.hide()

    def team_list_default_btn_func():
        settings['prev_window'] = 'files_menu'
        settings['file_type'] = 'default_team_list'
        PickFile.open_pick_file_window(win_files.x, win_files.y, db_dict, settings)
        win_files.hide()

    # ========== Button Toolbar Declarations ==========
    lists_btn = Button("Lists", height=small_button_height, width=small_button_width,
                       font=small_button_font, action=lists_btn_func, style='default',
                       color=small_button_color, just='center')
    databases_btn = Button("Databases", height=small_button_height, width=small_button_width, font=small_button_font,
                           action=databases_btn_func, style='default', color=small_button_color, just='center')
    defaults_btn = Button("Defaults", height=small_button_height, width=small_button_width, font=small_button_font,
                          action=defaults_btn_func, style='default', color=small_button_color, just='center')
    back_btn = Button("Back", height=small_button_height, width=small_button_width, font=small_button_font,
                      action=back_btn_func, style='default', color=small_button_color, just='center')

    button_list = [lists_btn,
                   databases_btn,
                   defaults_btn,
                   back_btn]

    for button in button_list:
        general_display_list.append(button)

    # ========== Current Lists Button Declarations ==========
    create_list_btn = Button("Create New List", height=small_button_height,
                             width=small_button_width, font=small_button_font,
                             action=create_list_btn_func,
                             style='default', color=small_button_color, just='center')
    lists_display_list.append(create_list_btn)
    player_list_current_btn = Button(db_dict['player_list'][0], height=small_button_height,
                                     width=file_btn_width, font=small_button_font,
                                     action=player_list_current_btn_func,
                                     style='default', color=small_button_color, just='center')
    lists_display_list.append(player_list_current_btn)
    formation_list_current_btn = Button(db_dict['formation_list'][0], height=small_button_height,
                                        width=file_btn_width, font=small_button_font,
                                        action=formation_list_current_btn_func,
                                        style='default', color=small_button_color, just='center')
    lists_display_list.append(formation_list_current_btn)
    team_list_current_btn = Button(db_dict['team_list'][0], height=small_button_height,
                                   width=file_btn_width, font=small_button_font,
                                   action=team_list_current_btn_func,
                                   style='default', color=small_button_color, just='center')
    lists_display_list.append(team_list_current_btn)

    # ========== Current Databases Button Declarations ==========
    download_player_db_btn = Button("Download Player DB", height=small_button_height,
                                    width=small_button_width, font=small_button_font,
                                    action=download_player_db_btn_func,
                                    style='default', color=small_button_color, just='center')
    databases_display_list.append(download_player_db_btn)
    player_db_current_btn = Button(db_dict['player_db'][0], height=small_button_height,
                                   width=file_btn_width, font=small_button_font,
                                   action=player_db_current_btn_func,
                                   style='default', color=small_button_color, just='center')
    databases_display_list.append(player_db_current_btn)
    formation_db_current_btn = Button(db_dict['formation_db'][0], height=small_button_height,
                                      width=file_btn_width, font=small_button_font,
                                      action=formation_db_current_btn_func,
                                      style='default', color=small_button_color, just='center')
    databases_display_list.append(formation_db_current_btn)

    # ========== Defaults Button Declarations ==========
    player_db_default_btn = Button(default_databases['player_db'], height=small_button_height, width=file_btn_width,
                                   font=small_button_font, action=player_db_default_btn_func, style='default',
                                   color=small_button_color, just='center')
    defaults_display_list.append(player_db_default_btn)
    player_list_default_btn = Button(default_databases['player_list'], height=small_button_height,
                                     width=file_btn_width, font=small_button_font,
                                     action=player_list_default_btn_func,
                                     style='default', color=small_button_color, just='center')
    defaults_display_list.append(player_list_default_btn)
    formation_db_default_btn = Button(default_databases['formation_db'], height=small_button_height,
                                      width=file_btn_width, font=small_button_font,
                                      action=formation_db_default_btn_func,
                                      style='default', color=small_button_color, just='center')
    defaults_display_list.append(formation_db_default_btn)
    formation_list_default_btn = Button(default_databases['formation_list'], height=small_button_height,
                                        width=file_btn_width, font=small_button_font,
                                        action=formation_list_default_btn_func,
                                        style='default', color=small_button_color, just='center')
    defaults_display_list.append(formation_list_default_btn)
    team_list_default_btn = Button(default_databases['team_list'], height=small_button_height, width=file_btn_width,
                                   font=small_button_font, action=team_list_default_btn_func,
                                   style='default', color=small_button_color, just='center')
    defaults_display_list.append(team_list_default_btn)

    # ========== Toolbar Buttons ==========
    lists_btn.x = (win_width - len(button_list)*small_button_width - (len(button_list)-1)*small_button_spacing) / 2
    lists_btn.y = title.bottom + small_button_top_spacing
    if settings['mode'] == 'lists':
        lists_btn.enabled = 0

    databases_btn.x = lists_btn.right + small_button_spacing
    databases_btn.y = lists_btn.top
    if settings['mode'] == 'databases':
        databases_btn.enabled = 0

    defaults_btn.x = databases_btn.right + small_button_spacing
    defaults_btn.y = lists_btn.top
    if settings['mode'] == 'defaults':
        defaults_btn.enabled = 0

    back_btn.x = defaults_btn.right + small_button_spacing
    back_btn.y = lists_btn.top

    subtitle.y = lists_btn.bottom + top_border

    # ========== Lists Buttons ========
    lists_file_label_width = 200
    lists_buttons_x = win_width - file_btn_width - (win_width - file_btn_width - lists_file_label_width) / 2

    create_list_btn.x = (win_files.width - button_width) / 2
    create_list_btn.y = subtitle.bottom + title_border

    player_list_current_btn.x = lists_buttons_x
    player_list_current_btn.y = create_list_btn.bottom + top_border

    formation_list_current_btn.x = lists_buttons_x
    formation_list_current_btn.y = player_list_current_btn.bottom + title_border

    team_list_current_btn.x = lists_buttons_x
    team_list_current_btn.y = formation_list_current_btn.bottom + title_border

    # ========== Databases Buttons ========
    dbs_file_label_width = 200
    dbs_buttons_x = win_width - file_btn_width - (win_width - file_btn_width - dbs_file_label_width) / 2

    download_player_db_btn.x = (win_files.width - button_width) / 2
    download_player_db_btn.y = subtitle.bottom + title_border

    player_db_current_btn.x = dbs_buttons_x
    player_db_current_btn.y = download_player_db_btn.bottom + top_border

    formation_db_current_btn.x = dbs_buttons_x
    formation_db_current_btn.y = player_db_current_btn.bottom + title_border

    # ========== Defaults Buttons ==========
    default_file_label_width = 200
    default_buttons_x = win_width - file_btn_width - (win_width - file_btn_width - default_file_label_width) / 2

    player_db_default_btn.x = default_buttons_x
    player_db_default_btn.y = subtitle.bottom + title_border

    player_list_default_btn.x = default_buttons_x
    player_list_default_btn.y = player_db_default_btn.bottom + title_border

    formation_db_default_btn.x = default_buttons_x
    formation_db_default_btn.y = player_list_default_btn.bottom + title_border*2

    formation_list_default_btn.x = default_buttons_x
    formation_list_default_btn.y = formation_db_default_btn.bottom + title_border

    team_list_default_btn.x = default_buttons_x
    team_list_default_btn.y = formation_list_default_btn.bottom + title_border*2

    # ========== Lists Labels ==========
    player_list_current_text = "Player List:"
    lists_display_list.append(Label(text=player_list_current_text, font=title_tf_font,
                                    width=lists_file_label_width, height=std_tf_height,
                                    x=player_list_current_btn.left - lists_file_label_width,
                                    y=player_list_current_btn.top + 6, color=title_color))
    formation_list_current_text = "Formation List:"
    lists_display_list.append(Label(text=formation_list_current_text, font=title_tf_font,
                                    width=lists_file_label_width, height=std_tf_height,
                                    x=formation_list_current_btn.left - lists_file_label_width,
                                    y=formation_list_current_btn.top + 6, color=title_color))
    team_list_current_text = "Team List:"
    lists_display_list.append(Label(text=team_list_current_text, font=title_tf_font,
                                    width=lists_file_label_width, height=std_tf_height,
                                    x=team_list_current_btn.left - lists_file_label_width,
                                    y=team_list_current_btn.top + 6, color=title_color))

    # ========== Databases Labels ==========
    player_db_current_text = "Player Database:"
    databases_display_list.append(Label(text=player_db_current_text, font=title_tf_font,
                                        width=dbs_file_label_width, height=std_tf_height,
                                        x=player_list_current_btn.left - lists_file_label_width,
                                        y=player_list_current_btn.top + 6, color=title_color))
    formation_db_current_text = "Formation Database:"
    databases_display_list.append(Label(text=formation_db_current_text, font=title_tf_font,
                                        width=dbs_file_label_width, height=std_tf_height,
                                        x=formation_list_current_btn.left - lists_file_label_width,
                                        y=formation_list_current_btn.top + 6, color=title_color))

    # ========== Default File Labels ==========
    player_db_default_text = "Player Database:"
    defaults_display_list.append(Label(text=player_db_default_text, font=title_tf_font, width=default_file_label_width,
                                       height=std_tf_height, x=player_db_default_btn.left - default_file_label_width,
                                       y=player_db_default_btn.top + 6, color=title_color))
    player_list_default_text = "Player List:"
    defaults_display_list.append(Label(text=player_list_default_text, font=title_tf_font,
                                       width=default_file_label_width, height=std_tf_height,
                                       x=player_list_default_btn.left - default_file_label_width,
                                       y=player_list_default_btn.top + 6, color=title_color))
    formation_db_default_text = "Formation Database:"
    defaults_display_list.append(Label(text=formation_db_default_text, font=title_tf_font,
                                       width=default_file_label_width, height=std_tf_height,
                                       x=formation_db_default_btn.left - default_file_label_width,
                                       y=formation_db_default_btn.top + 6, color=title_color))
    formation_list_default_text = "Formation List:"
    defaults_display_list.append(Label(text=formation_list_default_text, font=title_tf_font,
                                       width=default_file_label_width, height=std_tf_height,
                                       x=formation_list_default_btn.left - default_file_label_width,
                                       y=formation_list_default_btn.top + 6, color=title_color))
    team_list_default_text = "Team List:"
    defaults_display_list.append(Label(text=team_list_default_text, font=title_tf_font, width=default_file_label_width,
                                       height=std_tf_height, x=team_list_default_btn.left - default_file_label_width,
                                       y=team_list_default_btn.top + 6, color=title_color))

    # ========== Add components to view and add view to window ==========
    for item in general_display_list:
        view.add(item)

    add_new_display()

    win_files.add(view)
    view.become_target()
    win_files.show()
Пример #11
0
def open_formation_bio_window(window_x, window_y, formation, win_previous, file_name, current_list):

    # ========== Window ==========
    win_formation_bio = Window()
    win_formation_bio.title = formation_bio_win_title
    win_formation_bio.auto_position = False
    win_formation_bio.position = (window_x, window_y)
    win_formation_bio.size = (win_width, win_height)
    win_formation_bio.resizable = 0
    win_formation_bio.name = formation_bio_title + " Window"
    win_formation_bio.show()

    # ========== Load Formation Spacing ==========
    # Get attribute lists
    with open(config_filename, 'r') as f:
        formation_spacing = json.load(f)['formation_coordinates'][formation['name']]
        f.close()

    labels_list = []

    # ========== Field Ratio ==========
    y_to_x_ratio = 0.8

    # Line specification
    line_color = white
    line_size = 2

    # Field
    field_color = dark_green
    field_length = 600
    field_width = field_length*y_to_x_ratio

    # Field positioning on screen
    field_x_offset = (win_formation_bio.width - field_width - button_width - 100) / 2
    field_y_offset = top_border + title_height + title_border

    # Center circle
    center_spot_x = field_x_offset + field_width/2
    center_spot_y = field_y_offset + field_length/2
    circle_radius = int(field_length/10)

    # Goal box
    penalty_spot_height = int(field_length*12/100)
    eighteen_box_height = int(field_length*18/100)
    eighteen_box_width = int(field_length*44/100)
    six_box_height = int(field_length*6/100)
    six_box_width = int(field_length*20/100)

    # Corner semi circles
    corner_semi_circle_radius = int(field_length*2/100)

    # ========== Player Spacing Values ==========
    x_space = int(field_width/20)
    y_space = int(field_length/24)
    player_box_width = 80
    player_box_height = 50
    player_box_color = lighter
    link_size = 5
    link_color = red

    # ========== Window Image View ==========
    image_pos = (field_x_offset, field_y_offset)
    src_rect = (0, 0, field_width, field_length)
    dst_rect = Geometry.offset_rect(src_rect, image_pos)

    class StartWindowImageView(View):
        def draw(self, c, r):
            c.backcolor = view_backcolor
            c.erase_rect(r)

            # Field and sidelines
            c.forecolor = field_color
            c.fill_rect((dst_rect[0]-5, dst_rect[1]-5, dst_rect[2]+5, dst_rect[3]+5))
            c.forecolor = line_color
            c.fill_rect((dst_rect[0], dst_rect[1], dst_rect[2], dst_rect[3]))
            c.forecolor = field_color
            c.fill_rect((dst_rect[0]+line_size, dst_rect[1]+line_size, dst_rect[2]-line_size, dst_rect[3]-line_size))

            # Center circle, center spot, and half-way line
            c.forecolor = line_color
            c.fill_oval((center_spot_x-circle_radius, center_spot_y-circle_radius,
                         center_spot_x+circle_radius, center_spot_y+circle_radius))
            c.forecolor = field_color
            c.fill_oval((center_spot_x-circle_radius+line_size, center_spot_y-circle_radius+line_size,
                         center_spot_x+circle_radius-line_size, center_spot_y+circle_radius-line_size))
            c.forecolor = line_color
            c.fill_rect((dst_rect[0], center_spot_y-line_size/2, dst_rect[2], center_spot_y+line_size/2))
            c.fill_oval((center_spot_x-line_size*2, center_spot_y-line_size*2,
                         center_spot_x+line_size*2, center_spot_y+line_size*2))

            # Goal box semi circle
            c.forecolor = line_color
            c.fill_oval((center_spot_x-circle_radius, dst_rect[1]+penalty_spot_height-circle_radius,
                         center_spot_x+circle_radius, dst_rect[1]+penalty_spot_height+circle_radius))
            c.fill_oval((center_spot_x-circle_radius, dst_rect[3]-penalty_spot_height-circle_radius,
                         center_spot_x+circle_radius, dst_rect[3]-penalty_spot_height+circle_radius))
            c.forecolor = field_color
            c.fill_oval((center_spot_x-circle_radius+line_size,
                         dst_rect[1]+penalty_spot_height-circle_radius+line_size,
                         center_spot_x+circle_radius-line_size,
                         dst_rect[1]+penalty_spot_height+circle_radius-line_size))
            c.fill_oval((center_spot_x-circle_radius+line_size,
                         dst_rect[3]-penalty_spot_height-circle_radius+line_size,
                         center_spot_x+circle_radius-line_size,
                         dst_rect[3]-penalty_spot_height+circle_radius-line_size))

            # Eighteen yard box
            c.forecolor = line_color
            c.fill_rect((center_spot_x-eighteen_box_width/2, dst_rect[1],
                         center_spot_x+eighteen_box_width/2, dst_rect[1]+eighteen_box_height))
            c.fill_rect((center_spot_x-eighteen_box_width/2, dst_rect[3]-eighteen_box_height,
                         center_spot_x+eighteen_box_width/2, dst_rect[3]))
            c.forecolor = field_color
            c.fill_rect((center_spot_x-eighteen_box_width/2+line_size,
                         dst_rect[1]+line_size,
                         center_spot_x+eighteen_box_width/2-line_size,
                         dst_rect[1]+eighteen_box_height-line_size))
            c.fill_rect((center_spot_x-eighteen_box_width/2+line_size,
                         dst_rect[3]-eighteen_box_height+line_size,
                         center_spot_x+eighteen_box_width/2-line_size,
                         dst_rect[3]-line_size))

            # Penalty spot
            c.forecolor = line_color
            c.fill_oval((center_spot_x-line_size*2, dst_rect[1]+six_box_height*2-line_size*2,
                         center_spot_x+line_size*2, dst_rect[1]+six_box_height*2+line_size*2))
            c.fill_oval((center_spot_x-line_size*2, dst_rect[3]-six_box_height*2-line_size*2,
                         center_spot_x+line_size*2, dst_rect[3]-six_box_height*2+line_size*2))

            # Six yard box
            c.forecolor = line_color
            c.fill_rect((center_spot_x-six_box_width/2, dst_rect[1],
                         center_spot_x+six_box_width/2, dst_rect[1]+six_box_height))
            c.fill_rect((center_spot_x-six_box_width/2, dst_rect[3]-six_box_height,
                         center_spot_x+six_box_width/2, dst_rect[3]))
            c.forecolor = field_color
            c.fill_rect((center_spot_x-six_box_width/2+line_size,
                         dst_rect[1]+line_size,
                         center_spot_x+six_box_width/2-line_size,
                         dst_rect[1]+six_box_height-line_size))
            c.fill_rect((center_spot_x-six_box_width/2+line_size,
                         dst_rect[3]-six_box_height+line_size,
                         center_spot_x+six_box_width/2-line_size,
                         dst_rect[3]-line_size))

            # Corner circles
            c.forecolor = line_color
            c.stroke_arc((dst_rect[0]+1, dst_rect[1]), corner_semi_circle_radius, 0, 90)
            c.frame_arc((dst_rect[2], dst_rect[1]), corner_semi_circle_radius, 90, 180)
            c.stroke_arc((dst_rect[0]+1, dst_rect[3]-line_size), corner_semi_circle_radius, 270, 0)
            c.frame_arc((dst_rect[2], dst_rect[3]-line_size), corner_semi_circle_radius, 180, 270)

            # Links
            for sym, pos in formation['positions'].iteritems():

                c.forecolor = link_color
                position_coordinates = formation_spacing[sym]

                for link in pos['links']:
                    link_coordinates = formation_spacing[link]

                    # Determine line direction to decide which points to use
                    change_y = (link_coordinates[1]-position_coordinates[1])*y_space
                    change_x = (link_coordinates[0]-position_coordinates[0])*x_space+0.0001
                    ratio = change_y/change_x

                    # Horizontal width line
                    if abs(ratio) >= 1:
                        c.fill_poly([(int(dst_rect[0]+position_coordinates[0]*x_space)-link_size/2,
                                      int(dst_rect[1]+position_coordinates[1]*y_space)),
                                     (int(dst_rect[0]+position_coordinates[0]*x_space)+link_size/2,
                                      int(dst_rect[1]+position_coordinates[1]*y_space)),
                                     (int(dst_rect[0]+link_coordinates[0]*x_space+link_size/2),
                                      int(dst_rect[1]+link_coordinates[1]*y_space)),
                                     (int(dst_rect[0]+link_coordinates[0]*x_space-link_size/2),
                                      int(dst_rect[1]+link_coordinates[1]*y_space))])

                    # Vertical width line
                    else:
                        c.fill_poly([(int(dst_rect[0]+position_coordinates[0]*x_space),
                                      int(dst_rect[1]+position_coordinates[1]*y_space)-link_size/2),
                                     (int(dst_rect[0]+position_coordinates[0]*x_space),
                                      int(dst_rect[1]+position_coordinates[1]*y_space)+link_size/2),
                                     (int(dst_rect[0]+link_coordinates[0]*x_space),
                                      int(dst_rect[1]+link_coordinates[1]*y_space)+link_size/2),
                                     (int(dst_rect[0]+link_coordinates[0]*x_space),
                                      int(dst_rect[1]+link_coordinates[1]*y_space)-link_size/2)])

            # Player Markers
            for sym in formation['positions'].iterkeys():
                c.forecolor = player_box_color
                position_coordinates = formation_spacing[sym]
                c.fill_oval((dst_rect[0]+position_coordinates[0]*x_space-player_box_width/2,
                             dst_rect[1]+position_coordinates[1]*y_space-player_box_height/2,
                             dst_rect[0]+position_coordinates[0]*x_space+player_box_width/2,
                             dst_rect[1]+position_coordinates[1]*y_space+player_box_height/2))

    view = StartWindowImageView(size=win_formation_bio.size)

    # ========== Position Labels ==========
    label_width = player_box_width
    label_height = 35
    pos_label_color = blue

    for symbol, position in formation['positions'].iteritems():
        pos_coordinates = formation_spacing[symbol]
        label_x = int(dst_rect[0]+pos_coordinates[0]*x_space-label_width/2)
        label_y = int(dst_rect[1]+pos_coordinates[1]*y_space-label_height/2)

        pos_label = Label(text=position['symbol'],font=title_font_2, width=label_width, height=label_height,
                                 x=label_x, y=label_y, color=pos_label_color, just='center')
        labels_list.append(pos_label)

    # ========== Button Declarations ==========
    add_formation_btn = Button()
    back_btn = Button("Back")

    # ========== Button Functions ==========
    def add_formation_btn_func():
        # Check if formation is already on selected formations list
        # Remove formation from list
        if formation in current_list.db:
            # Remove
            current_list.db.remove(formation)
            # Save
            current_list.sort(['name'])
            current_list.save(file_name, 'list', True)

            # Switch button title
            add_formation_btn.title = "Add Formation to List"

        # Add formation to the list
        else:
            # Add
            current_list.db.append(formation)
            # Save
            current_list.sort(['name'])
            current_list.save(file_name, 'list', True)

            # Switch button title
            add_formation_btn.title = "Remove Formation from List"

        win_formation_bio.become_target()

    def back_btn_func():
        win_formation_bio.hide()
        win_previous.show()

    # ========== Buttons ==========
    button_x_offset = 50

    add_formation_btn.x = win_formation_bio.width - button_width - button_x_offset
    add_formation_btn.y = top_border
    add_formation_btn.height = small_button_height
    add_formation_btn.width = button_width
    add_formation_btn.font = smaller_button_font
    add_formation_btn.action = add_formation_btn_func
    add_formation_btn.style = 'default'
    add_formation_btn.color = small_button_color

    # Check if formation is already on selected formations list
    if formation in current_list.db:
        add_formation_btn.title = "Remove Formation from List"
    else:
        add_formation_btn.title = "Add Formation to List"

    back_btn.x = add_formation_btn.left
    back_btn.y = add_formation_btn.bottom
    back_btn.height = small_button_height
    back_btn.width = button_width
    back_btn.font = small_button_font
    back_btn.action = back_btn_func
    back_btn.style = 'default'
    back_btn.color = small_button_color

    # ========== Name ==========
    formation_name_label = Label(text=formation['name'], font=title_font, width=title_width, height=title_height,
                                 x=(win_width - title_width)/2, y=top_border, color=title_color, just='center')
    # Shift title over the field
    formation_name_label.x = (win_formation_bio.width - title_width - button_width - 100) / 2
    labels_list.append(formation_name_label)

    # ========== Formation Info Title Label ==========
    info_title = Label(text="Formation Info", font=title_font_2,
                             width=title_width, height=title_height,
                             x=add_formation_btn.right - button_width/2 - title_width/2,
                             y=back_btn.bottom + top_border*3,
                             color=title_color, just='center')
    labels_list.append(info_title)

    # ========== Formation Info Labels ==========
    info_width = 110
    info_label_text = "Style:\n# Links:\n# Attackers:\n# Midfielders:\n# Defenders:"
    info_title_label = Label(text=info_label_text, font=std_tf_font_bold,
                             width=info_width, height=std_tf_height*5,
                             x=add_formation_btn.left - button_x_offset, y=info_title.bottom + title_border,
                             color=title_color, just='right')
    labels_list.append(info_title_label)

    # ========== Formation Info ==========
    info_text = (formation['style'] + "\n" + str(formation['num_links']) + "\n" + str(formation['num_attackers']) +
                 "\n" + str(formation['num_midfielders']) + "\n" + str(formation['num_defenders']))
    info_label = Label(text=info_text, font=std_tf_font_bold,
                       width=info_width, height=std_tf_height*5,
                       x=info_title_label.right + 10, y=info_title_label.top,
                       color=title_color, just='left')
    labels_list.append(info_label)

    # ========== Description Label ==========
    description_title_label = Label(text="Description:", font=std_tf_font_bold,
                                    width=small_button_width, height=std_tf_height,
                                    x=add_formation_btn.left, y=info_title_label.bottom + top_border,
                                    color=title_color, just='center')
    labels_list.append(description_title_label)

    # ========== Description ==========
    description = formation['description']
    description_text = ''
    max_chars = 25
    counter = 0
    for word in description.split():
        counter += len(word) + 1
        description_text += ' ' + word
        if counter >= max_chars:
            description_text += '\n'
            counter = 0
    description_label = Label(text=description_text, font=std_tf_font,
                              width=small_button_width+100, height=std_tf_height*13,
                              x=info_title_label.left, y=description_title_label.bottom + title_border,
                              color=title_color, just='left')
    labels_list.append(description_label)

    # ========== Add buttons to window ==========
    view.add(add_formation_btn)
    view.add(back_btn)

    for label in labels_list:
        view.add(label)

    win_formation_bio.add(view)
    view.become_target()
    win_formation_bio.show()
Пример #12
0
def open_attribute_window(window_x, window_y, db_dict, attr_dict, attr_list, attr_type, settings):

    # ========== Window ==========
    win_attribute = Window()
    win_attribute.title = attribute_win_title
    win_attribute.auto_position = False
    win_attribute.position = (window_x, window_y)
    win_attribute.size = (win_width, 500)
    win_attribute.resizable = 0
    win_attribute.name = attribute_title + " Window"
    win_attribute.show()

    # ========== Window Image View ==========
    class StartWindowImageView(View):
        def draw(self, c, r):
            c.backcolor = view_backcolor
            c.erase_rect(r)

    view = StartWindowImageView(size=win_attribute.size)

    attribute_display_list = []

    # ========== Title ==========
    title = Label(text=attribute_title)
    title.font = title_font
    title.width = title_width
    title.height = title_height
    title.x = (win_width - title_width) / 2
    title.y = top_border
    title.color = title_color
    title.just = 'center'

    # ========== Button Declarations ==========
    enter_btn = Button("Enter")
    erase_btn = Button("Erase List")
    back_btn = Button("Back")

    # ========== Radio Button Action ==========
    def selection_made():
        enter_btn.enabled = 1
        win_attribute.become_target()

    def comp_selection_made():
        win_attribute.become_target()

    # ========== Attribute Radio Buttons ==========
    radio_group = RadioGroup(action=selection_made)
    radio_button_list = []

    with open(config_filename, 'r') as f:
            attributes_list = json.load(f)['player_attributes']['all']
            f.close()

    for idx, attribute in enumerate(attributes_list):
        button = RadioButton(attribute)

        if idx < 10:
            button.width = 45
            button.x = (idx / 10) * (button.width + 5) + 5
        elif idx < 30:
            button.width = 100
            button.x = (idx / 10) * (button.width + 5) - 50
        elif idx < 40:
            button.width = 110
            button.x = (idx / 10) * (button.width + 5) - 80
        else:
            button.width = 100
            button.x = (idx / 10) * (button.width + 5) - 40

        button.y = (idx % 10) * 25 + title.bottom + 5
        button.group = radio_group
        button.value = attribute
        button.title = format_attr_name(attribute)

        radio_button_list.append(button)

    # ========== Button Functions ==========
    def enter_btn_func():
        valid = False
        return_value = None

        if attr_type == 'sort':
            # Check for doubles
            if attr_list.count(radio_group.value) == 0:
                attr_list.append(radio_group.value)

            show_attributes(attribute_display_list)
            erase_btn.enabled = 1

        elif attr_type == 'search':
            # Value checks
            if radio_group.value in ["PAC", "SHO", "PAS", "DRI", "DEF", "PHY", "DIV", "HAN", "KIC", "REF", "SPD", "POS",
                                     "acceleration", "aggression", "agility", "balance", "ballcontrol", "crossing",
                                     "curve", "dribbling", "finishing", "freekickaccuracy", "gkdiving", "gkhandling",
                                     "gkkicking", "gkpositioning", "gkreflexes", "headingaccuracy", "interceptions",
                                     "jumping", "longpassing", "longshots", "marking", "penalties", "positioning",
                                     "potential", "rating", "reactions", "shortpassing", "shotpower", "skillMoves",
                                     "slidingtackle", "sprintspeed", "stamina", "standingtackle", "strength", "vision",
                                     "volleys", "weakFoot"]:
                # Value should be an integer between 0 and 100
                if value_tf.value.isdigit():
                    return_value = int(value_tf.value)
                    if 0 < return_value < 100:
                        valid = True

            elif radio_group.value in ["age", "baseId", "clubId", "height", "id", "leagueId", "nationId", "weight"]:
                # Value should be an integer
                if value_tf.value.isdigit():
                    return_value = int(value_tf.value)
                    valid = True

            elif radio_group.value in ["atkWorkRate", "birthdate", "club", "color", "commonName", "defWorkRate",
                                       "firstName", "foot", "itemType", "lastName", "league", "modelName", "name",
                                       "name_custom", "nation", "playStyle", "playerType", "position", "positionFull",
                                       "quality"]:
                # Value should be a string
                if type(value_tf.value) is str:
                    return_value = value_tf.value
                    valid = True

            elif radio_group.value in ["isGK", "isSpecialType"]:
                # Value should be a string
                if value_tf.value.upper() in ['T', 'F', 'TRUE', 'FALSE', 'Y', 'N', 'YES', 'NO']:
                    if value_tf.value.upper()[0] in ['T', 'Y']:
                        return_value = True
                    else:
                        return_value = False
                    valid = True

            if valid:
                attr_dict[radio_group.value] = (return_value, compare_group.value)
                value_tf.value = ''
                show_attributes(attribute_display_list)
                erase_btn.enabled = 1
            else:
                print "Invalid attribute value."

        else:
            print 'Invalid attr_type for AddAttribute.'

    def erase_btn_func():
        if attr_type == 'sort':
            del attr_list[:]
        elif attr_type == 'search':
            attr_dict.clear()

        show_attributes(attribute_display_list)

        erase_btn.enabled = 0

    def back_btn_func():
        SearchMenu.open_search_menu(win_attribute.x, win_attribute.y,
                                    db_dict, attr_dict, attr_list, settings)
        win_attribute.hide()

    # ========== Buttons ==========
    erase_btn.x = (win_width - button_width) / 2
    erase_btn.y = win_attribute.height - 70
    erase_btn.height = button_height
    erase_btn.width = button_width
    erase_btn.font = button_font
    erase_btn.action = erase_btn_func
    erase_btn.style = 'default'
    erase_btn.color = button_color
    erase_btn.just = 'right'
    if (attr_type == 'sort' and len(attr_list) == 0) or \
        (attr_type == 'search' and len(attr_dict) == 0):
        erase_btn.enabled = 0

    enter_btn.x = erase_btn.left - button_spacing - button_width
    enter_btn.y = erase_btn.top
    enter_btn.height = button_height
    enter_btn.width = button_width
    enter_btn.font = button_font
    enter_btn.action = enter_btn_func
    enter_btn.style = 'default'
    enter_btn.color = button_color
    enter_btn.just = 'right'
    enter_btn.enabled = 0

    back_btn.x = erase_btn.right + button_spacing
    back_btn.y = erase_btn.top
    back_btn.height = button_height
    back_btn.width = button_width
    back_btn.font = button_font
    back_btn.action = back_btn_func
    back_btn.style = 'default'
    back_btn.color = button_color
    back_btn.just = 'right'

    # ========== Value Textfield ==========
    value_tf = TextField()
    value_tf.width = 200
    value_tf.x = (win_width - value_tf.width) / 2
    value_tf.y = enter_btn.top - 35
    value_tf.height = 25
    value_tf.font = std_tf_font

    # ========== Compare Radio Buttons ==========
    compare_group = RadioGroup(action=comp_selection_made)
    comp_button_list = []

    comp_button_width = 55
    comp_button_x = (win_attribute.width - 4*comp_button_width)/2

    for value in ['higher', 'exact', 'lower', 'not']:
        button = RadioButton(attribute)
        button.width = comp_button_width
        button.x = comp_button_x
        button.y = value_tf.top - value_tf.height - title_border
        button.group = compare_group
        button.value = value
        button.title = value.capitalize()

        comp_button_x += comp_button_width + 5

        comp_button_list.append(button)

    compare_group.value = 'higher'

    def show_attributes(display_list):

        # Remove old attribute labels from screen
        for message in display_list:
            view.remove(message)

        del display_list[:]

        # Display new search attributes on screen
        message_x = 10
        message_y = win_attribute.height - 150

        if attr_type == 'search':
            display_list.append(Label(text=("Search Attributes:"), font=title_tf_font, width=std_tf_width,
                                   height=std_tf_height, x=message_x, y=message_y, color=title_color))
            message_y += std_tf_height

            index = 0

            for key, search_value in attr_dict.iteritems():
                if index == 6:
                    message_x = back_btn.right + 10
                    message_y = win_attribute.height - 150

                msg_text = format_attr_name(key) + ": "
                if key in ['id', 'baseId', 'nationId', 'leagueId', 'clubId']:
                    msg_text += str(search_value[0])
                elif type(search_value[0]) is int:
                    msg_text += search_value[1].capitalize() + ' ' + str(search_value[0])
                elif search_value[1] == 'not':
                    msg_text += search_value[1].capitalize() + ' "' + str(search_value[0]) + '"'
                else:
                    msg_text += '"' + str(search_value[0]) + '"'

                attr_label = Label(text=msg_text, font=std_tf_font, width=std_tf_width,
                                   height=std_tf_height, x=message_x, y=message_y, color=title_color)
                message_y += std_tf_height
                display_list.append(attr_label)
                index += 1

        # Display new sort attributes on screen
        elif attr_type == 'sort':
            display_list.append(Label(text=("Sort Attributes:"), font=title_tf_font, width=std_tf_width,
                                       height=std_tf_height, x=message_x, y=message_y, color=title_color))
            message_y += std_tf_height

            for index, sort_value in enumerate(attr_list):
                if index == 6:
                    message_x = back_btn.right + 10
                    message_y = win_attribute.height - 150

                attr_label = Label(text=(format_attr_name(sort_value)), font=std_tf_font, width=std_tf_width,
                                   height=std_tf_height, x=message_x, y=message_y, color=title_color)
                message_y += std_tf_height
                display_list.append(attr_label)

        for attribute_label in display_list:
            view.add(attribute_label)

    show_attributes(attribute_display_list)

    # ========== Add buttons to window ==========
    view.add(title)
    view.add(enter_btn)
    view.add(erase_btn)
    view.add(back_btn)

    # Shows only for getting attribute for search, not sort
    if attr_type == 'search':
        view.add(value_tf)

        for button in comp_button_list:
            view.add(button)

    for button in radio_button_list:
        view.add(button)

    win_attribute.add(view)
    view.become_target()
    win_attribute.show()
Пример #13
0
def open_pick_position_window(window_x, window_y, player, player_db, settings, btn, previous_window):

    # ========== Window ==========
    win_position = Window()
    win_position.title = pick_position_win_title
    win_position.auto_position = False
    win_position.position = (window_x, window_y)
    win_position.size = (win_width, 500)
    win_position.resizable = 0
    win_position.name = pick_position_title + " Window"
    win_position.show()

    # ========== Window Image View ==========
    class StartWindowImageView(View):
        def draw(self, c, r):
            c.backcolor = view_backcolor
            c.erase_rect(r)

    view = StartWindowImageView(size=win_position.size)

    display_list = []

    # ========== Title ==========
    title = Label(text=pick_position_title)
    title.font = title_font
    title.width = title_width
    title.height = title_height
    title.x = (win_width - title_width) / 2
    title.y = top_border
    title.color = title_color
    title.just = 'center'
    display_list.append(title)

    # ========== Button Function ==========
    def pos_btn_func(position_short, position_full):
        # Edit player's position
        player_data = player_db.search({'id': (player['id'], 'exact')})
        player_index = player_db.db.index(player_data[0])
        player_db.db[player_index]['position'] = position_short
        player_db.db[player_index]['positionFull'] = position_full

        # Save
        player_db.save(settings['file_name'], 'list', True)

        # Change button symbol
        btn.title = position_short
        win_position.hide()
        previous_window.show()

    def back_btn_func():
        # Go back
        win_position.hide()
        previous_window.show()

    # ========== Position Buttons ==========
    msg_x = (win_position.width - 5*button_width - 4*button_spacing) / 2
    msg_y = title.bottom + title_border
    positions = [
        ('LW', 'Left Wing'), ('LF', 'Left Forward'), ('ST', 'Striker'), ('RF', 'Right Forward'), ('RW', 'Right Wing'),
        ('CF', 'Centre Forward'),
        ('CAM', 'Centre Attacking Midfielder'),
        ('LM', 'Left Midfielder'), ('CM', 'Centre Midfielder'), ('RM', 'Right Midfielder'),
        ('CDM', 'Centre Defensive Midfielder'),
        ('LWB', 'Left Wing Back'), ('LB', 'Left Back'), ('CB', 'Centre Back'), ('RB', 'Right Back'),
        ('RWB', 'Right Wing Back'),
        ('GK', 'Goalkeeper')]

    for index, pos in enumerate(positions):
        if pos[0] in ['CAM', 'CDM']:
            width = button_width + 65
        else:
            width = button_width

        if index == 5:
            msg_x = (win_position.width - width) / 2
            msg_y += small_button_height + button_spacing
        elif index == 6:
            msg_x = (win_position.width - width) / 2
            msg_y += small_button_height + button_spacing
        elif index == 7:
            msg_x = (win_position.width - 3*width - 2*button_spacing) / 2
            msg_y += small_button_height + button_spacing
        elif index == 10:
            msg_x = (win_position.width - width) / 2
            msg_y += small_button_height + button_spacing
        elif index == 11:
            msg_x = (win_position.width - 5*width - 4*button_spacing) / 2
            msg_y += small_button_height + button_spacing
        elif index == 16:
            msg_x = (win_position.width - width) / 2
            msg_y += small_button_height + button_spacing

        position_title = pos[0] + ' - ' + pos[1]
        pos_btn = Button(title=position_title, width=width, height=small_button_height, x=msg_x, y=msg_y,
                         action=(pos_btn_func, pos[0], pos[1]), font=smaller_tf_font)
        display_list.append(pos_btn)

        msg_x += width + button_spacing

    # ========== Back Button ==========
    msg_x = (win_position.width - button_width) / 2
    msg_y += small_button_height + top_border
    back_btn = Button("Back", width=button_width, height=button_height, x=msg_x, y=msg_y,
                      action=back_btn_func, font=button_font)
    display_list.append(back_btn)

    # ========== Add buttons to window ==========
    for item in display_list:
        view.add(item)

    win_position.add(view)
    view.become_target()
    win_position.show()
Пример #14
0
def open_create_list_window(window_x, window_y, db_dict, settings):

    message_text = 'Select list type.'
    create_list_settings = dict()
    create_list_settings['results'] = []
    create_list_settings['process_step'] = 'list type'
    num_results = 5

    # ========== Window ==========
    win_create_list = Window()
    win_create_list.title = create_list_win_title
    win_create_list.auto_position = False
    win_create_list.position = (window_x+100, window_y+100)
    win_create_list.size = (win_width-100, win_height-200)
    win_create_list.resizable = 0
    win_create_list.name = create_list_title + " Window"
    win_create_list.show()

    # ========== Window Image View ==========
    class StartWindowImageView(View):
        def draw(self, c, r):
            c.backcolor = view_backcolor
            c.erase_rect(r)

    view = StartWindowImageView(size=win_create_list.size)

    # ========== Title ==========
    title = Label(text=create_list_title)
    title.font = title_font
    title.width = title_width
    title.height = title_height
    title.x = (win_create_list.width - title_width) / 2
    title.y = top_border
    title.color = title_color
    title.just = 'center'

    # ========== Message Label ==========
    message = Label(font=title_font_3, width=win_create_list.width - 50, height=title_height,
                    x=25, y=title.bottom + top_border, color=title_color, just='center')
    message.text = message_text

    # ========== Button Declarations ==========
    enter_btn = Button("Enter")
    undo_btn = Button("Undo Add")
    back_btn = Button("Back")

    player_list_btn = Button("Player")
    formation_list_btn = Button("Formation")
    team_list_btn = Button("Team")

    # ========== Results Navigation Item Declarations ==========
    previous_btn = Button("<<< Previous %d" % num_results)
    next_btn = Button("Next %d >>>" % num_results)
    total_num_results_label = Label()
    pages_label = Label()

    # ========== Button Functions ==========
    def enter_btn_func():
        # Get file name and save
        if create_list_settings['process_step'] == 'file name':

            # Get file name and file prefix
            file_name = value_tf.value
            file_prefix = get_file_prefix('current_' + create_list_settings['list_type'] + '_list')

            if len(file_name) > 0:

                if not isfile('JSONs/' + file_prefix + file_name + '.json'):

                    # Create list object, set message, and set process step
                    if create_list_settings['list_type'] == 'player':
                        new_list = PlayerDB()
                        message.text = "Enter player rating/name or just name."
                        create_list_settings['process_step'] = 'get player'

                    elif create_list_settings['list_type'] == 'formation':
                        new_list = FormationDB()
                        message.text = "Enter part or full formation name, or nothing for full list."
                        create_list_settings['process_step'] = 'get formation'

                    elif create_list_settings['list_type'] == 'team':
                        new_list = TeamDB()
                        message.text = "Blank team list created. Add teams from Search menu."
                        create_list_settings['process_step'] = 'get team'
                        back_btn.title = "Done"
                        enter_btn.enabled = 0

                    else:
                        new_list = PlayerDB()
                        print "Invalid list type."

                    # Assign file name and file object
                    create_list_settings['list'] = new_list
                    create_list_settings['file_name'] = file_name

                    # Clear box content
                    value_tf.value = ''

                else:
                    message.text = "A file with that name already exists."

            else:
                message.text = "File name must be at least 1 character."

        # Get player to add to list
        elif create_list_settings['process_step'] == 'get player':
            # Get input
            player_input = value_tf.value

            # Remove result messages off page
            for result_message in create_list_settings['results']:
                view.remove(result_message)

            if len(player_input) > 0:
                search_dict = {}

                # Check for rating
                if player_input.split(' ')[0].isdigit():
                    # Check if there is a name and rating
                    if len(player_input.split(' ')) > 1:
                        search_dict['rating'] = (int(player_input.split(' ')[0]), 'exact')

                        # Get name
                        search_dict['name_custom'] = (player_input.split(' ', 1)[1], 'exact')

                    else:
                        message.text = "Invalid. Ex: '99 Superman'  or 'Superman'."

                # No rating, just name (or invalid)
                else:
                    search_dict['name_custom'] = (player_input, 'exact')

                # Valid input
                if len(search_dict) > 0:
                    # Search for players
                    results = PlayerDB(db_dict['player_db'][1].search(search_dict))
                    results.sort(['rating'])

                    # No matching players found
                    if len(results.db) == 0:
                        message.text = "Unable to find player. Try again."

                    # If only one player in results, add player.
                    elif len(results.db) == 1:
                        add_player_btn_func(results.db[0])

                    else:
                        message.text = "Multiple players found. Pick correct one."
                        display_players(results, [], (0, num_results))

            else:
                message.text = "Invalid. Ex: '99 Superman' or 'Superman'."

        # Get formation to add to list
        elif create_list_settings['process_step'] == 'get formation':
            # Get input
            formation_input = value_tf.value

            # Remove result messages off page
            for result_message in create_list_settings['results']:
                view.remove(result_message)

            search_dict = {'name': (formation_input, 'exact')}

            # Search for formations
            results = FormationDB(db_dict['formation_db'][1].search(search_dict))
            # Remove formations already on list
            for formation in create_list_settings['list'].db:
                if formation in results.db:
                    results.db.remove(formation)
            results.sort(['name'])

            # No matching formations found
            if len(results.db) == 0:
                message.text = "Unable to find formation. Try again."

            # If only one formation in results, add formation.
            elif len(results.db) == 1:
                add_formation_btn_func(results.db[0])

            else:
                message.text = "Multiple formations found. Pick correct one."
                display_formations(results, [], (0, num_results))

        # Get team to add to list
        elif create_list_settings['process_step'] == 'get team':
            stuff = 0

        # Invalid process step
        else:
            print "Create file process step is invalid."

        value_tf.become_target()

    def undo_btn_func():
        # Remove last player added and save
        if create_list_settings['process_step'] == 'get player':
            if len(create_list_settings['list'].db) > 0:
                player = create_list_settings['list'].db.pop(-1)
                create_list_settings['list'].save(create_list_settings['file_name'], 'list', True)

                common_name = ascii_text(player['commonName'])
                player_name = ascii_text(player['firstName']) + ' ' + ascii_text(player['lastName'])
                if len(common_name) > 0:
                    player_name = common_name + " (" + player_name + ")"

                message.text = "Removed %s!" % player_name

        # Remove last formation added and save
        elif create_list_settings['process_step'] == 'get formation':
            if len(create_list_settings['list'].db) > 0:
                formation = create_list_settings['list'].db.pop(-1)
                create_list_settings['list'].save(create_list_settings['file_name'], 'list', True)

                message.text = "Removed %s!" % formation['name']

        # Disable undo if no items left
        if len(create_list_settings['list'].db) == 0:
            undo_btn.enabled = 0

    def back_btn_func():
        # Sort and save player list before exiting
        if create_list_settings['process_step'] == 'get player':
            create_list_settings['list'].sort(['rating'])
            create_list_settings['list'].save(create_list_settings['file_name'], 'list', True)

        # Sort and save formation list before exiting
        elif create_list_settings['process_step'] == 'get formation':
            create_list_settings['list'].sort(['name'])
            create_list_settings['list'].save(create_list_settings['file_name'], 'list', True)

        elif create_list_settings['process_step'] == 'get team':
            create_list_settings['list'].sort(['rating'])
            create_list_settings['list'].save(create_list_settings['file_name'], True)

        FilesMenu.open_files_menu(window_x, window_y, db_dict, settings)
        win_create_list.hide()

    def list_type_func(list_type):
        # Remove list type buttons
        view.remove(player_list_btn)
        view.remove(formation_list_btn)
        view.remove(team_list_btn)

        # Add textfield, enabled enter button, and change message
        view.add(value_tf)
        enter_btn.enabled = 1
        message.text = "Enter file name."
        create_list_settings['list_type'] = list_type

        # Set list type
        create_list_settings['process_step'] = 'file name'
        value_tf.become_target()

    # ========== Action Buttons ==========
    enter_btn.x = (win_create_list.width - 3*button_width - 2*button_spacing) / 2
    enter_btn.y = win_create_list.height - button_height - 40
    enter_btn.height = button_height
    enter_btn.width = button_width
    enter_btn.font = button_font
    enter_btn.action = enter_btn_func
    enter_btn.style = 'default'
    enter_btn.color = button_color
    enter_btn.just = 'right'
    enter_btn.enabled = 0

    undo_btn.x = enter_btn.right + button_spacing
    undo_btn.y = enter_btn.top
    undo_btn.height = button_height
    undo_btn.width = button_width
    undo_btn.font = button_font
    undo_btn.action = undo_btn_func
    undo_btn.style = 'default'
    undo_btn.color = button_color
    undo_btn.just = 'right'
    undo_btn.enabled = 0

    back_btn.x = undo_btn.right + button_spacing
    back_btn.y = enter_btn.top
    back_btn.height = button_height
    back_btn.width = button_width
    back_btn.font = button_font
    back_btn.action = back_btn_func
    back_btn.style = 'default'
    back_btn.color = button_color
    back_btn.just = 'right'

    # ========== List Type Buttons ==========
    player_list_btn.x = (win_create_list.width - 3*button_width - 2*button_spacing) / 2
    player_list_btn.y = message.bottom + top_border
    player_list_btn.height = button_height
    player_list_btn.width = button_width
    player_list_btn.font = button_font
    player_list_btn.action = (list_type_func, 'player')
    player_list_btn.style = 'default'
    player_list_btn.color = button_color
    player_list_btn.just = 'right'

    formation_list_btn.x = player_list_btn.right + button_spacing
    formation_list_btn.y = player_list_btn.top
    formation_list_btn.height = button_height
    formation_list_btn.width = button_width
    formation_list_btn.font = button_font
    formation_list_btn.action = (list_type_func, 'formation')
    formation_list_btn.style = 'default'
    formation_list_btn.color = button_color
    formation_list_btn.just = 'right'

    team_list_btn.x = formation_list_btn.right + button_spacing
    team_list_btn.y = player_list_btn.top
    team_list_btn.height = button_height
    team_list_btn.width = button_width
    team_list_btn.font = button_font
    team_list_btn.action = (list_type_func, 'team')
    team_list_btn.style = 'default'
    team_list_btn.color = button_color
    team_list_btn.just = 'right'

    # ========== Value Textfield ==========
    value_tf = TextField()
    value_tf.width = 200
    value_tf.x = (win_create_list.width - value_tf.width) / 2
    value_tf.y = message.bottom + top_border
    value_tf.height = 25
    value_tf.font = std_tf_font

    # ========== Players navigation functions ==========
    def previous_btn_func(display_db=None, attributes=None, index_range=None):
        if display_db is not None:
            # display previous results
            if create_list_settings['process_step'] == 'get player':
                display_players(display_db, attributes, index_range)
            elif create_list_settings['process_step'] == 'get formation':
                display_formations(display_db, attributes, index_range)
        win_create_list.become_target()

    def next_btn_func(display_db=None, attributes=None, index_range=None):
        if display_db is not None:
            # display next results
            if create_list_settings['process_step'] == 'get player':
                display_players(display_db, attributes, index_range)
            elif create_list_settings['process_step'] == 'get formation':
                display_formations(display_db, attributes, index_range)
        win_create_list.become_target()

    def add_player_btn_func(player):
        # Check for duplicates
        if create_list_settings['list'].db.count(player) == 0:
            # Add player and save
            create_list_settings['list'].db.append(player)
            create_list_settings['list'].save(create_list_settings['file_name'], 'list', True)

            # Remove result messages off page
            for result_message in create_list_settings['results']:
                view.remove(result_message)

            common_name = ascii_text(player['commonName'])
            player_name = ascii_text(player['firstName']) + ' ' + ascii_text(player['lastName'])
            if len(common_name) > 0:
                player_name = common_name + " (" + player_name + ")"

            # Reset page
            value_tf.value = ''
            message.text = "Added %s!" % player_name
            back_btn.title = "Done"
            undo_btn.enabled = 1
            value_tf.become_target()

        # Duplicate player, don't add
        else:
            message.text = "Player already on list."
            win_create_list.become_target()

    def add_formation_btn_func(formation):
        # Check for duplicates
        if create_list_settings['list'].db.count(formation) == 0:
            # Add formation and save
            create_list_settings['list'].db.append(formation)
            create_list_settings['list'].save(create_list_settings['file_name'], 'list', True)

            # Remove result messages off page
            for result_message in create_list_settings['results']:
                view.remove(result_message)

            # Reset page
            value_tf.value = ''
            message.text = "Added %s!" % formation['name']
            back_btn.title = "Done"
            undo_btn.enabled = 1
            value_tf.become_target()

        # Duplicate formation, don't add
        else:
            message.text = "Formation already on list."
            win_create_list.become_target()

    # ========== Display Players Buttons ==========
    previous_btn.height = tiny_button_height
    previous_btn.width = small_button_width
    previous_btn.x = (win_create_list.width - 2*small_button_width - small_button_spacing) / 2
    previous_btn.y = value_tf.bottom + top_border
    previous_btn.font = small_button_font
    previous_btn.action = previous_btn_func
    previous_btn.style = 'default'
    previous_btn.color = small_button_color
    previous_btn.just = 'right'

    next_btn.height = tiny_button_height
    next_btn.width = small_button_width
    next_btn.x = previous_btn.right + small_button_spacing
    next_btn.y = previous_btn.top
    next_btn.font = small_button_font
    next_btn.action = next_btn_func
    next_btn.style = 'default'
    next_btn.color = small_button_color
    next_btn.just = 'right'

    total_num_results_label.font = std_tf_font
    total_num_results_label.width = 100
    total_num_results_label.height = std_tf_height
    total_num_results_label.x = previous_btn.left + - 100 - 10
    total_num_results_label.y = previous_btn.top
    total_num_results_label.color = title_color
    total_num_results_label.just = 'right'

    pages_label.font = std_tf_font
    pages_label.width = 125
    pages_label.height = std_tf_height
    pages_label.x = next_btn.right + 10
    pages_label.y = previous_btn.top
    pages_label.color = title_color
    pages_label.just = 'left'

    # ========== Display info from search ==========
    def display_players(results_list, attributes, index_range):
        # Remove old messages off page
        for result_message in create_list_settings['results']:
            view.remove(result_message)
        del create_list_settings['results'][:]

        # Add navigation buttons to page
        previous_range = (index_range[0]-num_results, index_range[0])
        previous_btn.action = (previous_btn_func, results_list, attributes, previous_range)

        next_range = (index_range[1], index_range[1]+num_results)
        next_btn.action = (next_btn_func, results_list, attributes, next_range)

        total_num_results_label.text = str(len(results_list.db)) + " Players"
        pages_label.text = "Page %d of %d" % (int(index_range[1]/num_results),
                                              math.ceil(len(results_list.db)/float(num_results)))

        if index_range[0] > 0:
            previous_btn.enabled = 1
        else:
            previous_btn.enabled = 0
        if index_range[1] <= len(results_list.db) - 1:
            next_btn.enabled = 1
        else:
            next_btn.enabled = 0

        create_list_settings['results'].append(previous_btn)
        create_list_settings['results'].append(next_btn)
        create_list_settings['results'].append(total_num_results_label)
        create_list_settings['results'].append(pages_label)

        # Print out labels
        labels = [''] + player_info_labels(attributes)
        stat_index = 0
        add_btn_width = 30
        add_btn_space = add_btn_width + 10
        spacing_list = [add_btn_space, 125, 40, 40, 65, 115, 115, 115]
        left_border = (win_create_list.width - sum(spacing_list)) / 2
        msg_x = left_border
        msg_y = previous_btn.bottom + 5

        for info_label in labels:
            player_label = Label(text=info_label, font=std_tf_font_bold, width=spacing_list[stat_index]-5,
                                 height=std_tf_height, x=msg_x, y=msg_y, color=title_color)
            create_list_settings['results'].append(player_label)
            msg_x += spacing_list[stat_index]
            stat_index += 1

        msg_y += std_tf_height + 5

        # Print out players
        for idx, player in enumerate(results_list.db[index_range[0]:index_range[1]]):
            msg_x = left_border
            player_stats = player_info(player, attributes)
            stat_index = 0

            add_btn = Button("Add", width=add_btn_width, height=15, x=msg_x, y=msg_y,
                             action=(add_player_btn_func, player))
            create_list_settings['results'].append(add_btn)
            msg_x += spacing_list[stat_index]
            stat_index += 1

            for player_stat in player_stats:
                player_label = Label(text=player_stat, font=small_button_font, width=win_width-(2*left_border),
                                     height=std_tf_height, x=msg_x, y=msg_y, color=title_color)

                create_list_settings['results'].append(player_label)
                msg_x += spacing_list[stat_index]
                stat_index += 1

            msg_y += std_tf_height

        for results_msg in create_list_settings['results']:
            view.add(results_msg)

    def display_formations(results_list, attributes, index_range):
        # Remove old messages off page
        for result_message in create_list_settings['results']:
            view.remove(result_message)
        del create_list_settings['results'][:]

        # Add navigation buttons to page
        previous_range = (index_range[0]-num_results, index_range[0])
        previous_btn.action = (previous_btn_func, results_list, attributes, previous_range)

        next_range = (index_range[1], index_range[1]+num_results)
        next_btn.action = (next_btn_func, results_list, attributes, next_range)

        total_num_results_label.text = str(len(results_list.db)) + " Formations"
        pages_label.text = "Page %d of %d" % (int(index_range[1]/num_results),
                                              math.ceil(len(results_list.db)/float(num_results)))

        if index_range[0] > 0:
            previous_btn.enabled = 1
        else:
            previous_btn.enabled = 0
        if index_range[1] <= len(results_list.db) - 1:
            next_btn.enabled = 1
        else:
            next_btn.enabled = 0

        create_list_settings['results'].append(previous_btn)
        create_list_settings['results'].append(next_btn)
        create_list_settings['results'].append(total_num_results_label)
        create_list_settings['results'].append(pages_label)

        # Print out labels
        labels = [''] + formation_info_labels()[:-2]
        stat_index = 0
        add_btn_width = 30
        add_btn_space = add_btn_width + 10
        spacing_list = [add_btn_space, 100, 100, 55, 55, 55, 55]
        left_border = (win_create_list.width - sum(spacing_list)) / 2
        msg_x = left_border
        msg_y = previous_btn.bottom + 5

        for info_label in labels:
            player_label = Label(text=info_label, font=std_tf_font_bold, width=win_width-(2*left_border),
                                 height=std_tf_height, x=msg_x, y=msg_y, color=title_color)
            create_list_settings['results'].append(player_label)
            msg_x += spacing_list[stat_index]
            stat_index += 1

        msg_y += std_tf_height + 5

        # Print out formations
        for idx, formation in enumerate(results_list.db[index_range[0]:index_range[1]]):
            msg_x = left_border
            formation_stats = formation_info(formation)[:-2]
            stat_index = 0

            add_btn = Button("Add", width=add_btn_width, height=15, x=msg_x, y=msg_y,
                             action=(add_formation_btn_func, formation))
            create_list_settings['results'].append(add_btn)
            msg_x += spacing_list[stat_index]
            stat_index += 1

            for formation_stat in formation_stats:
                formation_label = Label(text=formation_stat, font=small_button_font, width=win_width-(2*left_border),
                                        height=std_tf_height, x=msg_x, y=msg_y, color=title_color)

                create_list_settings['results'].append(formation_label)
                msg_x += spacing_list[stat_index]
                stat_index += 1

            msg_y += std_tf_height

        for results_msg in create_list_settings['results']:
            view.add(results_msg)

    # ========== Add items to window ==========
    view.add(title)
    view.add(message)
    view.add(enter_btn)
    view.add(undo_btn)
    view.add(back_btn)
    view.add(player_list_btn)
    view.add(formation_list_btn)
    view.add(team_list_btn)

    win_create_list.add(view)
    view.become_target()
    win_create_list.show()
Пример #15
0
def open_teams_menu(window_x, window_y, db_dict):

    # ========== Window ==========
    win_teams = Window()
    win_teams.title = teams_win_title
    win_teams.auto_position = False
    win_teams.position = (window_x, window_y)
    win_teams.size = (win_width, win_height)
    win_teams.resizable = 0
    win_teams.name = teams_title + " Window"

    # ========== Window Image View ==========
    class FormationsWindowImageView(View):
        def draw(self, c, r):
            c.backcolor = view_backcolor
            c.erase_rect(r)

    view = FormationsWindowImageView(size=win_teams.size)

    # ========== Title ==========
    title = Label(text=teams_title)
    title.font = title_font
    title.width = title_width
    title.height = title_height
    title.x = (win_width - title_width) / 2
    title.y = top_border
    title.color = title_color
    title.just = 'center'

    # ========== Button Declarations ==========
    create_ultimate_teams_btn = Button("Generate Ultimate Teams")
    manually_create_teams_btn = Button("Build Ultimate Teams")
    back_btn = Button("Back")

    # ========== Button Functions ==========
    def create_ultimate_teams_btn_func():
        win_teams.become_target()
        CreateUltimateTeams.open_create_ultimate_teams_window(win_teams.x, win_teams.y, db_dict, win_teams)
        win_teams.hide()

    def manually_create_teams_btn_func():
        win_teams.become_target()
        PickFormation.open_pick_formation_window(win_teams.x, win_teams.y, db_dict, win_teams)
        win_teams.hide()

    def back_btn_func():
        win_teams.become_target()
        StartMenu.open_start_menu(win_teams.x, win_teams.y, db_dict)
        win_teams.hide()

    # ========== Buttons ==========
    create_ultimate_teams_btn.x = (win_width - file_btn_width) / 2
    create_ultimate_teams_btn.y = title.bottom + top_border
    create_ultimate_teams_btn.height = button_height
    create_ultimate_teams_btn.width = file_btn_width
    create_ultimate_teams_btn.font = button_font
    create_ultimate_teams_btn.action = create_ultimate_teams_btn_func
    create_ultimate_teams_btn.style = 'default'
    create_ultimate_teams_btn.color = button_color
    create_ultimate_teams_btn.just = 'right'

    manually_create_teams_btn.x = (win_width - file_btn_width) / 2
    manually_create_teams_btn.y = create_ultimate_teams_btn.bottom + top_border
    manually_create_teams_btn.height = button_height
    manually_create_teams_btn.width = file_btn_width
    manually_create_teams_btn.font = button_font
    manually_create_teams_btn.action = manually_create_teams_btn_func
    manually_create_teams_btn.style = 'default'
    manually_create_teams_btn.color = button_color
    manually_create_teams_btn.just = 'right'

    back_btn.x = (win_width - button_width) / 2
    back_btn.y = manually_create_teams_btn.bottom + top_border*2
    back_btn.height = button_height
    back_btn.width = button_width
    back_btn.font = button_font
    back_btn.action = back_btn_func
    back_btn.style = 'default'
    back_btn.color = button_color
    back_btn.just = 'right'

    # ========== Add components to view and add view to window ==========
    view.add(title)
    view.add(create_ultimate_teams_btn)
    view.add(manually_create_teams_btn)
    view.add(back_btn)

    win_teams.add(view)
    view.become_target()
    win_teams.show()
Пример #16
0
def open_edit_menu(window_x, window_y, db_dict, attr_dict=None, attr_list=None, settings=None):

    list_players = PlayerDB.PlayerDB()
    list_formations = FormationDB.FormationDB()
    list_teams = TeamDB.TeamDB()

    if settings['edit_subject'] == 'players':
        list_players.load(settings['file_name'], 'list')
    elif settings['edit_subject'] == 'formations':
        list_formations.load(settings['file_name'], 'list')
    elif settings['edit_subject'] == 'teams':
        list_teams.load(settings['file_name'])

    if attr_dict is None:
        attr_dict = {}

    if attr_list is None:
        attr_list = []

    if settings is None:
        settings = {
            'window': 'edit',
            'edit_type': 'add',
            'edit_mode': 'simple',
            'edit_subject': 'players',
            'sort_order': True,
            'messages': {
                'search': [],
                'sort': [],
                'results': []
            }
        }
    else:
        if 'window' not in settings:
            settings['window'] = 'edit'
        if 'edit_type' not in settings:
            settings['edit_type'] = 'add'
        if 'edit_mode' not in settings:
            settings['edit_mode'] = 'simple'
        if 'edit_subject' not in settings:
            settings['edit_subject'] = 'players'
        if 'sort_order' not in settings:
            settings['sort_order'] = True
        if 'messages' not in settings:
            settings['messages'] = {'search': [], 'sort': [], 'results': []}

    num_results = 20
    general_display = []
    simple_display = []
    advanced_display = []

    # ========== Window ==========
    win_edit = Window()
    win_edit.title = edit_win_title
    win_edit.auto_position = False
    win_edit.position = (window_x, window_y)
    win_edit.size = (win_width, win_height)
    win_edit.resizable = 0
    win_edit.name = edit_title + " Window"

    # ========== Window Image View ==========
    class FormationsWindowImageView(View):
        def draw(self, c, r):
            c.backcolor = view_backcolor
            c.erase_rect(r)

    view = FormationsWindowImageView(size=win_edit.size)

    # ========== Title ==========
    title = Label(text=edit_title + ' File: ' + settings['file_name'])
    title.font = title_font
    title.width = title_width
    title.height = title_height
    title.x = (win_width - title_width) / 2
    title.y = top_border
    title.color = title_color
    title.just = 'center'
    general_display.append(title)

    # ========== Action Button Declarations ==========
    start_btn = Button("Start")
    back_btn = Button("Back")

    # ========== Mode Button Declarations ==========
    simple_btn = Button("Simple")
    advanced_btn = Button("Advanced")

    # ========== Tool Button Declarations ==========
    attribute_btn = Button("Add Search Attribute")
    sort_btn = Button("Add Sort Attribute")
    reset_btn = Button("Reset Results")

    # ========== Simple Field Declarations ==========
    rating_label = Label("Rating: ")
    rating_tf = TextField()
    name_label = Label("Name: ")
    name_tf = TextField()

    # ========== Action Button Functions ==========
    def start_btn_func():
        # Search for players based on attributes
        if settings['edit_subject'] == 'players':

            # Get the attributes to search with based on what mode is in use
            if simple_btn.enabled == 0:
                if len(name_tf.value) > 0:
                    search_dict = {'name_custom': (name_tf.value, 'exact')}
                else:
                    search_dict = {}
                if rating_tf.value.isdigit():
                    search_dict['rating'] = (int(rating_tf.value), 'exact')
            else:
                search_dict = attr_dict

            # Get players from database to add and search
            if settings['edit_type'] == 'add':

                db_players = db_dict['player_db'][1]

                if len(search_dict) == 0:
                    search_results = db_players
                else:
                    search_results = db_players.search(search_dict)
                    search_results = PlayerDB.PlayerDB(search_results)

            # Get players from list to edit or delete and search
            else:
                if len(search_dict) == 0:
                    search_results = list_players
                else:
                    search_results = list_players.search(search_dict)
                    search_results = PlayerDB.PlayerDB(search_results)

            # Sort players - if no attribute selected, use rating
            if len(attr_list) == 0:
                search_results.sort(['rating'], sort_order_radio_group.value)
            else:
                search_results.sort(attr_list, sort_order_radio_group.value)

            # Get attributes list and avoid duplicates
            attributes_list = []

            for attr in attr_list:
                if attributes_list.count(attr) == 0:
                    attributes_list.append(attr)

            for attr_key in attr_dict.iterkeys():
                if attributes_list.count(attr_key) == 0:
                    attributes_list.append(attr_key)

            display_players(search_results, attributes_list, (0, num_results))

        # Start button corresponds to formations
        elif settings['edit_subject'] == 'formations':

            # Get the attributes to search with based on what mode is in use
            if simple_btn.enabled == 0:
                if len(name_tf.value) > 0:
                    search_dict = {'name': (name_tf.value, 'exact')}
                else:
                    search_dict = {}
            else:
                search_dict = attr_dict

            # Get formations from database to add and search
            if settings['edit_type'] == 'add':

                db_formations = db_dict['formation_db'][1]

                if len(search_dict) == 0:
                    search_results = db_formations
                else:
                    search_results = db_formations.search(search_dict)
                    search_results = FormationDB.FormationDB(search_results)

            # Get formations from list to edit or delete and search
            else:
                if len(search_dict) == 0:
                    search_results = list_formations
                else:
                    search_results = list_formations.search(search_dict)
                    search_results = FormationDB.FormationDB(search_results)

            # Sort formations - if no attribute selected, use name
            if len(attr_list) == 0:
                search_results.sort(['name'], sort_order_radio_group.value)
            else:
                search_results.sort(attr_list, sort_order_radio_group.value)

            # Get attributes list and avoid duplicates
            attributes_list = []

            for attr in attr_list:
                if attributes_list.count(attr) == 0:
                    attributes_list.append(attr)

            for attr_key in attr_dict.iterkeys():
                if attributes_list.count(attr_key) == 0:
                    attributes_list.append(attr_key)

            display_formations(search_results, attributes_list, (0, num_results))

        # Start button corresponds to teams
        elif settings['edit_subject'] == 'teams':
            stuff = 0

        win_edit.become_target()

    def back_btn_func():
        # Clean up
        reset_btn_func()

        win_edit.hide()
        PickFile.open_pick_file_window(win_edit.x, win_edit.y, db_dict, settings)

    # ========== Search Type Button Functions ==========
    def simple_btn_func():
        simple_btn.enabled = 0
        advanced_btn.enabled = 1
        settings['edit_mode'] = 'simple'

        for display_item in advanced_display:
            view.remove(display_item)

        clean_results()

        for display_item in simple_display:
            view.add(display_item)

        name_tf.become_target()

    def advanced_btn_func():
        advanced_btn.enabled = 0
        simple_btn.enabled = 1
        settings['edit_mode'] = 'advanced'

        for display_item in simple_display:
            view.remove(display_item)

        clean_results()
        display_attributes()

        for display_item in advanced_display:
            view.add(display_item)

        win_edit.become_target()

    # ========== Tool Button Functions ==========
    def attribute_btn_func():
        # Delete results
        del settings['messages']['results'][:]

        attr_type = ''
        if settings['edit_subject'] == 'players':
            attr_type = 'player_search'
        elif settings['edit_subject'] == 'formations':
            attr_type = 'formation_search'
        elif settings['team_subject'] == 'teams':
            attr_type = 'player_search'
        else:
            print "Invalid edit_subject settings."

        # Open new window and close current window
        win_edit.hide()
        AddAttribute.open_attribute_window(win_edit.x, win_edit.y,
                                           db_dict, attr_dict, attr_list, attr_type, settings)

    def sort_btn_func():
        # Delete results
        del settings['messages']['results'][:]

        attr_type = ''
        if settings['edit_subject'] == 'players':
            attr_type = 'player_sort'
        elif settings['edit_subject'] == 'formations':
            attr_type = 'formation_sort'
        elif settings['team_subject'] == 'teams':
            attr_type = 'player_sort'
        else:
            print "Invalid edit_subject settings."

        # Open new window and close current window
        win_edit.hide()
        AddAttribute.open_attribute_window(win_edit.x, win_edit.y, db_dict,
                                           attr_dict, attr_list, attr_type, settings)

    def display_attributes():
        for search_item in settings['messages']['search']:
            view.add(search_item)
        for sort_item in settings['messages']['sort']:
            view.add(sort_item)

    def clean_results():
        # Remove messages off page
        for message in settings['messages']['search']:
            view.remove(message)
        for message in settings['messages']['sort']:
            view.remove(message)
        for message in settings['messages']['results']:
            view.remove(message)

        del settings['messages']['results'][:]

        win_edit.become_target()

    def reset_btn_func():
        # Remove messages off page
        for message in settings['messages']['search']:
            view.remove(message)
        for message in settings['messages']['sort']:
            view.remove(message)
        for message in settings['messages']['results']:
            view.remove(message)

        # Delete the attribute parameters for search and sort
        attr_dict.clear()
        del attr_list[:]
        del settings['messages']['results'][:]

        win_edit.become_target()

    def player_bio_btn_func(player):
        win_edit.become_target()
        PlayerBio.open_player_bio_window(win_edit.x, win_edit.y, player, win_edit,
                                         file_name=settings['file_name'], current_list=list_players)
        win_edit.hide()

    def formation_bio_btn_func(formation):
        win_edit.become_target()
        FormationBio.open_formation_bio_window(
                win_edit.x, win_edit.y, formation, win_edit, settings['file_name'], list_formations)
        win_edit.hide()

    def add_btn_func(list_item, btn):
        if settings['edit_subject'] == 'players':
            # Check if player is already on selected players list
            # Remove player from list
            player_data = list_players.search({'id': (list_item['id'], 'exact')})
            if len(player_data) > 0:
                # Remove
                list_players.db.remove(player_data[0])
                # Save
                list_players.sort(['rating'])
                list_players.save(settings['file_name'], 'list', True)

                # Switch button title
                btn.title = "+"

            # Add player to the list
            else:
                # Add
                list_players.db.append(list_item)
                # Save
                list_players.sort(['rating'])
                list_players.save(settings['file_name'], 'list', True)

                # Switch button title
                btn.title = "-"

        elif settings['edit_subject'] == 'formations':
            # Check if formation is already on selected formations list
            # Remove formation from list
            if list_item in list_formations.db:
                # Remove
                list_formations.db.remove(list_item)
                # Save
                list_formations.sort(['name'])
                list_formations.save(settings['file_name'], 'list', True)

                # Switch button title
                btn.title = "+"

            # Add formation to the list
            else:
                # Add
                list_formations.db.append(list_item)
                # Save
                list_formations.sort(['name'])
                list_formations.save(settings['file_name'], 'list', True)

                # Switch button title
                btn.title = "-"

        win_edit.become_target()

    def pos_btn_func(player, btn):
        # Open window to get position
        win_edit.hide()
        PickPosition.open_pick_position_window(win_edit.x, win_edit.y, player, list_players, settings, btn, win_edit)
        win_edit.become_target()

    # ========== Action Buttons ==========
    start_btn.x = (win_width - 2*small_button_width - small_button_spacing) / 2
    start_btn.y = title.bottom + small_button_top_spacing
    start_btn.height = small_button_height
    start_btn.width = small_button_width
    start_btn.font = small_button_font
    start_btn.action = start_btn_func
    start_btn.style = 'default'
    start_btn.color = small_button_color
    start_btn.just = 'right'
    general_display.append(start_btn)

    back_btn.x = start_btn.right + small_button_spacing
    back_btn.y = start_btn.top
    back_btn.height = small_button_height
    back_btn.width = small_button_width
    back_btn.font = small_button_font
    back_btn.action = back_btn_func
    back_btn.style = 'default'
    back_btn.color = small_button_color
    back_btn.just = 'right'
    general_display.append(back_btn)

    # ========== Edit Type Radio Buttons ==========
    def get_edit_type_rg():
        settings['edit_type'] = edit_type_radio_group.value
        win_edit.become_target()

    edit_type_radio_group = RadioGroup(action=get_edit_type_rg)

    radio_btn_width = 125
    radio_btn_space = 5

    # Edit Type
    type_add_radio_btn = RadioButton()
    if settings['edit_subject'] == 'players':
        type_add_radio_btn.title = 'Add Players'
    elif settings['edit_subject'] == 'formations':
        type_add_radio_btn.title = 'Add Formations'
    elif settings['edit_subject'] == 'teams':
        type_add_radio_btn.title = 'Add Teams'
    type_add_radio_btn.width = radio_btn_width
    type_add_radio_btn.x = (win_edit.width - 2*radio_btn_width - radio_btn_space) / 2
    type_add_radio_btn.y = start_btn.bottom + small_button_top_spacing
    type_add_radio_btn.group = edit_type_radio_group
    type_add_radio_btn.value = 'add'
    general_display.append(type_add_radio_btn)

    type_edit_radio_btn = RadioButton()
    if settings['edit_subject'] == 'players':
        type_edit_radio_btn.title = 'Edit/Delete Players'
    elif settings['edit_subject'] == 'formations':
        type_edit_radio_btn.title = 'Edit/Delete Forms'
    elif settings['edit_subject'] == 'teams':
        type_edit_radio_btn.title = 'Edit/Delete Teams'
    type_edit_radio_btn.width = radio_btn_width
    type_edit_radio_btn.x = type_add_radio_btn.right + radio_btn_space
    type_edit_radio_btn.y = type_add_radio_btn.top
    type_edit_radio_btn.group = edit_type_radio_group
    type_edit_radio_btn.value = 'edit'
    general_display.append(type_edit_radio_btn)

    edit_type_radio_group.value = settings['edit_type']

    # ========== Mode Buttons ==========
    simple_btn.x = (win_width - 2*small_button_width - small_button_spacing) / 2
    simple_btn.y = type_add_radio_btn.bottom + small_button_top_spacing
    simple_btn.height = small_button_height
    simple_btn.width = small_button_width
    simple_btn.font = small_button_font
    simple_btn.action = simple_btn_func
    simple_btn.style = 'default'
    simple_btn.color = small_button_color
    simple_btn.just = 'right'
    if settings['edit_mode'] == 'simple':
        simple_btn.enabled = 0
    general_display.append(simple_btn)

    advanced_btn.x = simple_btn.right + small_button_spacing
    advanced_btn.y = simple_btn.top
    advanced_btn.height = small_button_height
    advanced_btn.width = small_button_width
    advanced_btn.font = small_button_font
    advanced_btn.action = advanced_btn_func
    advanced_btn.style = 'default'
    advanced_btn.color = small_button_color
    advanced_btn.just = 'right'
    if settings['edit_mode'] == 'advanced':
        advanced_btn.enabled = 0
    general_display.append(advanced_btn)

    # ========== Sort Order Radio Buttons ==========
    def get_attribute_sort_order_rg():
        settings['sort_order'] = sort_order_radio_group.value
        win_edit.become_target()

    sort_order_radio_group = RadioGroup(action=get_attribute_sort_order_rg)

    asc_desc_radio_btn_width = 75
    asc_msg_width = 80
    radio_btn_space = 5

    asc_desc_rg_msg = Label(text="Sort Order:", font=std_tf_font, width=asc_msg_width, height=std_tf_height,
                            color=title_color)
    asc_desc_rg_msg.x = (win_edit.width - 2*asc_desc_radio_btn_width - radio_btn_space - asc_msg_width) / 2
    asc_desc_rg_msg.y = simple_btn.bottom + radio_btn_space
    general_display.append(asc_desc_rg_msg)

    descend_radio_btn = RadioButton("Descending")
    descend_radio_btn.width = asc_desc_radio_btn_width
    descend_radio_btn.x = asc_desc_rg_msg.right
    descend_radio_btn.y = asc_desc_rg_msg.top
    descend_radio_btn.group = sort_order_radio_group
    descend_radio_btn.value = True
    general_display.append(descend_radio_btn)

    ascend_radio_btn = RadioButton("Ascending")
    ascend_radio_btn.width = asc_desc_radio_btn_width
    ascend_radio_btn.x = descend_radio_btn.right + radio_btn_space
    ascend_radio_btn.y = descend_radio_btn.top
    ascend_radio_btn.group = sort_order_radio_group
    ascend_radio_btn.value = False
    general_display.append(ascend_radio_btn)

    sort_order_radio_group.value = settings['sort_order']

    # ========== Tool Buttons ==========
    attribute_btn.x = (win_width - 3*small_button_width - 2*small_button_spacing) / 2
    attribute_btn.y = asc_desc_rg_msg.bottom + 5
    attribute_btn.height = small_button_height
    attribute_btn.width = small_button_width
    attribute_btn.font = small_button_font
    attribute_btn.action = attribute_btn_func
    attribute_btn.style = 'default'
    attribute_btn.color = small_button_color
    attribute_btn.just = 'right'
    advanced_display.append(attribute_btn)

    sort_btn.x = attribute_btn.right + small_button_spacing
    sort_btn.y = attribute_btn.top
    sort_btn.height = small_button_height
    sort_btn.width = small_button_width
    sort_btn.font = small_button_font
    sort_btn.action = sort_btn_func
    sort_btn.style = 'default'
    sort_btn.color = small_button_color
    sort_btn.just = 'right'
    advanced_display.append(sort_btn)

    reset_btn.x = sort_btn.right + small_button_spacing
    reset_btn.y = attribute_btn.top
    reset_btn.height = small_button_height
    reset_btn.width = small_button_width
    reset_btn.font = small_button_font
    reset_btn.action = reset_btn_func
    reset_btn.style = 'default'
    reset_btn.color = small_button_color
    reset_btn.just = 'right'
    advanced_display.append(reset_btn)

    # ========== Simple Fields ==========
    label_width = 50
    rating_tf_width = 30
    field_spacing = 20

    rating_label.font = std_tf_font
    rating_label.width = label_width
    rating_label.height = std_tf_height
    rating_label.x = (win_edit.width - 2*label_width - std_tf_width - rating_tf_width - field_spacing) / 2
    rating_label.y = asc_desc_rg_msg.bottom + 5
    rating_label.color = title_color
    if settings['edit_subject'] != 'formations':
        simple_display.append(rating_label)

    rating_tf.font = std_tf_font
    rating_tf.width = rating_tf_width
    rating_tf.height = 25
    rating_tf.x = rating_label.right
    rating_tf.y = rating_label.top
    if settings['edit_subject'] != 'formations':
        simple_display.append(rating_tf)

    name_label.font = std_tf_font
    name_label.width = label_width
    name_label.height = std_tf_height
    if settings['edit_subject'] != 'formations':
        name_label.x = rating_tf.right + field_spacing
    else:
        name_label.x = (win_edit.width - label_width - std_tf_width) / 2
    name_label.y = rating_label.top
    name_label.color = title_color
    simple_display.append(name_label)

    name_tf.font = std_tf_font
    name_tf.width = std_tf_width
    name_tf.height = 25
    name_tf.x = name_label.right
    name_tf.y = rating_label.top
    simple_display.append(name_tf)

    # ========== Messages ==========
    lowest_msg_l = start_btn.top
    lowest_msg_r = start_btn.top

    attr_msg_offset = 25

    # Attribute Messages
    del settings['messages']['search'][:]
    del settings['messages']['sort'][:]

    if len(attr_dict) > 0:
        settings['messages']['search'].append(Label(text="Search Attributes:", font=title_tf_font, width=std_tf_width,
                                                    height=std_tf_height, x=attr_msg_offset, y=lowest_msg_l,
                                                    color=title_color))
        lowest_msg_l += std_tf_height

        for key, value in attr_dict.iteritems():
            msg_text = format_attr_name(key) + ": "
            if key in ['id', 'baseId', 'nationId', 'leagueId', 'clubId']:
                msg_text += str(value[0])
            elif type(value[0]) is int:
                msg_text += value[1].capitalize() + ' ' + str(value[0])
            elif value[1] == 'not':
                msg_text += value[1].capitalize() + ' "' + str(value[0]) + '"'
            else:
                msg_text += '"' + str(value[0]) + '"'

            attr_label = Label(text=msg_text, font=std_tf_font, width=std_tf_width,
                               height=std_tf_height, x=attr_msg_offset, y=lowest_msg_l, color=title_color)
            lowest_msg_l += std_tf_height
            settings['messages']['search'].append(attr_label)

    if len(attr_list) > 0:
        settings['messages']['sort'].append(Label(text="Sort Attributes:", font=title_tf_font, width=std_tf_width,
                                                  height=std_tf_height, x=advanced_btn.right + 3*attr_msg_offset,
                                                  y=lowest_msg_r, color=title_color))
        lowest_msg_r += std_tf_height

        for value in attr_list:
            attr_label = Label(text=(format_attr_name(value)), font=std_tf_font, width=std_tf_width,
                               height=std_tf_height, x=advanced_btn.right + 3*attr_msg_offset, y=lowest_msg_r,
                               color=title_color)
            lowest_msg_r += std_tf_height
            settings['messages']['sort'].append(attr_label)

    # ========== Previous, Add to List, Next Buttons ==========
    previous_btn = Button("<<< Previous %d" % num_results)
    add_to_list_btn = Button()
    next_btn = Button("Next %d >>>" % num_results)
    total_num_results_label = Label()
    pages_label = Label()

    def add_to_list_btn_func(input_list, func_type):
        item_list = copy.deepcopy(input_list)

        if settings['edit_subject'] == 'players':
            if func_type == 'add all':
                added_players = []
                # Add current results to player list
                for player in item_list:
                    if list_players.db.count(player) == 0:
                        list_players.db.append(player)
                        added_players.append(player)

                # Sort
                list_players.sort(['rating'])
                # Save
                list_players.save(settings['file_name'], 'list', True)

                # Change button title and action
                add_to_list_btn.title = "Remove Added Players"
                add_to_list_btn.action = (add_to_list_btn_func, item_list, 'remove select')

                # Keep track of just added players
                settings['messages']['players_changed'] = added_players

            elif func_type == 'remove all':
                removed_players = []
                # Remove current results from player list
                for player in item_list:
                    if list_players.db.count(player) > 0:
                        list_players.db.remove(player)
                        removed_players.append(player)

                # Sort
                list_players.sort(['rating'])
                # Save
                list_players.save(settings['file_name'], 'list', True)

                # Change button title and action
                add_to_list_btn.title = "Add Removed Players"
                add_to_list_btn.action = (add_to_list_btn_func, item_list, 'add select')

                # Keep track of just removed players
                settings['messages']['players_changed'] = removed_players

            elif func_type == 'add select':
                # Add select players back to player list
                for player in settings['messages']['players_changed']:
                    if list_players.db.count(player) == 0:
                        list_players.db.append(player)

                # Sort
                list_players.sort(['rating'])
                # Save
                list_players.save(settings['file_name'], 'list', True)

                # Change button title and action
                add_to_list_btn.title = "Remove Added Players"
                add_to_list_btn.action = (add_to_list_btn_func, item_list, 'remove select')

            elif func_type == 'remove select':
                # Remove select players from player list
                for player in settings['messages']['players_changed']:
                    if list_players.db.count(player) > 0:
                        list_players.db.remove(player)

                # Sort
                list_players.sort(['rating'])
                # Save
                list_players.save(settings['file_name'], 'list', True)

                # Change button title and action
                add_to_list_btn.title = "Add Removed Players"
                add_to_list_btn.action = (add_to_list_btn_func, item_list, 'add select')

        elif settings['edit_subject'] == 'formations':
            if func_type == 'add all':
                added_formations = []
                # Add current results to formation list
                for formation in item_list:
                    if list_formations.db.count(formation) == 0:
                        list_formations.db.append(formation)
                        added_formations.append(formation)

                # Sort
                list_formations.sort(['name'])
                # Save
                list_formations.save(settings['file_name'], 'list', True)

                # Change button title and action
                add_to_list_btn.title = "Remove Added Forms"
                add_to_list_btn.action = (add_to_list_btn_func, item_list, 'remove select')

                # Keep track of just added formations
                settings['messages']['formations_changed'] = added_formations

            elif func_type == 'remove all':
                removed_formations = []
                # Remove current results from formation list
                for formation in item_list:
                    if formation in list_formations.db:
                        list_formations.db.remove(formation)
                        removed_formations.append(formation)

                # Sort
                list_formations.sort(['name'])
                # Save
                list_formations.save(settings['file_name'], 'list', True)

                # Change button title and action
                add_to_list_btn.title = "Add Removed Forms"
                add_to_list_btn.action = (add_to_list_btn_func, item_list, 'add select')

                # Keep track of just removed formations
                settings['messages']['formations_changed'] = removed_formations

            elif func_type == 'add select':
                # Add select formations back to formation list
                for formation in settings['messages']['formations_changed']:
                    if list_formations.db.count(formation) == 0:
                        list_formations.db.append(formation)

                # Sort
                list_formations.sort(['name'])
                # Save
                list_formations.save(settings['file_name'], 'list', True)

                # Change button title and action
                add_to_list_btn.title = "Remove Added Forms"
                add_to_list_btn.action = (add_to_list_btn_func, item_list, 'remove select')

            elif func_type == 'remove select':
                # Remove select formations from formation list
                for formation in settings['messages']['formations_changed']:
                    if list_formations.db.count(formation) > 0:
                        list_formations.db.remove(formation)

                # Sort
                list_formations.sort(['name'])
                # Save
                list_formations.save(settings['file_name'], 'list', True)

                # Change button title and action
                add_to_list_btn.title = "Add Removed Forms"
                add_to_list_btn.action = (add_to_list_btn_func, item_list, 'add select')

        del item_list
        win_edit.become_target()

    def previous_btn_func(display_db=None, attributes=None, index_range=None):
        if display_db is not None:
            # display previous results
            if settings['edit_subject'] == 'players':
                display_players(display_db, attributes, index_range)
            elif settings['edit_subject'] == 'formations':
                display_formations(display_db, attributes, index_range)
            #elif settings['edit_subject'] == 'teams':
                #display_teams(display_db, attributes, index_range)
        win_edit.become_target()

    def next_btn_func(display_db=None, attributes=None, index_range=None):
        if display_db is not None:
            # display next results
            if settings['edit_subject'] == 'players':
                display_players(display_db, attributes, index_range)
            elif settings['edit_subject'] == 'formations':
                display_formations(display_db, attributes, index_range)
            # elif settings['edit_subject'] == 'teams':
                # display_teams(display_db, attributes, index_range)
        win_edit.become_target()

    add_to_list_btn.x = attribute_btn.right + small_button_spacing
    add_to_list_btn.y = attribute_btn.bottom + 5
    add_to_list_btn.height = tiny_button_height
    add_to_list_btn.width = small_button_width
    add_to_list_btn.font = small_button_font
    add_to_list_btn.style = 'default'
    add_to_list_btn.color = small_button_color
    add_to_list_btn.just = 'right'

    previous_btn.height = tiny_button_height
    previous_btn.width = small_button_width
    previous_btn.x = add_to_list_btn.left - previous_btn.width - small_button_spacing
    previous_btn.y = add_to_list_btn.top
    previous_btn.font = small_button_font
    previous_btn.action = previous_btn_func
    previous_btn.style = 'default'
    previous_btn.color = small_button_color
    previous_btn.just = 'right'

    next_btn.height = tiny_button_height
    next_btn.width = small_button_width
    next_btn.x = add_to_list_btn.right + small_button_spacing
    next_btn.y = add_to_list_btn.top
    next_btn.font = small_button_font
    next_btn.action = next_btn_func
    next_btn.style = 'default'
    next_btn.color = small_button_color
    next_btn.just = 'right'

    total_num_results_label.font = std_tf_font
    total_num_results_label.width = 100
    total_num_results_label.height = std_tf_height
    total_num_results_label.x = previous_btn.left + - 100 - 10
    total_num_results_label.y = add_to_list_btn.top
    total_num_results_label.color = title_color
    total_num_results_label.just = 'right'

    pages_label.font = std_tf_font
    pages_label.width = 125
    pages_label.height = std_tf_height
    pages_label.x = next_btn.right + 10
    pages_label.y = add_to_list_btn.top
    pages_label.color = title_color
    pages_label.just = 'left'

    # ========== Display players from search ==========
    def display_players(display_db, attributes, index_range):
        # Remove old messages off page
        for message in settings['messages']['results']:
            view.remove(message)
        del settings['messages']['results'][:]

        # Add navigation buttons to page
        if settings['edit_type'] == 'add':
            add_to_list_btn.title = 'Add All Players'
            add_to_list_btn.action = (add_to_list_btn_func, display_db.db, 'add all')
        elif settings['edit_type'] == 'edit':
            add_to_list_btn.title = 'Remove All Players'
            add_to_list_btn.action = (add_to_list_btn_func, display_db.db, 'remove all')
        else:
            print "Invalid edit type."

        previous_range = (index_range[0]-num_results, index_range[0])
        previous_btn.action = (previous_btn_func, display_db, attributes, previous_range)

        next_range = (index_range[1], index_range[1]+num_results)
        next_btn.action = (next_btn_func, display_db, attributes, next_range)

        total_num_results_label.text = str(len(display_db.db)) + " Players"
        pages_label.text = "Page %d of %d" % (int(index_range[1]/num_results),
                                              math.ceil(len(display_db.db) / float(num_results)))

        if index_range[0] > 0:
            previous_btn.enabled = 1
        else:
            previous_btn.enabled = 0
        if index_range[1] <= len(display_db.db) - 1:
            next_btn.enabled = 1
        else:
            next_btn.enabled = 0

        settings['messages']['results'].append(add_to_list_btn)
        settings['messages']['results'].append(previous_btn)
        settings['messages']['results'].append(next_btn)
        settings['messages']['results'].append(total_num_results_label)
        settings['messages']['results'].append(pages_label)

        # Print out labels
        labels = player_info_labels(attributes)
        stat_index = 1
        spacing_list = [25, 125, 40, 40, 65, 115, 115, 115, 40]
        left_border = (win_width - sum(spacing_list[:-1]) - (len(labels) - len(spacing_list) + 2) * spacing_list[-1])/2
        msg_x = left_border + spacing_list[0]
        msg_y = add_to_list_btn.bottom + 5

        for info_label in labels:
            player_label = Label(text=info_label, font=std_tf_font_bold, width=spacing_list[stat_index]-5,
                                 height=std_tf_height, x=msg_x, y=msg_y, color=title_color)
            settings['messages']['results'].append(player_label)
            msg_x += spacing_list[stat_index]

            if stat_index < len(spacing_list)-1:
                stat_index += 1

        msg_y += std_tf_height + 5

        # Print out players
        for idx, player in enumerate(display_db.db[index_range[0]:index_range[1]]):
            msg_x = left_border
            player_stats = player_info(player, attributes)
            stat_index = 0

            player_data = list_players.search({'id': (player['id'], 'exact')})
            if len(player_data) > 0:
                add_btn_text = '-'
                temp_player = player_data[0]
            else:
                add_btn_text = '+'
                temp_player = player
            add_btn = Button(title=add_btn_text, width=spacing_list[stat_index]-5, height=15, x=msg_x, y=msg_y)
            add_btn.action = (add_btn_func, temp_player, add_btn)
            settings['messages']['results'].append(add_btn)
            msg_x += spacing_list[stat_index]
            stat_index += 1

            # Check for names that are too long
            name = player_stats[0]
            if len(name) > 20:
                name = player['lastName']

            bio_btn = Button(title=name, width=spacing_list[stat_index]-5, height=15, x=msg_x, y=msg_y,
                             action=(player_bio_btn_func, temp_player))
            settings['messages']['results'].append(bio_btn)
            msg_x += spacing_list[stat_index]
            stat_index += 1

            for player_stat in player_stats[1:]:
                player_label = Label(text=player_stat, font=small_button_font, width=spacing_list[stat_index]-5,
                                     height=std_tf_height, x=msg_x, y=msg_y, color=title_color)
                settings['messages']['results'].append(player_label)

                # Save values for position edit button
                if stat_index == 3:
                    edit_x = msg_x
                    edit_y = msg_y

                msg_x += spacing_list[stat_index]
                if stat_index < len(spacing_list) - 1:
                    stat_index += 1

            if settings['edit_type'] == 'edit':
                pos_btn = Button(title=player_stats[2], width=28, height=15, x=edit_x, y=edit_y)
                pos_btn.action = (pos_btn_func, player, pos_btn)
                settings['messages']['results'].append(pos_btn)

            msg_y += std_tf_height

        for results_msg in settings['messages']['results']:
            view.add(results_msg)

    # ========== Display formations from search ==========
    def display_formations(display_db, attributes, index_range):
        # Remove old messages off page
        for message in settings['messages']['results']:
            view.remove(message)
        del settings['messages']['results'][:]

        # Add navigation buttons to page
        if settings['edit_type'] == 'add':
            add_to_list_btn.title = 'Add All Formations'
            add_to_list_btn.action = (add_to_list_btn_func, display_db.db, 'add all')
        elif settings['edit_type'] == 'edit':
            add_to_list_btn.title = 'Remove All Formations'
            add_to_list_btn.action = (add_to_list_btn_func, display_db.db, 'remove all')
        else:
            print "Invalid edit type."

        previous_range = (index_range[0]-num_results, index_range[0])
        previous_btn.action = (previous_btn_func, display_db, attributes, previous_range)

        next_range = (index_range[1], index_range[1]+num_results)
        next_btn.action = (next_btn_func, display_db, attributes, next_range)

        total_num_results_label.text = str(len(display_db.db)) + " Formations"
        pages_label.text = "Page %d of %d" % (int(index_range[1]/num_results),
                                              math.ceil(len(display_db.db)/float(num_results)))

        if index_range[0] > 0:
            previous_btn.enabled = 1
        else:
            previous_btn.enabled = 0
        if index_range[1] <= len(display_db.db) - 1:
            next_btn.enabled = 1
        else:
            next_btn.enabled = 0

        settings['messages']['results'].append(add_to_list_btn)
        settings['messages']['results'].append(previous_btn)
        settings['messages']['results'].append(next_btn)
        settings['messages']['results'].append(total_num_results_label)
        settings['messages']['results'].append(pages_label)

        # Print out labels
        labels = formation_info_labels()
        stat_index = 1
        spacing_list = [25, 100, 100, 55, 55, 55, 55, 140, 160]
        left_border = (win_edit.width - sum(spacing_list))/2
        msg_x = left_border + spacing_list[0]
        msg_y = add_to_list_btn.bottom + 5

        for info_label in labels:
            formation_label = Label(text=info_label, font=std_tf_font_bold, width=spacing_list[stat_index]-5,
                                    height=std_tf_height, x=msg_x, y=msg_y, color=title_color)
            settings['messages']['results'].append(formation_label)
            msg_x += spacing_list[stat_index]

            if stat_index < len(spacing_list)-1:
                stat_index += 1

        msg_y += std_tf_height + 5

        # Print out formations
        for idx, formation in enumerate(display_db.db[index_range[0]:index_range[1]]):
            msg_x = left_border
            formation_stats = formation_info(formation)
            stat_index = 0

            if formation in list_formations.db:
                add_btn_text = '-'
            else:
                add_btn_text = '+'

            add_btn = Button(title=add_btn_text, width=spacing_list[stat_index]-5, height=15, x=msg_x, y=msg_y)
            add_btn.action = (add_btn_func, formation, add_btn)
            settings['messages']['results'].append(add_btn)
            msg_x += spacing_list[stat_index]
            stat_index += 1

            bio_btn = Button(title=formation['name'], width=spacing_list[stat_index]-5, height=15, x=msg_x, y=msg_y,
                             action=(formation_bio_btn_func, formation))
            settings['messages']['results'].append(bio_btn)
            msg_x += spacing_list[stat_index]
            stat_index += 1

            for formation_stat in formation_stats[1:]:
                formation_label = Label(text=formation_stat, font=small_button_font, width=spacing_list[stat_index]-5,
                                        height=std_tf_height, x=msg_x, y=msg_y, color=title_color)
                settings['messages']['results'].append(formation_label)

                msg_x += spacing_list[stat_index]
                if stat_index < len(spacing_list) - 1:
                    stat_index += 1

            msg_y += std_tf_height

        for results_msg in settings['messages']['results']:
            view.add(results_msg)

    # ========== Add components to view and add view to window ==========
    for item in general_display:
        view.add(item)

    if settings['edit_mode'] == 'simple':
        for item in simple_display:
            view.add(item)
    elif settings['edit_mode'] == 'advanced':
        for item in advanced_display:
            view.add(item)
        display_attributes()

    for msg in settings['messages']['results']:
        view.add(msg)

    win_edit.add(view)
    view.become_target()
    win_edit.show()
Пример #17
0
def open_create_ultimate_teams_window(window_x, window_y, db_dict, win_previous, player_judge_list=None,
                                      team_judge_list=None, file_name=None, roster=None, input_formation=None):

    display_items = []

    # Get create ultimate team configuration values
    with open(config_filename, 'r') as f:
        settings = json.load(f)['ultimate_team_configs']
        f.close()

    # Set the attributes lists
    if player_judge_list is not None:
        settings['player_sort_attributes'] = player_judge_list

    if team_judge_list is not None:
        settings['team_sort_attributes'] = team_judge_list

    if roster is None:
        roster = {}
    settings['roster'] = roster

    # Assign input formation, or lack thereof, to settings
    settings['input_formation'] = input_formation

    # ========== Window ==========
    win_ultimate_teams = Window()
    win_ultimate_teams.title = create_ultimate_teams_win_title
    win_ultimate_teams.auto_position = False
    win_ultimate_teams.position = (window_x, window_y)
    win_ultimate_teams.size = (win_width, win_height)
    win_ultimate_teams.resizable = 0
    win_ultimate_teams.name = create_ultimate_teams_title + " Window"

    # ========== Window Image View ==========
    class CreateUltimateTeamsWindowImageView(View):
        def draw(self, c, r):
            c.backcolor = view_backcolor
            c.erase_rect(r)

    view = CreateUltimateTeamsWindowImageView(size=win_ultimate_teams.size)

    # ========== Title ==========
    title = Label(text=create_ultimate_teams_title)
    title.font = title_font
    title.width = title_width
    title.height = title_height
    title.x = (win_width - title_width) / 2
    title.y = top_border
    title.color = title_color
    title.just = 'center'
    display_items.append(title)

    # ========== Settings ==========
    # ========== Current player list and formation list ==========
    file_name_width = 125
    file_button_width = 200

    # Functions for picking files
    def player_list_current_btn_func():
        save_settings()
        settings['file_type'] = 'current_player_list'
        settings['file_changes'] = False
        settings['prev_window'] = 'team_creation'
        settings['prev_window_value'] = win_previous
        settings['create_team_name'] = team_list_name_tf.value
        PickFile.open_pick_file_window(win_ultimate_teams.x, win_ultimate_teams.y, db_dict, settings)
        win_ultimate_teams.hide()

    def player_db_current_btn_func():
        save_settings()
        settings['file_type'] = 'current_player_db'
        settings['file_changes'] = False
        settings['prev_window'] = 'team_creation'
        settings['prev_window_value'] = win_previous
        settings['create_team_name'] = team_list_name_tf.value
        PickFile.open_pick_file_window(win_ultimate_teams.x, win_ultimate_teams.y, db_dict, settings)
        win_ultimate_teams.hide()

    def formation_list_current_btn_func():
        save_settings()
        settings['file_type'] = 'current_formation_list'
        settings['file_changes'] = False
        settings['prev_window'] = 'team_creation'
        settings['prev_window_value'] = win_previous
        settings['create_team_name'] = team_list_name_tf.value
        PickFile.open_pick_file_window(win_ultimate_teams.x, win_ultimate_teams.y, db_dict, settings)
        win_ultimate_teams.hide()

    player_list_label = Label(text="Player List:", font=std_tf_font_bold,
                              width=file_name_width, height=std_tf_height,
                              x=(win_width-file_name_width-file_button_width-5)/2, y=title.bottom + title_border*3,
                              color=title_color, just='right')
    display_items.append(player_list_label)

    player_list_button = Button(title=db_dict['player_list'][0], font=small_tf_font,
                                width=file_button_width, height=std_tf_height,
                                x=player_list_label.right + 5, y=player_list_label.top,
                                color=title_color, just='center',
                                action=player_list_current_btn_func)
    display_items.append(player_list_button)

    player_db_label = Label(text="Player DB:", font=std_tf_font_bold,
                            width=file_name_width, height=std_tf_height,
                            x=player_list_label.left, y=player_list_label.bottom + title_border,
                            color=title_color, just='right')
    display_items.append(player_db_label)

    player_db_button = Button(title=db_dict['player_db'][0], font=small_tf_font,
                              width=file_button_width, height=std_tf_height,
                              x=player_list_label.right + 5, y=player_db_label.top,
                              color=title_color, just='center',
                              action=player_db_current_btn_func)
    display_items.append(player_db_button)

    formation_list_label = Label(text="Formation List:", font=std_tf_font_bold,
                                 width=file_name_width, height=std_tf_height,
                                 x=player_list_label.left, y=player_db_label.bottom + title_border,
                                 color=title_color, just='right')
    display_items.append(formation_list_label)

    formation_list_button = Button(title=db_dict['formation_list'][0], font=small_tf_font,
                                   width=file_button_width, height=std_tf_height,
                                   x=formation_list_label.right + 5, y=formation_list_label.top,
                                   color=title_color, just='center',
                                   action=formation_list_current_btn_func)
    display_items.append(formation_list_button)
    if input_formation is not None and input_formation['name'] != 'Generic':
        formation_list_button.enabled = 0
        formation_list_button.title = input_formation['name']

    settings_indent = 3*win_width/7

    # ========== Team Name ==========
    tf_width = 235
    team_name_label_width = 130
    disabled_msg = "Disabled"

    team_list_name_label = Label(text="Team List Name: ", font=std_tf_font_bold,
                                 width=team_name_label_width, height=std_tf_height,
                                 x=settings_indent - team_name_label_width,
                                 y=formation_list_label.bottom + title_border*2,
                                 color=title_color, just='right')
    display_items.append(team_list_name_label)

    team_list_name_tf = TextField(font=std_tf_font, width=tf_width, height=std_tf_height + 5,
                                  x=team_list_name_label.right + small_button_spacing, y=team_list_name_label.top)
    display_items.append(team_list_name_tf)

    if file_name is not None:
        team_list_name_tf.value = file_name

    radio_btn_width = 75
    radio_btn_space = 5

    # ========== Process Type Label ==========
    process_type_label = Label(text="Processing Type: ", font=std_tf_font_bold,
                               width=std_tf_width, height=std_tf_height,
                               x=settings_indent - std_tf_width,
                               y=team_list_name_label.bottom + title_border,
                               color=title_color, just='right')
    display_items.append(process_type_label)

    def get_process_type_rg():
        settings['process_type'] = process_type_radio_group.value
        win_ultimate_teams.become_target()

    process_type_radio_group = RadioGroup(action=get_process_type_rg)

    # Process Type Radio Buttons
    multi_process_radio_btn = RadioButton('Multi', width=radio_btn_width,
                                          x=process_type_label.right + radio_btn_space,
                                          y=process_type_label.top, group=process_type_radio_group, value='multi')
    display_items.append(multi_process_radio_btn)

    single_process_radio_btn = RadioButton('Single', width=radio_btn_width,
                                           x=multi_process_radio_btn.right + radio_btn_space,
                                           y=process_type_label.top, group=process_type_radio_group, value='single')
    display_items.append(single_process_radio_btn)

    process_type_radio_group.value = settings['process_type']

    # If building a team based on one formation, there is no benefit to using multiple processes.
    if input_formation is not None:
        if input_formation['name'] != 'Generic':
            process_type_radio_group.value = 'single'
            settings['process_type'] = 'single'
            multi_process_radio_btn.enabled = 0
            single_process_radio_btn.enabled = 0

    # ========== Chemistry Matters Label ==========
    chemistry_matters_label = Label(text="Chemistry Matters: ", font=std_tf_font_bold,
                                    width=std_tf_width, height=std_tf_height,
                                    x=settings_indent - std_tf_width,
                                    y=process_type_label.bottom + title_border,
                                    color=title_color, just='right')
    display_items.append(chemistry_matters_label)

    def get_chemistry_matters_rg():
        settings['chemistry_matters'] = chemistry_matters_radio_group.value
        win_ultimate_teams.become_target()

    chemistry_matters_radio_group = RadioGroup(action=get_chemistry_matters_rg)

    # Process Type Radio Buttons
    multi_process_radio_btn = RadioButton('Yes', width=radio_btn_width,
                                          x=chemistry_matters_label.right + radio_btn_space,
                                          y=chemistry_matters_label.top, group=chemistry_matters_radio_group, value=True)
    display_items.append(multi_process_radio_btn)

    single_process_radio_btn = RadioButton('No', width=radio_btn_width,
                                           x=multi_process_radio_btn.right + radio_btn_space,
                                           y=chemistry_matters_label.top, group=chemistry_matters_radio_group, value=False)
    display_items.append(single_process_radio_btn)

    chemistry_matters_radio_group.value = settings['chemistry_matters']

    # ========== Judging Teams Label ==========
    judging_teams_label = Label(text="How to Judge Teams: ", font=std_tf_font_bold,
                                       width=std_tf_width, height=std_tf_height,
                                       x=settings_indent - std_tf_width,
                                       y=chemistry_matters_label.bottom + title_border,
                                       color=title_color, just='right')
    display_items.append(judging_teams_label)

    judging_teams_attributes = Label(font=std_tf_font,
                                       width=std_tf_width, height=std_tf_height,
                                       x=judging_teams_label.right + radio_btn_space,
                                       y=judging_teams_label.top,
                                       color=title_color, just='left')
    judging_teams_attributes_text = ''
    for attr in settings['team_sort_attributes']:
        judging_teams_attributes_text += format_attr_name(attr) + ', '
    # Remove extra comma and space
    judging_teams_attributes_text = judging_teams_attributes_text[:-2]
    # Truncate if too long
    if len(judging_teams_attributes_text) > 26:
        judging_teams_attributes_text = judging_teams_attributes_text[:26] + '...'
    judging_teams_attributes.text = judging_teams_attributes_text
    display_items.append(judging_teams_attributes)

    # Judging Teams Edit Button
    def judging_teams_edit_btn_func():
        save_settings()
        attr_dict = {}
        attr_list = settings['team_sort_attributes']
        attr_type = 'team_sort'
        attribute_settings = {'window': 'ultimate_team_judging', 'file_name': team_list_name_tf.value,
                              'roster': roster, 'input_formation': input_formation, 'prev_window_value': win_previous}
        AddAttribute.open_attribute_window(
            win_ultimate_teams.x, win_ultimate_teams.y, db_dict, attr_dict, attr_list, attr_type, attribute_settings)

        win_ultimate_teams.hide()

    judging_edit_btn_width = 40
    judging_teams_edit_btn = Button("Edit",
                                    #x=teams_to_return_tf.right - judging_edit_btn_width,
                                    x=judging_teams_attributes.right,
                                    y=judging_teams_label.top,
                                    height=small_button_height-7, width=judging_edit_btn_width,
                                    font=small_button_font, action=judging_teams_edit_btn_func, style = 'default',
                                    color=button_color, just='right')
    display_items.append(judging_teams_edit_btn)

    # ========== Judging Players Label ==========
    judging_players_label = Label(text="How to Judge Players: ", font=std_tf_font_bold,
                                  width=std_tf_width, height=std_tf_height,
                                  x=settings_indent - std_tf_width,
                                  y=judging_teams_label.bottom + title_border,
                                  color=title_color, just='right')
    display_items.append(judging_players_label)

    judging_players_attributes = Label(font=std_tf_font,
                                       width=std_tf_width, height=std_tf_height,
                                       x=judging_players_label.right + radio_btn_space,
                                       y=judging_players_label.top,
                                       color=title_color, just='left')
    judging_players_attributes_text = ''
    for attr in settings['player_sort_attributes']:
        judging_players_attributes_text += format_attr_name(attr) + ', '
    # Remove extra comma and space
    judging_players_attributes_text = judging_players_attributes_text[:-2]
    # Truncate if too long
    if len(judging_players_attributes_text) > 26:
        judging_players_attributes_text = judging_players_attributes_text[:26] + '...'
    judging_players_attributes.text = judging_players_attributes_text
    display_items.append(judging_players_attributes)

    # Judging Teams Edit Button
    def judging_players_edit_btn_func():
        save_settings()
        attr_dict = {}
        attr_list = settings['player_sort_attributes']
        attr_type = 'player_sort'
        attribute_settings = {'window': 'ultimate_player_judging', 'file_name': team_list_name_tf.value,
                              'roster': roster, 'input_formation': input_formation, 'prev_window_value': win_previous}
        AddAttribute.open_attribute_window(win_ultimate_teams.x, win_ultimate_teams.y, db_dict, attr_dict,
                                           attr_list, attr_type, attribute_settings)

        win_ultimate_teams.hide()

    judging_edit_btn_width = 40
    judging_players_edit_btn = Button("Edit",
                                      #x=teams_to_return_tf.right - judging_edit_btn_width,
                                      x=judging_players_attributes.right,
                                      y=judging_players_label.top,
                                      height=small_button_height-7, width=judging_edit_btn_width,
                                      font=small_button_font, action=judging_players_edit_btn_func, style = 'default',
                                      color=button_color, just='right')
    display_items.append(judging_players_edit_btn)

    # ========== New Player Budget ==========
    budget_tf = TextField(font=std_tf_font, width=tf_width, height=std_tf_height_plus)

    def budget_btn_func():
        if not settings['budget'][0]:
            settings['budget'][0] = True
            budget_tf.value = str(settings['budget'][1])
            budget_tf.enabled = 1
            player_db_button.enabled = 1

        else:
            # Get value from text field and assign to settings
            if str.isdigit(budget_tf.value):
                settings['budget'][1] = int(budget_tf.value)

            settings['budget'][0] = False
            budget_tf.value = disabled_msg
            budget_tf.enabled = 0
            player_db_button.enabled = 0

        win_ultimate_teams.become_target()

    budget_btn = Button(title="New Player Budget", font=std_tf_font_bold,
                        width=std_tf_width, height=std_tf_height_plus,
                        x=settings_indent - std_tf_width,
                        y=judging_players_label.bottom + title_border*2,
                        action=budget_btn_func,
                        color=title_color, just='right')
    display_items.append(budget_btn)

    budget_tf.x = budget_btn.right + radio_btn_space
    budget_tf.y = budget_btn.top
    display_items.append(budget_tf)

    # Disable based on settings
    if not settings['budget'][0]:
        budget_tf.value = disabled_msg
        budget_tf.enabled = 0
        player_db_button.enabled = 0

    else:
        budget_tf.value = str(settings['budget'][1])

    # ========== Limits Label ==========
    limits_label = Label(text="Limitations", font=title_font_3,
                         width=std_tf_width, height=title_height-25,
                         x=(win_ultimate_teams.width - std_tf_width)/2,
                         y=budget_tf.bottom + title_border*2,
                         color=title_color, just='center')
    display_items.append(limits_label)

    # ========== Players per Position Label ==========
    players_per_pos_tf = TextField(font=std_tf_font, width=tf_width, height=std_tf_height_plus)

    def players_per_pos_btn_func():
        if not settings['players_per_position'][0]:
            settings['players_per_position'][0] = True
            players_per_pos_tf.value = str(settings['players_per_position'][1])
            players_per_pos_tf.enabled = 1

        else:
            # Get value from text field and assign to settings
            if str.isdigit(players_per_pos_tf.value):
                settings['players_per_position'][1] = int(players_per_pos_tf.value)

            settings['players_per_position'][0] = False
            players_per_pos_tf.value = disabled_msg
            players_per_pos_tf.enabled = 0

        win_ultimate_teams.become_target()

    players_per_pos_btn = Button(title="Players per Position", font=std_tf_font_bold,
                                 width=std_tf_width, height=std_tf_height_plus,
                                 x=settings_indent - std_tf_width,
                                 y=limits_label.bottom + 5,
                                 action=players_per_pos_btn_func,
                                 color=title_color, just='right')
    display_items.append(players_per_pos_btn)

    players_per_pos_tf.x = players_per_pos_btn.right + radio_btn_space
    players_per_pos_tf.y = players_per_pos_btn.top
    display_items.append(players_per_pos_tf)

    # Disable based on settings
    if not settings['players_per_position'][0]:
        players_per_pos_tf.value = disabled_msg
        players_per_pos_tf.enabled = 0
    else:
        players_per_pos_tf.value = str(settings['players_per_position'][1])

    # ========== Max Teams per Formation Label ==========
    teams_per_formation_tf = TextField(font=std_tf_font, width=tf_width, height=std_tf_height_plus)

    def teams_per_formation_btn_func():
        if not settings['teams_per_formation'][0]:
            settings['teams_per_formation'][0] = True
            teams_per_formation_tf.value = str(settings['teams_per_formation'][1])
            teams_per_formation_tf.enabled = 1

        else:
            # Get value from text field and assign to settings
            if str.isdigit(teams_per_formation_tf.value):
                settings['teams_per_formation'][1] = int(teams_per_formation_tf.value)

            settings['teams_per_formation'][0] = False
            teams_per_formation_tf.value = disabled_msg
            teams_per_formation_tf.enabled = 0

        win_ultimate_teams.become_target()

    teams_per_formation_btn = Button(title="Max Teams per Formation", font=std_tf_font_bold,
                                     width=std_tf_width, height=std_tf_height_plus,
                                     x=settings_indent - std_tf_width,
                                     y=players_per_pos_btn.bottom + 5,
                                     action=teams_per_formation_btn_func,
                                     color=title_color, just='right')
    display_items.append(teams_per_formation_btn)

    teams_per_formation_tf.x = teams_per_formation_btn.right + radio_btn_space
    teams_per_formation_tf.y = teams_per_formation_btn.top
    display_items.append(teams_per_formation_tf)

    # Disable based on settings
    if not settings['teams_per_formation'][0]:
        teams_per_formation_tf.value = disabled_msg
        teams_per_formation_tf.enabled = 0
    else:
        teams_per_formation_tf.value = str(settings['teams_per_formation'][1])

    # ========== Max Teams to Return Label ==========
    teams_to_return_tf = TextField(font=std_tf_font, width=tf_width, height=std_tf_height_plus)

    def teams_to_return_btn_func():
        if not settings['num_teams_returned'][0]:
            settings['num_teams_returned'][0] = True
            teams_to_return_tf.value = str(settings['num_teams_returned'][1])
            teams_to_return_tf.enabled = 1

        else:
            # Get value from text field and assign to settings
            if str.isdigit(teams_to_return_tf.value):
                settings['num_teams_returned'][1] = int(teams_to_return_tf.value)

            settings['num_teams_returned'][0] = False
            teams_to_return_tf.value = disabled_msg
            teams_to_return_tf.enabled = 0

        win_ultimate_teams.become_target()

    teams_to_return_btn = Button(title="Max Teams to Return", font=std_tf_font_bold,
                                 width=std_tf_width, height=std_tf_height_plus,
                                 x=settings_indent - std_tf_width,
                                 y=teams_per_formation_btn.bottom + 5,
                                 action=teams_to_return_btn_func,
                                 color=title_color, just='right')
    display_items.append(teams_to_return_btn)

    teams_to_return_tf.x = teams_to_return_btn.right + radio_btn_space
    teams_to_return_tf.y = teams_to_return_btn.top
    display_items.append(teams_to_return_tf)

    # Disable based on settings
    if not settings['num_teams_returned'][0]:
        teams_to_return_tf.value = disabled_msg
        teams_to_return_tf.enabled = 0
    else:
        teams_to_return_tf.value = str(settings['num_teams_returned'][1])

    # ========== Time Limit Label ==========
    time_limit_tf = TextField(font=std_tf_font, width=tf_width, height=std_tf_height_plus)

    def time_limit_btn_func():
        if not settings['time_limit'][0]:
            settings['time_limit'][0] = True

            time_limit_val = 0.0
            if settings['time_limit'][2] == 'days':
                time_limit_val = settings['time_limit'][1] / 86400.0
            elif settings['time_limit'][2] == 'hours':
                time_limit_val = settings['time_limit'][1] / 3600.0
            if settings['time_limit'][2] == 'minutes':
                time_limit_val = settings['time_limit'][1] / 60.0
            time_limit_tf.value = str(time_limit_val)

            time_limit_tf.enabled = 1
            days_time_limit_radio_btn.enabled = 1
            hours_time_limit_radio_btn.enabled = 1
            minutes_time_limit_radio_btn.enabled = 1
            time_limit_radio_group.enabled = 1

        else:
            # Get value from text field, convert to seconds, and assign to settings
            try:
                if settings['time_limit'][2] == 'days':
                    settings['time_limit'][1] = int(float(time_limit_tf.value) * 86400.0)
                elif settings['time_limit'][2] == 'hours':
                    settings['time_limit'][1] = int(float(time_limit_tf.value) * 3600.0)
                elif settings['time_limit'][2] == 'minutes':
                    settings['time_limit'][1] = int(float(time_limit_tf.value) * 60.0)
            except ValueError:
                print "Invalid time limit."

            settings['time_limit'][0] = False
            time_limit_tf.value = disabled_msg
            time_limit_tf.enabled = 0
            days_time_limit_radio_btn.enabled = 0
            hours_time_limit_radio_btn.enabled = 0
            minutes_time_limit_radio_btn.enabled = 0
            time_limit_radio_group.enabled = 0

        win_ultimate_teams.become_target()

    time_limit_btn = Button(title="Time Limit", font=std_tf_font_bold,
                            width=std_tf_width, height=std_tf_height_plus,
                            x=settings_indent - std_tf_width,
                            y=teams_to_return_btn.bottom + 5,
                            action=time_limit_btn_func,
                            color=title_color, just='right')
    display_items.append(time_limit_btn)

    def get_time_limit_rg():
        # Get value from text field, convert to seconds, and assign to settings
        if time_limit_tf.value == '':
            time_limit_tf.value = '0'
        else:
            try:
                if settings['time_limit'][2] == 'days':
                    settings['time_limit'][1] = int(float(time_limit_tf.value) * 86400.0)
                elif settings['time_limit'][2] == 'hours':
                    settings['time_limit'][1] = int(float(time_limit_tf.value) * 3600.0)
                elif settings['time_limit'][2] == 'minutes':
                    settings['time_limit'][1] = int(float(time_limit_tf.value) * 60.0)
            except ValueError:
                print "Invalid time limit."

        # Get new time limit units
        settings['time_limit'][2] = time_limit_radio_group.value

        time_limit_val = 0.0
        if settings['time_limit'][2] == 'days':
            time_limit_val = settings['time_limit'][1] / 86400.0
        elif settings['time_limit'][2] == 'hours':
            time_limit_val = settings['time_limit'][1] / 3600.0
        elif settings['time_limit'][2] == 'minutes':
            time_limit_val = settings['time_limit'][1] / 60.0
        time_limit_tf.value = str(time_limit_val)

        win_ultimate_teams.become_target()

    time_limit_radio_group = RadioGroup(action=get_time_limit_rg)

    # Time Limit Units Radio Buttons
    days_time_limit_radio_btn = RadioButton('Days', width=radio_btn_width,
                                            x=time_limit_btn.right + radio_btn_space,
                                            y=time_limit_btn.bottom + 5,
                                            group=time_limit_radio_group, value='days')
    display_items.append(days_time_limit_radio_btn)

    hours_time_limit_radio_btn = RadioButton('Hours', width=radio_btn_width,
                                             x=days_time_limit_radio_btn.right + radio_btn_space,
                                             y=days_time_limit_radio_btn.top,
                                             group=time_limit_radio_group, value='hours')
    display_items.append(hours_time_limit_radio_btn)

    minutes_time_limit_radio_btn = RadioButton('Minutes', width=radio_btn_width,
                                               x=hours_time_limit_radio_btn.right + radio_btn_space,
                                               y=days_time_limit_radio_btn.top,
                                               group=time_limit_radio_group, value='minutes')
    display_items.append(minutes_time_limit_radio_btn)

    time_limit_radio_group.value = settings['time_limit'][2]

    time_limit_tf.x = time_limit_btn.right + radio_btn_space
    time_limit_tf.y = time_limit_btn.top
    display_items.append(time_limit_tf)

    # Disable based on settings
    if not settings['time_limit'][0]:
        time_limit_tf.value = disabled_msg
        time_limit_tf.enabled = 0
        days_time_limit_radio_btn.enabled = 0
        hours_time_limit_radio_btn.enabled = 0
        minutes_time_limit_radio_btn.enabled = 0
        time_limit_radio_group.enabled = 0
    else:
        time_limit_value = 0.0
        if settings['time_limit'][2] == 'days':
            time_limit_value = settings['time_limit'][1] / 86400.0
        elif settings['time_limit'][2] == 'hours':
            time_limit_value = settings['time_limit'][1] / 3600.0
        elif settings['time_limit'][2] == 'minutes':
            time_limit_value = settings['time_limit'][1] / 60.0
        time_limit_tf.value = str(time_limit_value)

    # ========== Button Declarations ==========
    start_btn = Button("Start")
    menu_btn = Button("Main Menu")
    back_btn = Button("Back")

    # ========== Button Functions ==========
    def save_settings():
        """
        Save the ultimate team creation configuration settings
        """

        # Get the values from the text fields
        # New player budget
        if str.isdigit(budget_tf.value):
            settings['budget'][1] = int(budget_tf.value)
        # Players per position
        if str.isdigit(players_per_pos_tf.value):
                settings['players_per_position'][1] = int(players_per_pos_tf.value)
        # Teams per formation
        if str.isdigit(teams_per_formation_tf.value):
                settings['teams_per_formation'][1] = int(teams_per_formation_tf.value)
        # Number of teams returned
        if str.isdigit(teams_to_return_tf.value):
                settings['num_teams_returned'][1] = int(teams_to_return_tf.value)
        # Time limit
        if time_limit_tf.value != disabled_msg:
            try:
                if settings['time_limit'][2] == 'days':
                    settings['time_limit'][1] = int(float(time_limit_tf.value) * 86400.0)
                elif settings['time_limit'][2] == 'hours':
                    settings['time_limit'][1] = int(float(time_limit_tf.value) * 3600.0)
                elif settings['time_limit'][2] == 'minutes':
                    settings['time_limit'][1] = int(float(time_limit_tf.value) * 60.0)
            except ValueError:
                print "Invalid time limit."

        # Load configurations
        from Window.AppConfig import config_filename
        with open(config_filename, 'r') as config_file:
            configurations = json.load(config_file)
            config_file.close()

        # Edit configurations
        configurations['ultimate_team_configs'] = settings

        # Save the settings
        with open(config_filename, 'w') as config_file:
            json.dump(configurations, config_file)
            config_file.close()

    def start_btn_func():
        save_settings()

        # Assign formation(s) to use
        if input_formation is None or input_formation['name'] == "Generic":
            formations = db_dict['formation_list'][1]
        else:
            formations = FormationDB.FormationDB(input_formation)

        # If budget is not used, set player DB to an empty object.
        if budget_btn.enabled:
            player_db = db_dict['player_db'][1]
        else:
            player_db = PlayerDB.PlayerDB()

        # Open status page
        """StatusWindow.open_status_window(win_ultimate_teams.x, win_ultimate_teams.y,
                                        db_dict, file_name=team_list_name_tf.value, win_previous=win_ultimate_teams)
        win_ultimate_teams.hide()"""

        # Run team creation here
        team = Team.Team()
        teams = TeamDB.TeamDB(team.create_team_ultimate(db_dict['player_list'][1], player_db, formations))

        if len(teams.db) > 0:
            teams.save(team_list_name_tf.value)
        else:
            print 'Not saved because no teams created.'

        # Erase file name
        team_list_name_tf.value = ''
        win_ultimate_teams.become_target()

    def menu_btn_func():
        save_settings()
        StartMenu.open_start_menu(win_ultimate_teams.x, win_ultimate_teams.y, db_dict)
        win_ultimate_teams.hide()

    def back_btn_func():
        save_settings()
        win_previous.show()
        win_ultimate_teams.hide()

    # Save the attribute lists if they were changed
    if player_judge_list is not None:
        save_settings()

    if team_judge_list is not None:
        save_settings()

    # ========== Buttons ==========
    start_btn.x = (win_width - 3*button_width - 2*button_spacing) / 2
    start_btn.y = win_ultimate_teams.height - 100
    start_btn.height = button_height
    start_btn.width = button_width
    start_btn.font = button_font
    start_btn.action = start_btn_func
    start_btn.style = 'default'
    start_btn.color = button_color
    start_btn.just = 'right'
    display_items.append(start_btn)

    menu_btn.x = start_btn.right + button_spacing
    menu_btn.y = start_btn.top
    menu_btn.height = button_height
    menu_btn.width = button_width
    menu_btn.font = button_font
    menu_btn.action = menu_btn_func
    menu_btn.style = 'default'
    menu_btn.color = button_color
    menu_btn.just = 'right'
    display_items.append(menu_btn)

    back_btn.x = menu_btn.right + button_spacing
    back_btn.y = start_btn.top
    back_btn.height = button_height
    back_btn.width = button_width
    back_btn.font = button_font
    back_btn.action = back_btn_func
    back_btn.style = 'default'
    back_btn.color = button_color
    back_btn.just = 'right'
    display_items.append(back_btn)

    # ========== Add components to view and add view to window ==========
    for item in display_items:
        view.add(item)

    win_ultimate_teams.add(view)
    view.become_target()
    win_ultimate_teams.show()