Selection of Items to get in the Cart

CatalogPanel.java

package com.arballon.web.framework.client.ui.widget.panel;

import java.util.List;

import com.arballon.web.common.client.icons.AWFIconImages;
import com.arballon.web.common.client.localization.ArballonMessages;
import com.arballon.web.common.client.localization.MessagesFactory;
import com.arballon.web.framework.client.AWF;
import com.arballon.web.framework.client.event.wizard.AddToCartEvent;
import com.arballon.web.framework.client.event.wizard.AddToCartEvent.AddToCartHandler;
import com.arballon.web.framework.client.event.wizard.AddToCartEvent.HasAddToCartHandlers;
import com.arballon.web.framework.shared.model.CatalogDTO;
import com.google.gwt.core.client.GWT;
import com.google.gwt.event.logical.shared.SelectionEvent;
import com.google.gwt.event.logical.shared.SelectionHandler;
import com.google.gwt.event.shared.HandlerRegistration;
import com.google.gwt.i18n.client.NumberFormat;
import com.google.gwt.resources.client.ClientBundle;
import com.google.gwt.resources.client.CssResource;
import com.google.gwt.safehtml.shared.SafeHtml;
import com.google.gwt.safehtml.shared.SafeHtmlBuilder;
import com.google.gwt.safehtml.shared.SafeUri;
import com.google.gwt.text.shared.AbstractSafeHtmlRenderer;
import com.sencha.gxt.cell.core.client.SimpleSafeHtmlCell;
import com.sencha.gxt.core.client.IdentityValueProvider;
import com.sencha.gxt.core.client.Style.SelectionMode;
import com.sencha.gxt.core.client.XTemplates;
import com.sencha.gxt.core.client.XTemplates.Formatter;
import com.sencha.gxt.core.client.XTemplates.FormatterFactories;
import com.sencha.gxt.core.client.XTemplates.FormatterFactory;
import com.sencha.gxt.core.client.dom.XElement;
import com.sencha.gxt.core.client.resources.CommonStyles;
import com.sencha.gxt.core.client.util.Format;
import com.sencha.gxt.data.shared.ListStore;
import com.sencha.gxt.widget.core.client.ListView;
import com.sencha.gxt.widget.core.client.ListViewCustomAppearance;
import com.sencha.gxt.widget.core.client.container.SimpleContainer;
import com.sencha.gxt.widget.core.client.form.NumberPropertyEditor.IntegerPropertyEditor;
import com.sencha.gxt.widget.core.client.form.SpinnerField;
import com.sencha.gxt.widget.core.client.menu.Item;
import com.sencha.gxt.widget.core.client.menu.Menu;
import com.sencha.gxt.widget.core.client.menu.MenuItem;
import com.sencha.gxt.widget.core.client.selection.SelectionChangedEvent.HasSelectionChangedHandlers;
import com.sencha.gxt.widget.core.client.selection.SelectionChangedEvent.SelectionChangedHandler;

/**
 * Panel de Seleccion de Catalogos con Imagenes
 * 
 * @author Daniel H. Ardison - (c)2013 Ardison Software & Consulting
 *
 * @param <M> DTO de Catalogo
 */
