Revision 38410 branches/v2_0_0_prep/extensions/org.gvsig.installer/org.gvsig.installer.swing/org.gvsig.installer.swing.impl/src/main/java/org/gvsig/installer/swing/impl/execution/panel/model/PackagesTableModel.java
PackagesTableModel.java | ||
---|---|---|
32 | 32 |
import java.util.Arrays; |
33 | 33 |
import java.util.Comparator; |
34 | 34 |
import java.util.HashMap; |
35 |
import java.util.HashSet; |
|
36 |
import java.util.Iterator; |
|
35 | 37 |
import java.util.List; |
36 | 38 |
import java.util.Map; |
39 |
import java.util.Set; |
|
37 | 40 |
|
38 | 41 |
import javax.swing.table.AbstractTableModel; |
39 | 42 |
|
... | ... | |
68 | 71 |
// WINDOLS_32, WINDOLS_64, LINUX_32, LINUX_64, ALL, OTHER |
69 | 72 |
// } |
70 | 73 |
|
71 |
private TablePackageInfo[] installerInfos = null;
|
|
74 |
private TablePackageInfo[] currentlyVisiblePackages = null;
|
|
72 | 75 |
|
73 | 76 |
private final String[] columnNames; |
74 | 77 |
|
... | ... | |
79 | 82 |
boolean isOfficial; |
80 | 83 |
private NameDescriptionOrCodeFilter packageFastFilter = null; |
81 | 84 |
private PackageFilter packageFilter = null; |
85 |
|
|
86 |
private Set<PackageInfo> selectedPackages = new HashSet<PackageInfo>(); |
|
87 |
private Map<String, TablePackageInfo> allPackages = null; |
|
82 | 88 |
|
83 | 89 |
public PackagesTableModel(SwingInstallerManager swingInstallerManager, |
84 | 90 |
InstallPackageService installerExecutionService, boolean isOfficial) { |
85 | 91 |
|
86 | 92 |
this.installerExecutionService = installerExecutionService; |
87 | 93 |
this.isOfficial = isOfficial; |
94 |
|
|
88 | 95 |
Map<String, TablePackageInfo> infos = getDefaultPackages(); |
89 | 96 |
|
90 |
installerInfos = infos.values().toArray(
|
|
97 |
currentlyVisiblePackages = infos.values().toArray(
|
|
91 | 98 |
new TablePackageInfo[infos.size()]); |
92 | 99 |
sortInstallerInfos(); |
93 | 100 |
|
... | ... | |
100 | 107 |
} |
101 | 108 |
|
102 | 109 |
private void sortInstallerInfos() { |
103 |
Arrays.sort(this.installerInfos, new Comparator<TablePackageInfo>() {
|
|
110 |
Arrays.sort(currentlyVisiblePackages, new Comparator<TablePackageInfo>() {
|
|
104 | 111 |
|
105 | 112 |
public int compare(TablePackageInfo o1, TablePackageInfo o2) { |
106 | 113 |
return o1.getPackageInfo().getName().compareToIgnoreCase( |
... | ... | |
109 | 116 |
}); |
110 | 117 |
} |
111 | 118 |
|
112 |
private Map<String, TablePackageInfo> getDefaultPackages() {
|
|
119 |
private Map<String, TablePackageInfo> getDefaultPackages() {
|
|
113 | 120 |
|
114 |
List<String> defaultIDs = installerExecutionService |
|
115 |
.getDefaultSelectedPackagesIDs(); |
|
121 |
if (allPackages == null) { |
|
116 | 122 |
|
117 |
Map<String, TablePackageInfo> infos = new HashMap<String, TablePackageInfo>(); |
|
118 |
// Add installable package infos |
|
119 |
for (int i = 0; i < installerExecutionService.getPackageCount(); i++) { |
|
120 |
PackageInfo installerInfo = installerExecutionService |
|
121 |
.getPackageInfo(i); |
|
122 |
TablePackageInfo info = new TablePackageInfo(installerInfo, false, |
|
123 |
true); |
|
124 |
if (defaultIDs != null) { |
|
125 |
for (int j = 0; j < defaultIDs.size(); j++) { |
|
126 |
if (info.getPackageInfo().matchID(defaultIDs.get(j))) { |
|
127 |
if (info.getPackageInfo().getOperatingSystem().equals( |
|
128 |
installerManager.getOperatingSystem()) |
|
129 |
|| info.getPackageInfo().getOperatingSystem() |
|
130 |
.equals("all")) { |
|
131 |
info.setDefault(true); |
|
132 |
break; |
|
133 |
} |
|
123 |
List<String> defaultIDs = |
|
124 |
installerExecutionService.getDefaultSelectedPackagesIDs(); |
|
134 | 125 |
|
135 |
} |
|
136 |
} |
|
137 |
} |
|
138 |
infos.put(info.getID(), info); |
|
139 |
} |
|
140 |
// Add already installed package infos |
|
141 |
try { |
|
142 |
PackageInfo[] installedPackages = installerManager |
|
143 |
.getInstalledPackages(); |
|
126 |
allPackages = |
|
127 |
new HashMap<String, PackagesTableModel.TablePackageInfo>(); |
|
144 | 128 |
|
145 |
for (int i = 0; i < installedPackages.length; i++) { |
|
146 |
TablePackageInfo info = new TablePackageInfo( |
|
147 |
installedPackages[i], true, false); |
|
148 |
TablePackageInfo x = infos.get(info.getID()); |
|
149 |
if (x == null) { |
|
150 |
infos.put(info.getID(), info); |
|
151 |
} else { |
|
152 |
x.setInstalled(true); |
|
153 |
} |
|
154 |
} |
|
155 |
} catch (MakePluginPackageServiceException e) { |
|
156 |
throw new RuntimeException(e); |
|
157 |
} |
|
129 |
// Add installable package infos |
|
130 |
for (int i = 0; i < installerExecutionService.getPackageCount(); i++) { |
|
131 |
PackageInfo installerInfo = |
|
132 |
installerExecutionService.getPackageInfo(i); |
|
133 |
TablePackageInfo info = |
|
134 |
new TablePackageInfo(installerInfo, false, true); |
|
135 |
if (defaultIDs != null) { |
|
136 |
for (int j = 0; j < defaultIDs.size(); j++) { |
|
137 |
if (info.getPackageInfo().matchID(defaultIDs.get(j))) { |
|
138 |
if (info.getPackageInfo().getOperatingSystem() |
|
139 |
.equals(installerManager.getOperatingSystem()) |
|
140 |
|| info.getPackageInfo().getOperatingSystem() |
|
141 |
.equals("all")) { |
|
142 |
info.setDefault(true); |
|
143 |
break; |
|
144 |
} |
|
158 | 145 |
|
159 |
return infos; |
|
160 |
} |
|
146 |
} |
|
147 |
} |
|
148 |
} |
|
149 |
allPackages.put(info.getID(), info); |
|
150 |
} |
|
151 |
// Add already installed package infos |
|
152 |
try { |
|
153 |
PackageInfo[] installedPackages = |
|
154 |
installerManager.getInstalledPackages(); |
|
161 | 155 |
|
156 |
for (int i = 0; i < installedPackages.length; i++) { |
|
157 |
TablePackageInfo info = |
|
158 |
new TablePackageInfo(installedPackages[i], true, false); |
|
159 |
TablePackageInfo x = allPackages.get(info.getID()); |
|
160 |
if (x == null) { |
|
161 |
allPackages.put(info.getID(), info); |
|
162 |
} else { |
|
163 |
x.setInstalled(true); |
|
164 |
} |
|
165 |
} |
|
166 |
} catch (MakePluginPackageServiceException e) { |
|
167 |
throw new RuntimeException(e); |
|
168 |
} |
|
169 |
|
|
170 |
// ========================================== |
|
171 |
// Set default |
|
172 |
|
|
173 |
TablePackageInfo tpi = null; |
|
174 |
String os = null; |
|
175 |
List<String> idList = installerExecutionService |
|
176 |
.getDefaultSelectedPackagesIDs(); |
|
177 |
|
|
178 |
if (idList != null) { |
|
179 |
for (int i=0; i<idList.size(); i++) { |
|
180 |
|
|
181 |
tpi = getMatch(idList.get(i), allPackages); |
|
182 |
if (tpi != null) { |
|
183 |
os = tpi.getPackageInfo().getOperatingSystem(); |
|
184 |
if (os.equals(installerManager.getOperatingSystem()) |
|
185 |
|| os.equals("all")) { |
|
186 |
|
|
187 |
tpi.setDefault(true); |
|
188 |
} |
|
189 |
} |
|
190 |
} |
|
191 |
} |
|
192 |
} |
|
193 |
return allPackages; |
|
194 |
} |
|
195 |
|
|
196 |
private TablePackageInfo getMatch(String id, Map<String, TablePackageInfo> map) { |
|
197 |
|
|
198 |
Iterator<TablePackageInfo> iter = map.values().iterator(); |
|
199 |
TablePackageInfo item = null; |
|
200 |
while (iter.hasNext()) { |
|
201 |
item = iter.next(); |
|
202 |
if (item.getPackageInfo().matchID(id)) { |
|
203 |
return item; |
|
204 |
} |
|
205 |
} |
|
206 |
return null; |
|
207 |
} |
|
208 |
|
|
162 | 209 |
// get filtered packages |
163 | 210 |
private Map<String, TablePackageInfo> getFilteredPackages( |
164 | 211 |
Map<String, TablePackageInfo> packageInfos) { |
... | ... | |
213 | 260 |
infos = getFastFilteredPackages(infos); |
214 | 261 |
} |
215 | 262 |
|
216 |
for (int i = 0; i < installerInfos.length; i++) { |
|
217 |
TablePackageInfo installerInfo = infos.get(installerInfos[i] |
|
218 |
.getID()); |
|
219 |
if (installerInfo != null) { |
|
220 |
installerInfo.setSelected(installerInfos[i].isSelected()); |
|
221 |
} |
|
222 |
} |
|
223 |
|
|
224 |
installerInfos = infos.values().toArray( |
|
263 |
currentlyVisiblePackages = infos.values().toArray( |
|
225 | 264 |
new TablePackageInfo[infos.size()]); |
226 | 265 |
sortInstallerInfos(); |
266 |
} |
|
227 | 267 |
|
228 |
List<String> idList = installerExecutionService |
|
229 |
.getDefaultSelectedPackagesIDs(); |
|
230 | 268 |
|
231 |
if (idList != null) { |
|
232 |
for (int i = 0; i < installerInfos.length; i++) { |
|
233 |
for (int j = 0; j < idList.size(); j++) { |
|
234 |
if (installerInfos[i].getPackageInfo().matchID( |
|
235 |
idList.get(j))) { |
|
236 |
if (installerInfos[i].getPackageInfo() |
|
237 |
.getOperatingSystem().equals( |
|
238 |
installerManager.getOperatingSystem()) |
|
239 |
|| installerInfos[i].getPackageInfo() |
|
240 |
.getOperatingSystem().equals("all")) { |
|
241 |
installerInfos[i].setDefault(true); |
|
242 |
} |
|
243 |
} |
|
244 |
} |
|
245 |
} |
|
246 |
} |
|
247 |
} |
|
248 |
|
|
249 |
// selects default packages |
|
250 | 269 |
public void selectDefaultPackages() { |
251 |
for (int i = 0; i < installerInfos.length; i++) { |
|
252 |
if (installerInfos[i].isDefault()) { |
|
253 |
installerInfos[i].setSelected(true); |
|
254 |
} else { |
|
255 |
installerInfos[i].setSelected(false); |
|
256 |
} |
|
257 |
} |
|
270 |
|
|
271 |
Iterator<String> iter = allPackages.keySet().iterator(); |
|
272 |
TablePackageInfo tpi = null; |
|
273 |
while (iter.hasNext()) { |
|
274 |
|
|
275 |
tpi = allPackages.get(iter.next()); |
|
276 |
if (tpi.isDefault()) { |
|
277 |
tpi.setSelected(true); |
|
278 |
} |
|
279 |
} |
|
258 | 280 |
} |
259 | 281 |
|
260 | 282 |
public void selectPackage(PackageInfo pkg) { |
261 |
for (int i = 0; i < installerInfos.length; i++) { |
|
262 |
if (pkg.equals(installerInfos[i].getPackageInfo())) { |
|
263 |
installerInfos[i].setSelected(true); |
|
264 |
return; |
|
265 |
} |
|
266 |
} |
|
283 |
|
|
284 |
Iterator<String> iter = allPackages.keySet().iterator(); |
|
285 |
TablePackageInfo tpi = null; |
|
286 |
while (iter.hasNext()) { |
|
287 |
|
|
288 |
tpi = allPackages.get(iter.next()); |
|
289 |
if (pkg.equals(tpi.getPackageInfo())) { |
|
290 |
tpi.setSelected(true); |
|
291 |
return; |
|
292 |
} |
|
293 |
} |
|
267 | 294 |
} |
268 | 295 |
|
269 | 296 |
@Override |
... | ... | |
291 | 318 |
} |
292 | 319 |
|
293 | 320 |
public int getRowCount() { |
294 |
return installerInfos.length;
|
|
321 |
return currentlyVisiblePackages.length;
|
|
295 | 322 |
} |
296 | 323 |
|
297 | 324 |
public Object getValueAt(int rowIndex, int columnIndex) { |
298 |
TablePackageInfo tableInfo = installerInfos[rowIndex];
|
|
325 |
TablePackageInfo tableInfo = currentlyVisiblePackages[rowIndex];
|
|
299 | 326 |
PackageInfo installerInfo = tableInfo.getPackageInfo(); |
300 | 327 |
|
301 | 328 |
switch (columnIndex) { |
... | ... | |
326 | 353 |
*/ |
327 | 354 |
private PackageOsAndArchitecture checkPackageSystem(int rowIndex) { |
328 | 355 |
PackageOsAndArchitecture oSArch = new PackageOsAndArchitecture(); |
329 |
TablePackageInfo tableInfo = installerInfos[rowIndex];
|
|
356 |
TablePackageInfo tableInfo = currentlyVisiblePackages[rowIndex];
|
|
330 | 357 |
PackageInfo installerInfo = tableInfo.getPackageInfo(); |
331 | 358 |
oSArch.os = installerInfo.getOperatingSystem(); |
332 | 359 |
oSArch.arch = installerInfo.getArchitecture(); |
... | ... | |
337 | 364 |
* @return |
338 | 365 |
*/ |
339 | 366 |
private PackageStatus checkStatus(int rowIndex) { |
340 |
TablePackageInfo tableInfo = installerInfos[rowIndex];
|
|
367 |
TablePackageInfo tableInfo = currentlyVisiblePackages[rowIndex];
|
|
341 | 368 |
|
342 | 369 |
// TODO: checkboxes when a package is broken dont work correctly |
343 | 370 |
if (tableInfo.getPackageInfo().isBroken()) { |
... | ... | |
365 | 392 |
} |
366 | 393 |
|
367 | 394 |
private PackageOfficialRecommended checkOfficialRecommended(int rowIndex) { |
368 |
TablePackageInfo tableInfo = installerInfos[rowIndex];
|
|
395 |
TablePackageInfo tableInfo = currentlyVisiblePackages[rowIndex];
|
|
369 | 396 |
PackageInfo packageInfo = tableInfo.getPackageInfo(); |
370 | 397 |
|
371 | 398 |
if (packageInfo.isOfficial()) { |
372 |
if (installerInfos[rowIndex].isDefault()) {
|
|
399 |
if (currentlyVisiblePackages[rowIndex].isDefault()) {
|
|
373 | 400 |
return PackageOfficialRecommended.OFFICIAL_RECOMMENDED; |
374 | 401 |
} else { |
375 | 402 |
return PackageOfficialRecommended.OFFICIAL_NOT_RECOMMENDED; |
376 | 403 |
} |
377 | 404 |
} else { |
378 |
if (installerInfos[rowIndex].isDefault()) {
|
|
405 |
if (currentlyVisiblePackages[rowIndex].isDefault()) {
|
|
379 | 406 |
return PackageOfficialRecommended.NOT_OFFICIAL_RECOMMENDED; |
380 | 407 |
} else { |
381 | 408 |
return PackageOfficialRecommended.NOT_OFFICIAL_NOT_RECOMMENDED; |
... | ... | |
384 | 411 |
} |
385 | 412 |
|
386 | 413 |
public PackageInfo getPackageInfoAt(int rowIndex) { |
387 |
return installerInfos[rowIndex].getPackageInfo();
|
|
414 |
return currentlyVisiblePackages[rowIndex].getPackageInfo();
|
|
388 | 415 |
} |
389 | 416 |
|
390 | 417 |
public String getDescriptionAt(int rowIndex) { |
... | ... | |
405 | 432 |
|
406 | 433 |
@Override |
407 | 434 |
public boolean isCellEditable(int rowIndex, int columnIndex) { |
408 |
return (columnIndex == 0) && installerInfos[rowIndex].isInstallable();
|
|
435 |
return (columnIndex == 0) && currentlyVisiblePackages[rowIndex].isInstallable();
|
|
409 | 436 |
} |
410 | 437 |
|
411 | 438 |
@Override |
... | ... | |
413 | 440 |
|
414 | 441 |
if (columnIndex == 0) { |
415 | 442 |
PackageStatus status = (PackageStatus) aValue; |
416 |
TablePackageInfo tableInfo = installerInfos[rowIndex];
|
|
443 |
TablePackageInfo tableInfo = currentlyVisiblePackages[rowIndex];
|
|
417 | 444 |
switch (status) { |
418 | 445 |
case INSTALLED: |
419 | 446 |
case NOT_INSTALLED: |
... | ... | |
429 | 456 |
} |
430 | 457 |
|
431 | 458 |
public List<PackageInfo> getPackagesToInstall() { |
432 |
List<PackageInfo> packageInfosToInstall = new ArrayList<PackageInfo>(); |
|
433 |
for (int i = 0; i < installerInfos.length; i++) { |
|
434 |
TablePackageInfo tableInfo = installerInfos[i]; |
|
435 |
if (tableInfo.isSelected()) { |
|
436 |
packageInfosToInstall.add(tableInfo.getPackageInfo()); |
|
437 |
} |
|
438 |
} |
|
439 |
return packageInfosToInstall; |
|
459 |
|
|
460 |
List<PackageInfo> packageInfosToInstall = new ArrayList<PackageInfo>(); |
|
461 |
packageInfosToInstall.addAll(selectedPackages); |
|
462 |
return packageInfosToInstall; |
|
440 | 463 |
} |
441 | 464 |
|
442 | 465 |
public boolean hasAnyPackageSelected() { |
443 |
for (int i = 0; i < installerInfos.length; i++) { |
|
444 |
if (installerInfos[i].isSelected) { |
|
445 |
return true; |
|
446 |
} |
|
447 |
} |
|
448 |
return false; |
|
466 |
return (selectedPackages.size() > 0); |
|
449 | 467 |
} |
450 | 468 |
|
451 |
public static final class TablePackageInfo {
|
|
469 |
public final class TablePackageInfo { |
|
452 | 470 |
|
453 | 471 |
private final PackageInfo packageInfo; |
454 | 472 |
private boolean isInstalled; |
455 | 473 |
private final boolean isInstallable; |
456 |
private boolean isSelected; |
|
474 |
// private boolean isSelected;
|
|
457 | 475 |
private boolean isDefault; |
458 | 476 |
|
459 | 477 |
public TablePackageInfo(PackageInfo packageInfo, boolean isInstalled, |
460 | 478 |
boolean isInstallable) { |
461 |
this(packageInfo, isInstalled, isInstallable, false, false);
|
|
479 |
this(packageInfo, isInstalled, isInstallable, false); |
|
462 | 480 |
} |
463 | 481 |
|
464 | 482 |
public void setInstalled(boolean installed) { |
... | ... | |
466 | 484 |
} |
467 | 485 |
|
468 | 486 |
public TablePackageInfo(PackageInfo packageInfo, boolean isInstalled, |
469 |
boolean isInstallable, boolean isSelected, boolean isDefault) {
|
|
487 |
boolean isInstallable, boolean isDefault) { |
|
470 | 488 |
this.packageInfo = packageInfo; |
471 | 489 |
this.isInstalled = isInstalled; |
472 | 490 |
this.isInstallable = isInstallable; |
473 |
this.isSelected = isSelected; |
|
474 | 491 |
this.isDefault = isDefault; |
475 | 492 |
} |
476 | 493 |
|
... | ... | |
492 | 509 |
} |
493 | 510 |
|
494 | 511 |
public boolean isSelected() { |
495 |
return isSelected;
|
|
512 |
return selectedPackages.contains(packageInfo);
|
|
496 | 513 |
} |
497 | 514 |
|
498 | 515 |
public void setSelected(boolean isSelected) { |
499 |
this.isSelected = isSelected; |
|
516 |
if (isSelected) { |
|
517 |
selectedPackages.add(packageInfo); |
|
518 |
} else { |
|
519 |
selectedPackages.remove(packageInfo); |
|
520 |
} |
|
500 | 521 |
} |
501 | 522 |
|
502 | 523 |
public void setDefault(boolean isDefault) { |
... | ... | |
516 | 537 |
* the TablePackageInfo located in the given row |
517 | 538 |
*/ |
518 | 539 |
public TablePackageInfo getPackageInfo(int row) { |
519 |
return installerInfos[row];
|
|
540 |
return currentlyVisiblePackages[row];
|
|
520 | 541 |
} |
521 | 542 |
|
522 | 543 |
public void setFilter(PackageFilter filter) { |
Also available in: Unified diff