<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml"
	xmlns:ui="http://java.sun.com/jsf/facelets"
	xmlns:h="http://java.sun.com/jsf/html"
	xmlns:f="http://java.sun.com/jsf/core">

<ui:composition template="template.jsf">
	<ui:define name="title">
		<h:outputText value="Team: #{viewTeam.team.name}" />
	</ui:define>
	<ui:define name="subtitle">
		<h:outputText value="Modify Team" />
	</ui:define>
	<ui:define name="crumb1">
		<h:commandLink value="MySports" action="index" />
	</ui:define>
	<ui:define name="crumb2">
		<h:commandLink value="#{viewLeague.leagueId}"
			action="#{viewLeague.view}" />
	</ui:define>
	<ui:define name="crumb3">
		<h:commandLink value="#{viewLeague.currentDivision.name}"
			action="#{viewDivision.view}" />
	</ui:define>
	<ui:define name="body">
		<h:form>

			<h:panelGrid width="100%" columns="2" border="1">
				<h:outputLabel value="Name:" />
				<h:inputText value="#{editTeam.team.name}" />
			</h:panelGrid>
			<h3>Players</h3>
			<h:dataTable binding="#{editTeam.dataTable}" />
			<div align="center">
				<h:commandButton action="#{editTeam.save}" value="Save" />
				<h:commandButton action="#{editTeam.cancel}" value="Cancel" />
			</div>
		</h:form>
	</ui:define>
</ui:composition>
</html>