public class CatalogPanel<M extends CatalogDTO> 
  									extends SimpleContainer
										implements HasSelectionChangedHandlers<M>,
										           HasAddToCartHandlers<M> {
	private ArballonMessages messages=MessagesFactory.instance().getMessages();
	private ListStore<M> store;
	private ListView<M, M> view;
	private Menu contextMenu;

	@FormatterFactories(@FormatterFactory(factory = ShortenFactory.class, name = "shorten"))
	public interface Renderer extends XTemplates {

		@XTemplate("<span class='x-editable'>{item.name:shorten(24)}</span>")
	    public SafeHtml renderItem(CatalogItem item);
	}
	
	public interface ImageView extends XTemplates {
		
		@XTemplate("<img src='{baseUri}loadimageservlet?id={item.id}'>")
		SafeHtml renderImage(String baseUri, CatalogItem item);
	}
	
	public interface DefaultImageView extends XTemplates {
		
		@XTemplate("<img src='{uri}'>")
		SafeHtml renderImage(SafeUri uri);
	}
	
	public interface RenderPrice extends XTemplates {
		
		@XTemplate("<div class='{style.price}'>{item.price}</div>")
		SafeHtml render(CatalogItem item, Style style);
		
	}
	
	public interface RenderUnit extends XTemplates {

		@XTemplate("<div class='{style.unit}'>{item.messureUnit}</div>")
		SafeHtml renderUnit(CatalogItem item, Style style);

	}

	public interface Resources extends ClientBundle {
	    @Source("CatalogView.css")
	    Style css();
	  }

	static class Shorten implements Formatter<String> {

	    private int length;

	    public Shorten(int length) {
	      this.length = length;
	    }

	    @Override
	    public String format(String data) {
	      return Format.ellipse(data, length);
	    }
	}

	static class ShortenFactory {
	    public static Shorten getFormat(int length) {
	      return new Shorten(length);
	    }
	}

	public interface Style extends CssResource {
		
	    String over();

	    String select();

	    String thumb();

	    String thumbWrap();
	    
	    String price();
	    
	    String unit();
	    
	    String cellInCart();
	}

    final Resources resources = GWT.create(Resources.class);
    final Style style = resources.css();

    final Renderer render = GWT.create(Renderer.class);
    final DefaultImageView defImage = GWT.create(DefaultImageView.class);
    final ImageView imageView = GWT.create(ImageView.class);
    final RenderPrice renPrice = GWT.create(RenderPrice.class);
    final RenderUnit renUnit = GWT.create(RenderUnit.class);
    
	public CatalogPanel(ListStore<M> store) {
		super();
		this.store = store;
		this.buildUI();
	}

	protected void buildUI(){
	    resources.css().ensureInjected();
	    
	    ListViewCustomAppearance<M> appearance = new ListViewCustomAppearance<M>("." + style.thumbWrap(),
	              style.over(), style.select()) {
	            @Override
	            public void renderEnd(SafeHtmlBuilder builder) {
	              String markup = new StringBuilder("<div class=\"").append(CommonStyles.get().clear()).append("\"></div>").toString();
	              builder.appendHtmlConstant(markup);
	            }

	            @Override
	            public void renderItem(SafeHtmlBuilder builder, SafeHtml content) {
	              builder.appendHtmlConstant("<div class='" + style.thumbWrap() + "' style='border: 1px solid white'>");
	              builder.append(content);
	              builder.appendHtmlConstant("</div>");
	            }

	    };
	    
	    view = new ListView<M, M>(store, new IdentityValueProvider<M>(){

			@Override
			public void setValue(M object, M value) {

			}
	    	
	    }, appearance);
	    view.setCell(new SimpleSafeHtmlCell<M>(new AbstractSafeHtmlRenderer<M>() {

			@Override
			public SafeHtml render(M catalog) {
				SafeHtmlBuilder sb=new SafeHtmlBuilder();
				NumberFormat priceFormat=NumberFormat.getFormat("#,##0.00");
				CatalogItem item=new CatalogItem();

				item.setId(catalog.getImageId());
				item.setDescription(catalog.getDescription());
				item.setName(catalog.getName());
				item.setMessureUnit(catalog.getMessureUnit());
				sb.appendHtmlConstant("<div class='"+style.thumb()+"'>");
				if(item.getId()==null){
					sb.append(defImage.renderImage(AWFIconImages.INSTANCE.product96().getSafeUri()));
				}else{
					sb.append(imageView.renderImage(GWT.getModuleBaseURL(), item));
				}
				sb.appendHtmlConstant("</div>");
				sb.append(render.renderItem(item));
				sb.append(renUnit.renderUnit(item, style));
				if(!catalog.isPriceless()){
					item.setPrice(catalog.getCurrency()+" "+priceFormat.format(catalog.getPrice()));
					sb.append(renPrice.render(item, style));
				}
				return sb.toSafeHtml();
			}
	    	
		}));
	    view.getSelectionModel().setSelectionMode(SelectionMode.SINGLE);
	    this.setWidget(view);
	    //this.addStyleName("margin-10");
	    if(AWF.deviceType().isTablet() || AWF.deviceType().isMobile()){
	    	
	    }else{
	    	this.view.setContextMenu(this.createContextMenu());
	    }
	}
	
	protected Menu createContextMenu(){
		this.contextMenu=new Menu();
		Menu menu = new Menu();
		
		MenuItem qty=new MenuItem(messages.quantity_label());
		qty.setWidth(120);
		final SpinnerField<Integer> qtyField=new SpinnerField<Integer>(new IntegerPropertyEditor());
		qtyField.setValue(1);
		qtyField.setWidth(60);
		menu.add(qtyField);
		qty.setSubMenu(menu);
		this.contextMenu.addSelectionHandler(new SelectionHandler<Item>() {
			
			@Override
			public void onSelection(SelectionEvent<Item> event) {
				Integer qty=qtyField.getValue();
				M selected=view.getSelectionModel().getSelectedItem();
				processAddToCart(selected, qty);
			}
		});
		this.contextMenu.add(qty);
		return this.contextMenu;
	}
	
	protected void processAddToCart(M model, Integer qty){
		AddToCartEvent<M> event=new AddToCartEvent<M>(model, new Double(qty));
		this.fireEvent(event);
	}
	
	public void markAddToCartItem(Integer index){
		XElement element=this.view.getElement(index);
		if(element!=null){
			element.addClassName(style.cellInCart());
		}
	}
	
	public void markRemoveToCartItem(Integer index){
		XElement element=this.view.getElement(index);
		if(element!=null){
			element.removeClassName(style.cellInCart());
		}
	}
	
	public void setViewContextMenu(Menu menu){
		this.view.setContextMenu(menu);
	}
	
	/**
	 * Clase generica para exponer el catalogo
	 * 
	 * @author Daniel H. Ardison - (c)2013 Ardison Software & Consulting
	 *
	 */
	public static class CatalogItem {
		private Long id;
		private String name;
		private String description;
		private String price;
		private String messureUnit;
		
		public Long getId() {
			return id;
		}
		public void setId(Long id) {
			this.id = id;
		}
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
		public String getDescription() {
			return description;
		}
		public void setDescription(String description) {
			this.description = description;
		}
		public String getPrice() {
			return price;
		}
		public void setPrice(String price) {
			this.price = price;
		}
		public String getMessureUnit() {
			return messureUnit;
		}
		public void setMessureUnit(String messureUnit) {
			this.messureUnit = messureUnit;
		}
	}
	
	public List<M> getSelection(){
		
		return view.getSelectionModel().getSelectedItems();
	}

	@Override
	public HandlerRegistration addSelectionChangedHandler(SelectionChangedHandler<M> handler) {
		return this.view.getSelectionModel().addSelectionChangedHandler(handler);
	}

	@Override
	public HandlerRegistration addAddToCartHandler(AddToCartHandler<M> handler) {
		return this.addHandler(handler, AddToCartEvent.getType());
	}
	
}

