Statistics
| Revision:

gvsig-raster / org.gvsig.raster / trunk / org.gvsig.raster / org.gvsig.raster.swing / org.gvsig.raster.swing.impl / src / main / java / org / gvsig / raster / swing / impl / pagedtable / Pager.java @ 1506

History | View | Annotate | Download (5.83 KB)

1
/**
2
 * gvSIG. Desktop Geographic Information System.
3
 *
4
 * Copyright (C) 2007-2013 gvSIG Association.
5
 *
6
 * This program is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU General Public License
8
 * as published by the Free Software Foundation; either version 2
9
 * of the License, or (at your option) any later version.
10
 *
11
 * This program is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 * GNU General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU General Public License
17
 * along with this program; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
19
 * MA  02110-1301, USA.
20
 *
21
 * For any additional information, do not hesitate to contact us
22
 * at info AT gvsig.com, or visit our website www.gvsig.com.
23
 */
24
package org.gvsig.raster.swing.impl.pagedtable;
25

    
26
import java.util.ArrayList;
27
import java.util.List;
28
import java.util.Observable;
29

    
30

    
31
/**
32
 * @author Nacho Brodin (nachobrodin@gmail.com)
33
 */
34
public class Pager extends Observable {
35
        private List<Object>             entries                = null;
36
        private int                      entriesPerPage         = 0;
37
        private int                      selectedPage           = 0;
38
        private int[]                    selectedRows           = null;
39
        
40
        public static int                CHANGE_SELECTED_ROWS   = 0;
41
        public static int                CHANGE_ADD_ENTRY       = 1; 
42
        public static int                CHANGE_REMOVE_ENTRY    = 2;
43
        public static int                CHANGE_REMOVE_ALL      = 3;
44
        public static int                CHANGE_SELECTED_PAGE   = 4;
45
        //public static int                CHANGE_SWAP_ROWS       = 5;
46
                
47
        public Pager(int entriesPerPage) {
48
                this.entriesPerPage = entriesPerPage;
49
                entries = new ArrayList<Object>();
50
        }
51
        
52
        public void setEntriesPerPage(int n) {
53
                this.entriesPerPage = n;
54
        }
55
        
56
        public void increaseSelectedPage() {
57
                if(selectedPage < getPageCount() - 1) {
58
                        selectedPage ++;
59
                        setChanged();
60
                    notifyObservers(CHANGE_SELECTED_PAGE);
61
                }
62
        }
63
        
64
        public void decreaseSelectedPage() {
65
                if (selectedPage > 0) {
66
                        selectedPage --;
67
                        setChanged();
68
                    notifyObservers(CHANGE_SELECTED_PAGE);
69
                }
70
        }
71
        
72
        public void setSelectedRows(int[] rows) {
73
                selectedRows = rows;
74
                setChanged();
75
            notifyObservers(CHANGE_SELECTED_ROWS);
76
        }
77
        
78
        public void increaseSelectedRows() {
79
                boolean change = false;
80
                for (int i = 0; i < selectedRows.length; i++) {
81
                        if(selectedRows[i] < getEntriesCount()) {
82
                                selectedRows[i] ++;
83
                                change = true;
84
                        }
85
                }
86
                if(change) {
87
                        setChanged();
88
                        notifyObservers(CHANGE_SELECTED_ROWS);
89
                }
90
        }
91
        
92
        public void decreaseSelectedRows() {
93
                boolean change = false;
94
                for (int i = 0; i < selectedRows.length; i++) {
95
                        if(selectedRows[i] > 0) {
96
                                selectedRows[i] --;
97
                                change = true;
98
                        }
99
                }
100
                if(change) {
101
                        setChanged();
102
                        notifyObservers(CHANGE_SELECTED_ROWS);
103
                }
104
        }
105
        
106
        public void addSelectedRow(int row) {
107
                int[] newSelected = new int[selectedRows.length + 1];
108
                for (int i = 0; i < selectedRows.length; i++) {
109
                        newSelected[i] = selectedRows[i];
110
                }
111
                newSelected[newSelected.length - 1] = row;
112
                selectedRows = newSelected;
113
                setChanged();
114
            notifyObservers(CHANGE_SELECTED_ROWS);
115
        }
116
        
117
        public int[] getSelectedRows() {
118
                return selectedRows;
119
        }
120
        
121
        public void setSelectedPage(int page) {
122
                if(page >= 0 && page < getPageCount()) {
123
                        selectedPage = page;
124
                        setChanged();
125
                    notifyObservers(CHANGE_SELECTED_PAGE);
126
                }
127
        }
128
        
129
        public int getPageFromRow(int row) {
130
                return (int)(row / getEntriesPerPage());
131
        }
132
        
133
        public List<Object> getSelectedPage() {
134
                return getPage(getSelectedPageNumber());
135
        }
136
        
137
        public void addEntry(Object entry) {
138
                entries.add(entry);
139
                setChanged();
140
            notifyObservers(CHANGE_ADD_ENTRY);
141
            setSelectedRows(new int[]{entries.size() - 1});
142
        }
143
        
144
        public void removeEntry(int pos) {
145
                if(pos >= 0 && pos < entries.size()) {
146
                        entries.remove(pos);
147
                        setChanged();
148
                    notifyObservers(CHANGE_REMOVE_ENTRY);
149
                }
150
        }
151
        
152
        public void swapRow(int i, int j) {
153
                if(i == j)
154
                        return;
155
                if(j < i) {
156
                        int aux = i;
157
                        i = j;
158
                        j = aux;
159
                }
160
                        
161
                Object a = entries.get(i);
162
                Object b = entries.get(j);
163
                entries.add(i, b);
164
                entries.remove(i + 1);
165
                entries.add(j, a);
166
                entries.remove(j + 1);
167
                
168
                //setChanged();
169
            //notifyObservers(CHANGE_REMOVE_ALL);
170
        }
171
        
172
        public boolean isSelectedRow(int row) {
173
                for (int i = 0; i < selectedRows.length; i++) {
174
                        if(selectedRows[i] == row)
175
                                return true;
176
                }
177
                return false;
178
        }
179
        
180
        public void removePage(int page) {
181
                if(page >= 0 && page < getPageCount()) {
182
                        int init = entriesPerPage * page;
183
                        int end = init + entriesPerPage;
184
                        for (int i = end - 1; i >= init; i--) {
185
                                entries.remove(i);
186
                        }
187
                }
188
        }
189
        
190
        public int getPageCount() {
191
                return (int)Math.ceil(entries.size() / (double)entriesPerPage);
192
        }
193
        
194
        public boolean isInCurrentPage(int row) {
195
                int init = selectedPage * getEntriesPerPage();
196
                int end = init + getEntriesPerPage() - 1;
197
                if(row >= init && row <= end)
198
                        return true;
199
                return false;
200
        }
201
        
202
        public List<Object> getPage(int page) {
203
                if(page >= 0 && page < getPageCount()) {
204
                        int init = entriesPerPage * page;
205
                        int end = init + entriesPerPage;
206
                        end = end >= entries.size() ? entries.size() : end;
207
                        return entries.subList(init, end);
208
                }
209
                return null;
210
        }
211
        
212
        public int getEntriesPerPage() {
213
                return entriesPerPage;
214
        }
215
        
216
        public int getEntriesCount() {
217
                return entries.size();
218
        }
219
        
220
        public Object[] getLastEntry() {
221
                return (Object[])entries.get(entries.size() - 1);
222
        }
223
        
224
        public int getSelectedPageNumber() {
225
                if(selectedPage >= getPageCount()) {
226
                        selectedPage = getPageCount() - 1;
227
                        if(selectedPage < 0)
228
                                selectedPage = 0;
229
                }
230
                return selectedPage;
231
        }
232
        
233
        public void removeAllEntries() {
234
                entries.clear();
235
                setChanged();
236
            notifyObservers(CHANGE_REMOVE_ALL);
237
        }
238
}