Java tutorial
/* * Sencha GXT 2.3.1 - Sencha for GWT * Copyright(c) 2007-2013, Sencha, Inc. * licensing@sencha.com * * http://www.sencha.com/products/gxt/license/ */ package com.extjs.gxt.ui.client.widget.grid; import com.extjs.gxt.ui.client.GXT; import com.extjs.gxt.ui.client.Style.SortDir; import com.extjs.gxt.ui.client.core.El; import com.extjs.gxt.ui.client.core.XDOM; import com.extjs.gxt.ui.client.data.ModelData; import com.extjs.gxt.ui.client.data.ModelKeyProvider; import com.extjs.gxt.ui.client.data.PagingLoadResult; import com.extjs.gxt.ui.client.data.PagingLoader; import com.extjs.gxt.ui.client.event.BaseEvent; import com.extjs.gxt.ui.client.event.Events; import com.extjs.gxt.ui.client.event.GridEvent; import com.extjs.gxt.ui.client.event.Listener; import com.extjs.gxt.ui.client.event.LiveGridEvent; import com.extjs.gxt.ui.client.store.ListStore; import com.extjs.gxt.ui.client.store.Record; import com.extjs.gxt.ui.client.store.StoreEvent; import com.extjs.gxt.ui.client.store.StoreListener; import com.extjs.gxt.ui.client.util.DelayedTask; import com.google.gwt.dom.client.Element; import com.google.gwt.safehtml.shared.SafeHtml; import com.google.gwt.safehtml.shared.SafeHtmlUtils; import com.google.gwt.user.client.Command; import com.google.gwt.user.client.DeferredCommand; import com.google.gwt.user.client.Event; /** * LiveGridView for displaying large amount of data. Data is loaded on demand as * the user scrolls the grid. */ @SuppressWarnings("deprecation") public class LiveGridView extends GridView { protected El liveScroller; protected ListStore<ModelData> liveStore; protected int liveStoreOffset = 0; protected int totalCount = 0; protected int viewIndex; private int cacheSize = 200; private boolean ignoreScroll; private boolean isLoading; // to prevent flickering private boolean isMasked; private StoreListener<ModelData> liveStoreListener; private int loadDelay = 200; private PagingLoader<PagingLoadResult<ModelData>> loader; private int loaderOffset; private DelayedTask loaderTask; private double prefetchFactor = .2; private int rowHeight = 20; private int viewIndexReload = -1; /** * Returns the numbers of rows that should be cached. * * @return the cache size */ public int getCacheSize() { int c = -1; if (grid.isViewReady()) { c = getVisibleRowCount(); } return Math.max(c, cacheSize); } /** * Returns the amount of time before loading is done. * * @return the load delay in milliseconds */ public int getLoadDelay() { return loadDelay; } /** * Returns the prefetchFactor. * * @return the prefetchFactor */ public double getPrefetchFactor() { return prefetchFactor; } /** * Returns the height of one row. * * @return the height of one row */ public int getRowHeight() { return rowHeight; } public int getVisibleRowCount() { int rh = getCalculatedRowHeight(); int visibleHeight = getLiveScrollerHeight(); return (int) ((visibleHeight < 1) ? 0 : Math.floor((double) visibleHeight / rh)); } @SuppressWarnings("rawtypes") @Override public void handleComponentEvent(GridEvent ge) { super.handleComponentEvent(ge); int type = ge.getEventTypeInt(); Element target = ge.getTarget(); if (!ignoreScroll && (type == Event.ONSCROLL && liveScroller.dom.isOrHasChild(target)) || (type == Event.ONMOUSEWHEEL && mainBody.dom.isOrHasChild(target))) { ge.stopEvent(); if (type == Event.ONMOUSEWHEEL) { int v = ge.getEvent().getMouseWheelVelocityY() * getCalculatedRowHeight(); liveScroller.setScrollTop(liveScroller.getScrollTop() + v); } else { updateRows((int) Math.ceil((double) liveScroller.getScrollTop() / getCalculatedRowHeight()), false); } } } /** * Refreshed the view. Reloads the store based on the current settings */ public void refresh() { maskView(); loadLiveStore(liveStoreOffset); } @Override public void refresh(boolean headerToo) { super.refresh(headerToo); if (headerToo) { positionLiveScroller(); } if (!preventScrollToTopOnRefresh) { // we scrolled to the top updateRows(0, false); } } @Override public void scrollToTop() { liveScroller.setScrollTop(0); } /** * Sets the amount of rows that should be cached (default to 200). The cache * size is the number of rows that are retrieved each time a data request is * made. The cache size should always be greater than the number of visible * rows of the grid. The number of visible rows will vary depending on the * grid height and the height of each row. If the set cache size is smaller * than the number of visible rows of the grid than it gets set to the number * of visible rows of the grid. * * @param cacheSize the new cache size */ public void setCacheSize(int cacheSize) { this.cacheSize = cacheSize; } /** * Sets the amount of time before loading is done (defaults to 200). * * @param loadDelay the new load delay in milliseconds */ public void setLoadDelay(int loadDelay) { this.loadDelay = loadDelay; } /** * Sets the pre-fetch factor (defaults to .2). The pre-fetch factor is used to * determine when new data should be fetched as the user scrolls the grid. The * factor is used with the cache size. * * <p /> * For example, if the cache size is 1000 with a pre-fetch of .20, the grid * will request new data when the 800th (1000 * .20) row of the grid becomes * visible. * * @param prefetchFactor the pre-fetch factor */ public void setPrefetchFactor(double prefetchFactor) { this.prefetchFactor = prefetchFactor; } /** * Sets the height of one row (defaults to 20). <code>LiveGridView</code> will * only work with fixed row heights with all rows being the same height. * Changing this value will not physically resize the row heights, rather, the * specified height will be used internally for calculations. * * @param rowHeight the new row height. */ public void setRowHeight(int rowHeight) { this.rowHeight = rowHeight; } @Override protected void afterRender() { mainBody.setInnerHtml(renderRows(0, -1)); renderWidgets(0, -1); processRows(0, true); applyEmptyText(); refresh(); } @Override protected void calculateVBar(boolean force) { if (force) { layout(); } } @SuppressWarnings({ "rawtypes", "unchecked" }) protected GridEvent<?> createComponentEvent(Event event) { LiveGridEvent l = new LiveGridEvent(grid, event); l.setLiveStoreOffset(liveStoreOffset); l.setViewIndex(viewIndex); l.setTotalCount(totalCount); return l; } protected void doLoad() { loader.load(loaderOffset, getCacheSize()); } protected int getCalculatedRowHeight() { return rowHeight + borderWidth; } protected int getLiveScrollerHeight() { return liveScroller.getHeight(true); } protected int getLiveStoreCalculatedIndex(int index) { int calcIndex = index - (getCacheSize() / 2) + getVisibleRowCount(); calcIndex = Math.min(totalCount - getCacheSize(), calcIndex); calcIndex = Math.min(index, calcIndex); return Math.max(0, calcIndex); } @Override protected int getScrollAdjust() { return scrollOffset; } @SuppressWarnings({ "unchecked", "rawtypes" }) protected void initData(ListStore ds, ColumnModel cm) { if (liveStoreListener == null) { liveStoreListener = new StoreListener<ModelData>() { public void storeDataChanged(StoreEvent<ModelData> se) { liveStoreOffset = loader.getOffset(); if (totalCount != loader.getTotalCount()) { totalCount = loader.getTotalCount(); int height = totalCount * getCalculatedRowHeight(); // 1000000 as browser maxheight hack int count = height / 1000000; int h = 0; StringBuilder sb = new StringBuilder(); if (count > 0) { h = height / count; for (int i = 0; i < count; i++) { sb.append("<div style=\"width:"); sb.append(XDOM.getScrollBarWidth()); sb.append("px; height:"); sb.append(h); sb.append("px;\"> </div>"); } } int diff = height - count * h; if (diff != 0) { sb.append("<div style=\"width:"); sb.append(XDOM.getScrollBarWidth()); sb.append("px; height:"); sb.append(diff); sb.append("px;\"></div>"); } liveScroller.setInnerHtml(SafeHtmlUtils.fromTrustedString(sb.toString())); } if (totalCount > 0 && viewIndexReload != -1 && !isCached(viewIndexReload)) { loadLiveStore(getLiveStoreCalculatedIndex(viewIndexReload)); } else { viewIndexReload = -1; ignoreScroll = true; int scrollTop = liveScroller.getScrollTop(); liveScroller.setScrollTop(scrollTop - 1); liveScroller.setScrollTop(scrollTop); ignoreScroll = false; updateRows(viewIndex, true); isLoading = false; if (isMasked) { isMasked = false; scroller.unmask(); } } } public void storeUpdate(StoreEvent<ModelData> se) { LiveGridView.this.ds.update(se.getModel()); } }; } if (liveStore != null) { liveStore.removeStoreListener(liveStoreListener); } liveStore = ds; super.initData(new ListStore() { @Override public boolean equals(ModelData model1, ModelData model2) { return LiveGridView.this.liveStore.equals(model1, model2); } @Override public ModelKeyProvider getKeyProvider() { return LiveGridView.this.liveStore.getKeyProvider(); } @Override public Record getRecord(ModelData model) { return LiveGridView.this.liveStore.getRecord(model); } @Override public boolean hasRecord(ModelData model) { return LiveGridView.this.liveStore.hasRecord(model); } @Override public void sort(String field, SortDir sortDir) { LiveGridView.this.liveStore.sort(field, sortDir); sortInfo = liveStore.getSortState(); } }, cm); loader = (PagingLoader) liveStore.getLoader(); liveStore.addStoreListener(liveStoreListener); grid.getSelectionModel().bind(this.ds); } protected boolean isCached(int index) { if ((liveStore.getCount() == 0 && totalCount > 0) || (index < liveStoreOffset) || (index > (liveStoreOffset + getCacheSize() - getVisibleRowCount()))) { return false; } return true; } protected boolean isHorizontalScrollBarShowing() { return cm.getTotalWidth() + getScrollAdjust() > scroller.dom.getOffsetWidth(); } protected boolean loadLiveStore(int offset) { if (loaderTask == null) { loaderTask = new DelayedTask(new Listener<BaseEvent>() { public void handleEvent(BaseEvent be) { doLoad(); } }); } loaderOffset = offset; loaderTask.delay(loadDelay); if (isLoading) { return true; } else { isLoading = true; return false; } } @Override protected void notifyShow() { super.notifyShow(); updateRows((int) Math.ceil((double) liveScroller.getScrollTop() / getCalculatedRowHeight()), true); } @Override protected void onRemove(ListStore<ModelData> ds, ModelData m, int index, boolean isUpdate) { super.onRemove(ds, m, index, isUpdate); if (!isUpdate && liveStore.hasRecord(m)) { liveStore.getRecord(m).reject(false); } } @Override protected void renderUI() { super.renderUI(); scroller.setStyleAttribute("overflowY", "hidden"); liveScroller = grid.el().insertFirst("<div class=\"x-livegrid-scroller\"><div style=\"width: " + XDOM.getScrollBarWidth() + "px;\"> </div></div>"); positionLiveScroller(); liveScroller.addEventsSunk(Event.ONSCROLL); mainBody.addEventsSunk(Event.ONMOUSEWHEEL); } @Override protected void resize() { final int oldCount = getVisibleRowCount(); super.resize(); if (mainBody != null) { resizeLiveScroller(); scroller.setWidth(grid.getWidth() - getScrollAdjust(), true); DeferredCommand.addCommand(new Command() { public void execute() { if (oldCount != getVisibleRowCount()) { updateRows(LiveGridView.this.viewIndex, true); } } }); } } protected boolean shouldCache(int index) { int cz = getCacheSize(); int i = (int) (cz * prefetchFactor); double low = liveStoreOffset + i; double high = liveStoreOffset + cz - getVisibleRowCount() - i; if ((index < low && liveStoreOffset > 0) || (index > high && liveStoreOffset != totalCount - cz)) { return true; } return false; } @Override protected void updateAllColumnWidths() { super.updateAllColumnWidths(); resizeLiveScroller(); updateRows(viewIndex, true); } @Override protected void updateColumnHidden(int index, boolean hidden) { super.updateColumnHidden(index, hidden); resizeLiveScroller(); updateRows(viewIndex, true); } @Override protected void updateColumnWidth(int col, int width) { super.updateColumnWidth(col, width); resizeLiveScroller(); updateRows(viewIndex, true); } @SuppressWarnings("unchecked") protected void updateRows(int newIndex, boolean reload) { int rowCount = getVisibleRowCount(); newIndex = Math.min(newIndex, Math.max(0, totalCount - rowCount)); int diff = newIndex - viewIndex; int delta = Math.abs(diff); // nothing has changed and we are not forcing a reload if (delta == 0 && !reload) { return; } viewIndex = newIndex; int liveStoreIndex = Math.max(0, viewIndex - liveStoreOffset); // load data if not already cached if (!isCached(viewIndex)) { maskView(); if (loadLiveStore(getLiveStoreCalculatedIndex(viewIndex))) { viewIndexReload = viewIndex; } return; } // do pre caching if (shouldCache(viewIndex) && !isLoading) { loadLiveStore(getLiveStoreCalculatedIndex(viewIndex)); } int rc = getVisibleRowCount(); if (delta > rc - 1) { reload = true; } if (reload) { delta = diff = rc; boolean p = preventScrollToTopOnRefresh; preventScrollToTopOnRefresh = true; ds.removeAll(); preventScrollToTopOnRefresh = p; } if (delta == 0) { return; } int count = ds.getCount(); if (diff > 0) { // rolling forward for (int c = 0; c < delta && c < count; c++) { ds.remove(0); } count = ds.getCount(); ds.add(liveStore.getRange(liveStoreIndex + count, liveStoreIndex + count + delta - 1)); } else { // rolling back for (int c = 0; c < delta && c < count; c++) { ds.remove(count - c - 1); } ds.insert(liveStore.getRange(liveStoreIndex, liveStoreIndex + delta - 1), 0); } LiveGridEvent<ModelData> event = (LiveGridEvent<ModelData>) createComponentEvent(null); fireEvent(Events.LiveGridViewUpdate, event); } private void maskView() { if (!isMasked && grid.isLoadMask()) { scroller.mask(GXT.MESSAGES.loadMask_msg()); isMasked = true; } } private void positionLiveScroller() { liveScroller.setTop(mainHd.getHeight()); } private void resizeLiveScroller() { int h = grid.getHeight(true) - mainHd.getHeight(true); if (isHorizontalScrollBarShowing()) { h -= XDOM.getScrollBarWidth(); } if (footer != null) { h -= footer.getHeight(); } liveScroller.setHeight(h, true); } }