CatalogSelectionPresenter.java

package com.arballon.web.framework.client.wizard.presenter;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

import com.arballon.web.framework.client.dispatch.ListLoaderDispatcherProvider;
import com.arballon.web.framework.client.event.filter.FilterChangedEvent;
import com.arballon.web.framework.client.event.filter.FilterChangedEvent.FilterChangedHandler;
import com.arballon.web.framework.client.event.wizard.AddToCartEvent;
import com.arballon.web.framework.client.event.wizard.CartDataChangedEvent;
import com.arballon.web.framework.client.event.wizard.CartDataChangedEvent.CartDataChangedHandler;
import com.arballon.web.framework.client.event.wizard.RemoveFromCartEvent;
import com.arballon.web.framework.client.event.wizard.ShowCartEvent;
import com.arballon.web.framework.client.field.catalog.CatalogSort;
import com.arballon.web.framework.client.wizard.view.CatalogSelectionView;
import com.arballon.web.framework.client.wizard.view.CatalogSelectionView.Presenter;
import com.arballon.web.framework.shared.data.AttributeFilterConfig;
import com.arballon.web.framework.shared.model.CatalogDTO;
import com.arballon.web.framework.shared.model.cart.CartItemDTO;
import com.arballon.web.framework.shared.parameter.Parameter;
import com.arballon.web.framework.shared.service.AbstractFilterListAttributeFiltersProcess;
import com.arballon.web.framework.shared.service.ListResult;
import com.google.gwt.event.shared.EventBus;
import com.sencha.gxt.data.shared.ListStore;
import com.sencha.gxt.data.shared.ModelKeyProvider;
import com.sencha.gxt.data.shared.SortDir;
import com.sencha.gxt.data.shared.Store.StoreSortInfo;
import com.sencha.gxt.data.shared.event.StoreDataChangeEvent;
import com.sencha.gxt.data.shared.event.StoreDataChangeEvent.StoreDataChangeHandler;
import com.sencha.gxt.data.shared.loader.BeforeLoadEvent;
import com.sencha.gxt.data.shared.loader.BeforeLoadEvent.BeforeLoadHandler;
import com.sencha.gxt.data.shared.loader.ListLoadConfig;

/**
 * Presentador Seleccion de Catalogos
 * 
 * @author Daniel H. Ardison - (c)2013 Ardison Software & Consulting
 *
 * @param <M> DTO de Catalogo
 * @param <P> Proceso de Lectura de Catalogos
 * @param <L> Resultado
 */
public class CatalogSelectionPresenter<M extends CatalogDTO,
  								   P extends AbstractFilterListAttributeFiltersProcess<M, L>,
									   L extends ListResult<M>> implements Presenter<M> {
	
	private ListLoaderDispatcherProvider<P, L, M> dispatcher;
	private CatalogSelectionView<M> view;
	private EventBus eventBus;
	private AttributeFilterConfig config;
	private ArrayList<Parameter> filters;
	private CatalogSort sortOption;
	private ListStore<M> store;
	private List<M> added;
	
	public CatalogSelectionPresenter(P process, EventBus eventBus, ModelKeyProvider<M> key){
		this.dispatcher = new ListLoaderDispatcherProvider<P, L, M>(process);
		this.store = this.getStore(key);
		this.eventBus = eventBus;
		this.registerEvents();
		this.sortOption=CatalogSort.CODE;
		this.added=new ArrayList<M>();
		this.bindSortOption();
		this.registerEvents();
	}

	protected void registerEvents(){
		this.eventBus.addHandler(FilterChangedEvent.getType(), new FilterChangedHandler(){

			@Override
			public void onFilterChanged(FilterChangedEvent event) {
				List<Parameter> filters=event.getFilters();
				reload(config, new ArrayList<Parameter>(filters));
			}
		});
		this.eventBus.addHandler(CartDataChangedEvent.getType(), new CartDataChangedHandler<M, CartItemDTO<M>>(){

			@Override
			public void onCartDataChanged(CartDataChangedEvent<M, CartItemDTO<M>> event) {
				processCartDataChanged(event);
			}

		});
	}
	
	protected ListStore<M> getStore(ModelKeyProvider<M> keyProvider){
		ListStore<M> result=this.dispatcher.buildStore(keyProvider);
		// Ya se creo el Loader, agrego handler para setear los filtro antes de cargar
		this.dispatcher.getLoader().addBeforeLoadHandler(new BeforeLoadHandler<ListLoadConfig>() {

			@Override
			public void onBeforeLoad(BeforeLoadEvent<ListLoadConfig> event) {
				setFilterAttributesBeforeLoad();
				view.mask();
			}
		});
		result.addStoreDataChangeHandler(new StoreDataChangeHandler<M>() {

			@Override
			public void onDataChange(StoreDataChangeEvent<M> event) {
				if(view.isMusk()){
					view.unmask();
				}
			}
		});
		return result;
	}
	
	protected void processCartDataChanged(CartDataChangedEvent<M, ?> event){
		this.view.updateCartItems(event.getItemsCount());
	}
	
	protected void setFilterAttributesBeforeLoad(){
		AttributeFilterConfig config=this.view.getCurrentAttributeConfig();
		this.setAttributeFiltersProcessData(this.dispatcher.getProcess(), config, filters);
	}
	
	protected void setAttributeFiltersProcessData(P process, AttributeFilterConfig config, ArrayList<Parameter> filters){
		process.setSearchAttributeList(config.getSearchAttributeList());
		process.setStatusAvailable(config.isStatusAvailable());
		process.setDisableRows(config.isDisabledRows());
		process.setEnableRows(config.isEnabledRows());
		process.setSearchValue(config.getSearchValue());
		process.setFilters(filters);
	}

	protected void reload(AttributeFilterConfig config, ArrayList<Parameter> filters) {
		this.filters=filters;
		this.setAttributeFiltersProcessData(this.dispatcher.getProcess(), config, filters);
		this.dispatcher.getLoader().load();
	}

	@Override
	public void applySort(CatalogSort sortOption) {
		this.sortOption=sortOption;
		this.store.applySort(false);
	}

	@Override
	public void addToCart(M model, Double quantity) {
		AddToCartEvent<M> event=new AddToCartEvent<M>(model, quantity);
		this.eventBus.fireEvent(event);
		this.updateCartItemAdded(model);
	}
	
	protected void updateCartItemAdded(M model){
		Integer index=this.store.indexOf(model);
		this.view.updateCartItemAdded(index);
		this.added.add(model);
	}
	
	protected void updateCartItemRemoved(M model){
		Integer index=this.store.indexOf(model);
		this.view.updateCartItemRemoved(index);
		this.added.remove(model);
	}
	
	@Override
	public void addToCart(List<M> list) {
		AddToCartEvent<M> event=new AddToCartEvent<M>();
		event.addListOfItemsToCartEvent(list);
		this.eventBus.fireEvent(event);
		for(M model : list){
			this.updateCartItemAdded(model);
		}
	}
	
	@Override
	public void removeFromCart(M model){
		RemoveFromCartEvent<M> event=new RemoveFromCartEvent<M>(model, new Double(1));
		this.eventBus.fireEvent(event);
		this.updateCartItemRemoved(model);
	}

	protected void bindSortOption(){
		this.store.addSortInfo(new StoreSortInfo<M>(new Comparator<M>(){

			@Override
			public int compare(M o1, M o2) {
				switch(sortOption){
				
				case CODE:
					return o1.getCode().compareTo(o2.getCode());
					
				case DESCRIPTION:
					return o1.getDescription().compareTo(o2.getDescription());
					
				case NAME:
					return o1.getName().compareTo(o2.getName());
					
				case PRICE:
					if(o1.isPriceless()){
						if(o2.isPriceless()){
							return 0;
						}else{
							return -1;
						}
					}else{
						return o1.getPrice().compareTo(o2.getPrice());
					}
					
				case MESSURE_UNIT:
					return o1.getMessureUnit().compareTo(o2.getMessureUnit());
					
				default: return 0;
				}
				
			}
			
		}, SortDir.ASC));
	}

	public CatalogSelectionView<M> getView() {
		return view;
	}

	public void setView(CatalogSelectionView<M> view) {
		this.view = view;
		this.view.setPresenter(this);
	}

	public ListStore<M> getStore() {
		return store;
	}
	
	public void load(){
		this.dispatcher.getLoader().load();
	}

	@Override
	public void showCart() {
		ShowCartEvent event=new ShowCartEvent();
		this.eventBus.fireEvent(event);
	}

	public ArrayList<Parameter> getFilters() {
		return filters;
	}

	public void setFilters(ArrayList<Parameter> filters) {
		this.filters = filters;
	}
	
	@Override
	public boolean isAdded(M model){
		return this.added.contains(model);
	}

}

CatalogSelectionView.java

package com.arballon.web.framework.client.wizard.view;

import java.util.List;

import com.arballon.web.framework.client.field.catalog.CatalogSort;
import com.arballon.web.framework.shared.data.AttributeFilterConfig;
import com.arballon.web.framework.shared.model.ModelDTO;
import com.google.gwt.user.client.ui.IsWidget;
import com.sencha.gxt.widget.core.client.button.TextButton;
import com.sencha.gxt.widget.core.client.event.SelectEvent.SelectHandler;

/**
 * Vista Generica de Seleccion de Elemento de un Catalogo
 * 
 * @author Daniel H. Ardison - (c)2013 Ardison Software & Consulting
 *
 * @param <M> DTO de Catalogo
 */
public interface CatalogSelectionView<M extends ModelDTO> extends IsWidget, WizardViewItem {
  
	public interface Presenter<M extends ModelDTO> {
		
		void applySort(CatalogSort sortOption);
		
		void addToCart(M model, Double quantity);
		
		void removeFromCart(M model);
		
		boolean isAdded(M model);
		
		void addToCart(List<M> list);
		
		void showCart();
		
	}
	
	void setPresenter(Presenter<M> presenter);
	
	public void addToolButton(TextButton button);

	public void addToolButton(TextButton button, SelectHandler handler);

	public AttributeFilterConfig getCurrentAttributeConfig();

	public void setHeader(String title);
	
	public void mask();
	
	public void unmask();
	
	public boolean isMusk();
	
	public void updateCartItems(Integer count);
	
	public void updateCartItemAdded(Integer index);
	
	public void updateCartItemRemoved(Integer index);
	
}

CatalogSelectionViewImpl.java

package com.arballon.web.framework.client.wizard.view;

import java.util.List;

import com.arballon.web.common.client.localization.ArballonMessages;
import com.arballon.web.common.client.localization.MessagesFactory;
import com.arballon.web.framework.client.AWF;
import com.arballon.web.framework.client.event.wizard.AddToCartEvent;
import com.arballon.web.framework.client.event.wizard.AddToCartEvent.AddToCartHandler;
import com.arballon.web.framework.client.field.EnumAttributeFieldValue;
import com.arballon.web.framework.client.field.catalog.CatalogFilterField;
import com.arballon.web.framework.client.field.catalog.CatalogSort;
import com.arballon.web.framework.client.field.catalog.CatalogSortField;
import com.arballon.web.framework.client.ui.widget.button.CartButton;
import com.arballon.web.framework.client.ui.widget.panel.AWFContentPanel;
import com.arballon.web.framework.client.ui.widget.panel.CatalogPanel;
import com.arballon.web.framework.shared.data.AttributeFilterConfig;
import com.arballon.web.framework.shared.data.BaseAttributeFilterConfig;
import com.arballon.web.framework.shared.model.CatalogDTO;
import com.google.gwt.event.logical.shared.SelectionEvent;
import com.google.gwt.event.logical.shared.SelectionHandler;
import com.google.gwt.resources.client.ImageResource;
import com.google.gwt.user.client.ui.Widget;
import com.sencha.gxt.data.shared.ListStore;
import com.sencha.gxt.messages.client.DefaultMessages;
import com.sencha.gxt.widget.core.client.box.AlertMessageBox;
import com.sencha.gxt.widget.core.client.button.ButtonBar;
import com.sencha.gxt.widget.core.client.button.TextButton;
import com.sencha.gxt.widget.core.client.container.BoxLayoutContainer.BoxLayoutPack;
import com.sencha.gxt.widget.core.client.event.SelectEvent;
import com.sencha.gxt.widget.core.client.event.SelectEvent.SelectHandler;
import com.sencha.gxt.widget.core.client.selection.SelectionChangedEvent;
import com.sencha.gxt.widget.core.client.selection.SelectionChangedEvent.SelectionChangedHandler;
import com.sencha.gxt.widget.core.client.toolbar.SeparatorToolItem;
import com.sencha.gxt.widget.core.client.toolbar.ToolBar;

public class CatalogSelectionViewImpl<M extends CatalogDTO> 
  										implements CatalogSelectionView<M> {
	private ArballonMessages messages=MessagesFactory.instance().getMessages();
	private CatalogPanel<M> panel;
	private ListStore<M> store;
	private AWFContentPanel main;
	private CatalogSortField sortField;
	private CatalogFilterField<M> filterField;
	private ToolBar toolBar;
	private Presenter<M> presenter;
	private ButtonBar cartButtonBar;
	private String title;
	private WizardViewItem previous;
	private WizardViewItem next;
	private AttributeFilterConfig filterConfig;
	private boolean masked;
	private CartButton cartButton;
	
	public CatalogSelectionViewImpl(ListStore<M> store, String title) {
		super();
		this.store = store;
		this.title = title;
		this.buildUI(title);
		this.masked = false;
	}
	
	protected void buildUI(String title){
		main=new AWFContentPanel();
		main.setHeadingText(title);
		
		toolBar=new ToolBar();
		filterField = new CatalogFilterField<M>();
		filterField.bind(store);
		filterField.setWidth(150);
		toolBar.add(filterField);
		toolBar.add(new SeparatorToolItem());
		
		sortField = new CatalogSortField();
		sortField.addSelectionHandler(new SelectionHandler<EnumAttributeFieldValue<CatalogSort>>() {
			
			@Override
			public void onSelection(SelectionEvent<EnumAttributeFieldValue<CatalogSort>> event) {
				CatalogSort option=event.getSelectedItem().getValue();
				presenter.applySort(option);
			}
		});
		toolBar.add(sortField);
		main.setTopComponent(toolBar);
		
		panel = new CatalogPanel<M>(store);
		panel.addSelectionChangedHandler(new SelectionChangedHandler<M>() {

			@Override
			public void onSelectionChanged(SelectionChangedEvent<M> event) {
				if(presenter.isAdded(event.getSelection().get(0))){
					presenter.removeFromCart(event.getSelection().get(0));
				}else{
					presenter.addToCart(event.getSelection());
				}
			}
			
		});
		if(AWF.deviceType().isDesktop()){
			panel.addAddToCartHandler(new AddToCartHandler<M>() {

				@Override
				public void onAddToCart(AddToCartEvent<M> event) {
					presenter.addToCart(event.getItems().get(0).getItem(), event.getItems().get(0).getQuantity());
				}
			});
		}else{
			// TODO Definir procedimiento para indicar cantidad cuando es mobile
		}
		main.setCentralWidget(panel);
		
		this.cartButtonBar = new ButtonBar();
		
		
/*		AddToCartButton addToCart=new AddToCartButton();
		addToCart.addSelectHandler(new SelectHandler() {
			
			@Override
			public void onSelect(SelectEvent event) {
				onAddToCart();
			}
		});
		this.cartButtonBar.add(addToCart);*/
		this.cartButtonBar.setPack(BoxLayoutPack.CENTER);
		this.cartButtonBar.setHorizontalSpacing(20);
		
		cartButton=new CartButton();
		cartButton.addSelectHandler(new SelectHandler() {
			
			@Override
			public void onSelect(SelectEvent event) {
				presenter.showCart();
			}
		});
		this.cartButtonBar.add(cartButton);
		this.main.setBottomComponent(cartButtonBar);
		
	}
	
	protected void onAddToCart(){
		List<M> selected=this.panel.getSelection();
		if(selected!=null && selected.size()>0){
			presenter.addToCart(selected);
		}else{
			AlertMessageBox box=new AlertMessageBox("Carrito de Compras", "No hay articulos seleccionados");
			box.show();
		}
	}
	

	public Presenter<M> getPresenter() {
		return presenter;
	}

	public void setPresenter(Presenter<M> presenter) {
		this.presenter = presenter;
	}

	@Override
	public Widget asWidget() {
		return main;
	}

	@Override
	public void addToolButton(TextButton button) {
		this.toolBar.add(button);
	}

	@Override
	public void addToolButton(TextButton button, SelectHandler handler) {
		button.addSelectHandler(handler);
		this.toolBar.add(button);
	}


	@Override
	public AttributeFilterConfig getCurrentAttributeConfig() {
		if(this.filterConfig==null){
			this.filterConfig=new BaseAttributeFilterConfig();
		}
		
		return filterConfig;
	}

	@Override
	public void setHeader(String title) {
		this.title=title;
		
	}

	@Override
	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	@Override
	public WizardViewItem getPrevious() {
		return previous;
	}

	@Override
	public void setPrevious(WizardViewItem previous) {
		this.previous = previous;
	}

	@Override
	public WizardViewItem getNext() {
		return next;
	}

	@Override
	public void setNext(WizardViewItem next) {
		this.next = next;
	}

	@Override
	public ImageResource getIcon() {
		return null;
	}

	@Override
	public String getToolTip() {
		return null;
	}

	@Override
	public void hideHeading() {
		main.setHeaderVisible(false);
		
	}

	@Override
	public void mask() {
		this.masked=true;
		this.panel.mask(DefaultMessages.getMessages().loadMask_msg());
	}

	@Override
	public void unmask() {
		this.masked=false;
		this.panel.unmask();
	}

	@Override
	public boolean isMusk() {
		return masked;
	}

	@Override
	public void updateCartItems(Integer count) {
		String text="[ "+count.toString()+" ] "+messages.items_label();
		this.cartButton.setText(text);
	}

	@Override
	public void updateCartItemAdded(Integer index) {
		this.panel.markAddToCartItem(index);
	}

	@Override
	public void updateCartItemRemoved(Integer index) {
		this.panel.markRemoveToCartItem(index);
	}
	
	

}