svn-gvsig-desktop / trunk / org.gvsig.desktop / org.gvsig.desktop.library / 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 @ 43088
History | View | Annotate | Download (17.8 KB)
1 | 40560 | jjdelcerro | /**
|
---|---|---|---|
2 | * gvSIG. Desktop Geographic Information System.
|
||
3 | 40435 | jjdelcerro | *
|
4 | 40560 | jjdelcerro | * Copyright (C) 2007-2013 gvSIG Association.
|
5 | *
|
||
6 | 40435 | jjdelcerro | * This program is free software; you can redistribute it and/or
|
7 | * modify it under the terms of the GNU General Public License
|
||
8 | 40560 | jjdelcerro | * as published by the Free Software Foundation; either version 3
|
9 | 40435 | jjdelcerro | * of the License, or (at your option) any later version.
|
10 | 40560 | jjdelcerro | *
|
11 | 40435 | jjdelcerro | * 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 | 40560 | jjdelcerro | *
|
16 | 40435 | jjdelcerro | * 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 | 40560 | jjdelcerro | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
19 | 40435 | jjdelcerro | * MA 02110-1301, USA.
|
20 | 40560 | jjdelcerro | *
|
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 | 40435 | jjdelcerro | */
|
24 | /*
|
||
25 | * AUTHORS (In addition to CIT):
|
||
26 | * 2010 {Prodevelop} {Task}
|
||
27 | */
|
||
28 | |||
29 | package org.gvsig.installer.swing.impl.execution.panel.model; |
||
30 | |||
31 | import java.net.URL; |
||
32 | import java.util.ArrayList; |
||
33 | import java.util.Arrays; |
||
34 | import java.util.Comparator; |
||
35 | import java.util.HashMap; |
||
36 | import java.util.HashSet; |
||
37 | import java.util.Iterator; |
||
38 | import java.util.List; |
||
39 | import java.util.Map; |
||
40 | import java.util.Set; |
||
41 | |||
42 | import javax.swing.table.AbstractTableModel; |
||
43 | 42881 | jjdelcerro | import org.apache.commons.lang3.StringUtils; |
44 | 40435 | jjdelcerro | |
45 | import org.gvsig.installer.lib.api.InstallerLocator; |
||
46 | import org.gvsig.installer.lib.api.InstallerManager; |
||
47 | import org.gvsig.installer.lib.api.PackageInfo; |
||
48 | import org.gvsig.installer.lib.api.creation.MakePluginPackageServiceException; |
||
49 | import org.gvsig.installer.lib.api.execution.InstallPackageService; |
||
50 | import org.gvsig.installer.swing.api.SwingInstallerManager; |
||
51 | import org.gvsig.installer.swing.impl.execution.panel.filters.NameDescriptionOrCodeFilter; |
||
52 | import org.gvsig.installer.swing.impl.execution.panel.filters.PackageFilter; |
||
53 | 40923 | jjdelcerro | import org.gvsig.tools.packageutils.PackageManager; |
54 | 40937 | jjdelcerro | import org.slf4j.Logger; |
55 | import org.slf4j.LoggerFactory; |
||
56 | 40435 | jjdelcerro | |
57 | public class PackagesTableModel extends AbstractTableModel { |
||
58 | |||
59 | private static final long serialVersionUID = -454014676003979512L; |
||
60 | 40937 | jjdelcerro | private Logger logger = LoggerFactory.getLogger(PackagesTableModel.class); |
61 | 40435 | jjdelcerro | |
62 | public enum PackageStatus { |
||
63 | INSTALLED, NOT_INSTALLED, TO_REINSTALL, TO_INSTALL, INSTALLED_NOT_INSTALLABLE, BROKEN, INSTALLATION_NOT_AVAILABLE; |
||
64 | } |
||
65 | |||
66 | public enum PackageOfficialRecommended { |
||
67 | 43088 | jjdelcerro | OFFICIAL_NOT_RECOMMENDED, OFFICIAL_RECOMMENDED, COMMUNITY_RECOMMENDED, COMMUNITY_NOT_RECOMMENDED |
68 | 40435 | jjdelcerro | } |
69 | |||
70 | public class PackageOsAndArchitecture { |
||
71 | 42881 | jjdelcerro | public String osfamily; |
72 | public String osname; |
||
73 | public String osversion; |
||
74 | 40435 | jjdelcerro | public String arch; |
75 | 42881 | jjdelcerro | |
76 | public String getOperatingSystemId() { |
||
77 | if( StringUtils.isEmpty(osname)) {
|
||
78 | return osfamily;
|
||
79 | } |
||
80 | return osfamily + "-" + osname; |
||
81 | } |
||
82 | 40435 | jjdelcerro | } |
83 | |||
84 | //
|
||
85 | // public enum PackageOsAndArchitecture {
|
||
86 | // WINDOLS_32, WINDOLS_64, LINUX_32, LINUX_64, ALL, OTHER
|
||
87 | // }
|
||
88 | |||
89 | private TablePackageInfo[] currentlyVisiblePackages = null; |
||
90 | |||
91 | private final String[] columnNames; |
||
92 | |||
93 | private InstallerManager installerManager = InstallerLocator
|
||
94 | .getInstallerManager(); |
||
95 | private InstallPackageService installerExecutionService;
|
||
96 | |||
97 | boolean isOfficial;
|
||
98 | private NameDescriptionOrCodeFilter packageFastFilter = null; |
||
99 | private PackageFilter packageFilter = null; |
||
100 | |||
101 | private Set<PackageInfo> selectedPackages = new HashSet<PackageInfo>(); |
||
102 | private Map<String, TablePackageInfo> allPackages = null; |
||
103 | |||
104 | public PackagesTableModel(SwingInstallerManager swingInstallerManager,
|
||
105 | InstallPackageService installerExecutionService, boolean isOfficial) {
|
||
106 | |||
107 | this.installerExecutionService = installerExecutionService;
|
||
108 | this.isOfficial = isOfficial;
|
||
109 | |||
110 | Map<String, TablePackageInfo> infos = getDefaultPackages(); |
||
111 | |||
112 | currentlyVisiblePackages = infos.values().toArray( |
||
113 | new TablePackageInfo[infos.size()]);
|
||
114 | sortInstallerInfos(); |
||
115 | |||
116 | columnNames = new String[] { |
||
117 | "", // Check column |
||
118 | "", "", swingInstallerManager.getText("_name"), |
||
119 | swingInstallerManager.getText("_version"),
|
||
120 | swingInstallerManager.getText("_type") };
|
||
121 | |||
122 | } |
||
123 | |||
124 | private void sortInstallerInfos() { |
||
125 | Arrays.sort(currentlyVisiblePackages, new Comparator<TablePackageInfo>() { |
||
126 | |||
127 | public int compare(TablePackageInfo o1, TablePackageInfo o2) { |
||
128 | 40937 | jjdelcerro | PackageInfo p1 = o1.getPackageInfo(); |
129 | PackageInfo p2 = o2.getPackageInfo(); |
||
130 | String s1 = p1.getName() + "/" + p1.getVersion().fullFormat() + "/" + p1.getOperatingSystem() + "/" + p1.getArchitecture(); |
||
131 | String s2 = p2.getName() + "/" + p2.getVersion().fullFormat() + "/" + p2.getOperatingSystem() + "/" + p2.getArchitecture(); |
||
132 | return s1.compareToIgnoreCase(s2);
|
||
133 | 40435 | jjdelcerro | } |
134 | }); |
||
135 | } |
||
136 | |||
137 | 40937 | jjdelcerro | private boolean canSetAsDefault(List<String> defaultIDs, PackageInfo pkg) { |
138 | 42881 | jjdelcerro | String system_osfamily = installerManager.getOperatingSystemFamily();
|
139 | String system_arch = installerManager.getArchitecture();
|
||
140 | 40937 | jjdelcerro | String pkg_os = pkg.getOperatingSystem();
|
141 | String pkg_arch = pkg.getArchitecture();
|
||
142 | if (defaultIDs != null) { |
||
143 | for (int j = 0; j < defaultIDs.size(); j++) { |
||
144 | String code = defaultIDs.get(j);
|
||
145 | if (pkg.matchID(code)) {
|
||
146 | 42881 | jjdelcerro | if ( pkg.getOperatingSystemFamily().equals(system_osfamily) || pkg_os.equals(PackageManager.OS.ALL)) {
|
147 | if( PackageManager.ARCH.ALL.equalsIgnoreCase(pkg_arch) ) {
|
||
148 | return true; |
||
149 | } else if( system_arch.equalsIgnoreCase(pkg_arch) ) { |
||
150 | return true; |
||
151 | } |
||
152 | 40937 | jjdelcerro | } |
153 | } |
||
154 | } |
||
155 | } |
||
156 | logger.info("package '"+pkg.getCode()+"/"+pkg_os+"/"+pkg_arch+"' don't install as default."); |
||
157 | return false; |
||
158 | } |
||
159 | |||
160 | 40435 | jjdelcerro | private Map<String, TablePackageInfo> getDefaultPackages() { |
161 | |||
162 | if (allPackages == null) { |
||
163 | List<String> defaultIDs = |
||
164 | installerExecutionService.getDefaultSelectedPackagesIDs(); |
||
165 | allPackages = |
||
166 | new HashMap<String, PackagesTableModel.TablePackageInfo>(); |
||
167 | // Add installable package infos
|
||
168 | for (int i = 0; i < installerExecutionService.getPackageCount(); i++) { |
||
169 | PackageInfo installerInfo = |
||
170 | installerExecutionService.getPackageInfo(i); |
||
171 | TablePackageInfo info = |
||
172 | new TablePackageInfo(installerInfo, false, true); |
||
173 | 40937 | jjdelcerro | PackageInfo pkg = info.getPackageInfo(); |
174 | if( canSetAsDefault(defaultIDs, pkg) ) {
|
||
175 | info.setDefault(true);
|
||
176 | } |
||
177 | 40435 | jjdelcerro | allPackages.put(info.getID(), info); |
178 | } |
||
179 | // Add already installed package infos
|
||
180 | try {
|
||
181 | PackageInfo[] installedPackages =
|
||
182 | installerManager.getInstalledPackages(); |
||
183 | |||
184 | for (int i = 0; i < installedPackages.length; i++) { |
||
185 | TablePackageInfo info = |
||
186 | new TablePackageInfo(installedPackages[i], true, false); |
||
187 | TablePackageInfo x = allPackages.get(info.getID()); |
||
188 | if (x == null) { |
||
189 | allPackages.put(info.getID(), info); |
||
190 | } else {
|
||
191 | x.setInstalled(true);
|
||
192 | } |
||
193 | } |
||
194 | } catch (MakePluginPackageServiceException e) {
|
||
195 | throw new RuntimeException(e); |
||
196 | } |
||
197 | |||
198 | // ==========================================
|
||
199 | // Set default
|
||
200 | |||
201 | TablePackageInfo tpi = null;
|
||
202 | String os = null; |
||
203 | List<String> idList = installerExecutionService |
||
204 | .getDefaultSelectedPackagesIDs(); |
||
205 | |||
206 | if (idList != null) { |
||
207 | for (int i=0; i<idList.size(); i++) { |
||
208 | |||
209 | tpi = getMatch(idList.get(i), allPackages); |
||
210 | if (tpi != null) { |
||
211 | os = tpi.getPackageInfo().getOperatingSystem(); |
||
212 | if (os.equals(installerManager.getOperatingSystem())
|
||
213 | || os.equals("all")) {
|
||
214 | |||
215 | tpi.setDefault(true);
|
||
216 | } |
||
217 | } |
||
218 | } |
||
219 | } |
||
220 | } |
||
221 | return allPackages;
|
||
222 | } |
||
223 | |||
224 | private TablePackageInfo getMatch(String id, Map<String, TablePackageInfo> map) { |
||
225 | |||
226 | Iterator<TablePackageInfo> iter = map.values().iterator();
|
||
227 | TablePackageInfo item = null;
|
||
228 | while (iter.hasNext()) {
|
||
229 | item = iter.next(); |
||
230 | if (item.getPackageInfo().matchID(id)) {
|
||
231 | return item;
|
||
232 | } |
||
233 | } |
||
234 | return null; |
||
235 | } |
||
236 | |||
237 | // get filtered packages
|
||
238 | private Map<String, TablePackageInfo> getFilteredPackages( |
||
239 | Map<String, TablePackageInfo> packageInfos) { |
||
240 | |||
241 | Map<String, TablePackageInfo> infos = new HashMap<String, TablePackageInfo>(); |
||
242 | |||
243 | TablePackageInfo[] packs = packageInfos.values().toArray(
|
||
244 | new TablePackageInfo[infos.size()]);
|
||
245 | |||
246 | for (int i = 0; i < packs.length; i++) { |
||
247 | PackageInfo installerInfo = packs[i].getPackageInfo(); |
||
248 | |||
249 | if (packageFilter.match(installerInfo)) {
|
||
250 | TablePackageInfo info = packs[i]; |
||
251 | infos.put(installerInfo.getID(), info); |
||
252 | } |
||
253 | } |
||
254 | return infos;
|
||
255 | } |
||
256 | |||
257 | // get fast filtered packages (by name or description)
|
||
258 | private Map<String, TablePackageInfo> getFastFilteredPackages( |
||
259 | Map<String, TablePackageInfo> packageInfos) { |
||
260 | |||
261 | Map<String, TablePackageInfo> infos = new HashMap<String, TablePackageInfo>(); |
||
262 | |||
263 | TablePackageInfo[] packs = packageInfos.values().toArray(
|
||
264 | new TablePackageInfo[infos.size()]);
|
||
265 | |||
266 | for (int i = 0; i < packs.length; i++) { |
||
267 | PackageInfo installerInfo = packs[i].getPackageInfo(); |
||
268 | |||
269 | if (packageFastFilter.match(installerInfo)) {
|
||
270 | TablePackageInfo info = packs[i]; |
||
271 | infos.put(installerInfo.getID(), info); |
||
272 | } |
||
273 | } |
||
274 | return infos;
|
||
275 | } |
||
276 | |||
277 | public void updatePackages() { |
||
278 | |||
279 | Map<String, TablePackageInfo> infos = getDefaultPackages(); |
||
280 | |||
281 | // check if there is a filter set (category, type, etc)
|
||
282 | if (isPackageFilterSet()) {
|
||
283 | infos = getFilteredPackages(infos); |
||
284 | } |
||
285 | |||
286 | // check if there is any filter set (fastFilter)
|
||
287 | if (isFastFilterSet()) {
|
||
288 | infos = getFastFilteredPackages(infos); |
||
289 | } |
||
290 | |||
291 | currentlyVisiblePackages = infos.values().toArray( |
||
292 | new TablePackageInfo[infos.size()]);
|
||
293 | sortInstallerInfos(); |
||
294 | } |
||
295 | |||
296 | |||
297 | public void selectDefaultPackages() { |
||
298 | |||
299 | Iterator<String> iter = allPackages.keySet().iterator(); |
||
300 | TablePackageInfo tpi = null;
|
||
301 | while (iter.hasNext()) {
|
||
302 | |||
303 | tpi = allPackages.get(iter.next()); |
||
304 | if (tpi.isDefault()) {
|
||
305 | tpi.setSelected(true);
|
||
306 | } |
||
307 | } |
||
308 | } |
||
309 | |||
310 | public void selectPackage(PackageInfo pkg) { |
||
311 | |||
312 | Iterator<String> iter = allPackages.keySet().iterator(); |
||
313 | TablePackageInfo tpi = null;
|
||
314 | while (iter.hasNext()) {
|
||
315 | |||
316 | tpi = allPackages.get(iter.next()); |
||
317 | if (pkg.equals(tpi.getPackageInfo())) {
|
||
318 | tpi.setSelected(true);
|
||
319 | return;
|
||
320 | } |
||
321 | } |
||
322 | } |
||
323 | |||
324 | @Override
|
||
325 | public Class<?> getColumnClass(int columnIndex) { |
||
326 | switch (columnIndex) {
|
||
327 | case 0: |
||
328 | return PackageStatus.class;
|
||
329 | case 1: |
||
330 | return PackageOfficialRecommended.class;
|
||
331 | case 2: |
||
332 | return PackageOsAndArchitecture.class;
|
||
333 | default:
|
||
334 | return String.class; |
||
335 | } |
||
336 | } |
||
337 | |||
338 | public int getColumnCount() { |
||
339 | return columnNames.length;
|
||
340 | } |
||
341 | |||
342 | @Override
|
||
343 | public String getColumnName(int columnIndex) { |
||
344 | return columnIndex >= columnNames.length ? "" |
||
345 | : columnNames[columnIndex]; |
||
346 | } |
||
347 | |||
348 | public int getRowCount() { |
||
349 | return currentlyVisiblePackages.length;
|
||
350 | } |
||
351 | |||
352 | public Object getValueAt(int rowIndex, int columnIndex) { |
||
353 | TablePackageInfo tableInfo = currentlyVisiblePackages[rowIndex]; |
||
354 | PackageInfo installerInfo = tableInfo.getPackageInfo(); |
||
355 | |||
356 | switch (columnIndex) {
|
||
357 | case 0: |
||
358 | PackageStatus installStatus = checkStatus(rowIndex); |
||
359 | return installStatus;
|
||
360 | case 1: |
||
361 | PackageOfficialRecommended officialRecommended = checkOfficialRecommended(rowIndex); |
||
362 | return officialRecommended;
|
||
363 | case 2: |
||
364 | PackageOsAndArchitecture packageSystem = checkPackageSystem(rowIndex); |
||
365 | return packageSystem;
|
||
366 | case 3: |
||
367 | return installerInfo.getName();
|
||
368 | case 4: |
||
369 | return installerInfo.getVersion();
|
||
370 | case 5: |
||
371 | return installerInfo.getType();
|
||
372 | default:
|
||
373 | return ""; |
||
374 | |||
375 | } |
||
376 | } |
||
377 | |||
378 | /**
|
||
379 | * @param rowIndex
|
||
380 | * @return
|
||
381 | */
|
||
382 | private PackageOsAndArchitecture checkPackageSystem(int rowIndex) { |
||
383 | PackageOsAndArchitecture oSArch = new PackageOsAndArchitecture();
|
||
384 | TablePackageInfo tableInfo = currentlyVisiblePackages[rowIndex]; |
||
385 | PackageInfo installerInfo = tableInfo.getPackageInfo(); |
||
386 | 42881 | jjdelcerro | oSArch.osfamily = installerInfo.getOperatingSystemFamily(); |
387 | oSArch.osname = installerInfo.getOperatingSystemName(); |
||
388 | oSArch.osversion = installerInfo.getOperatingSystemVersion(); |
||
389 | 40435 | jjdelcerro | oSArch.arch = installerInfo.getArchitecture(); |
390 | return oSArch;
|
||
391 | } |
||
392 | |||
393 | /**
|
||
394 | * @return
|
||
395 | */
|
||
396 | private PackageStatus checkStatus(int rowIndex) { |
||
397 | TablePackageInfo tableInfo = currentlyVisiblePackages[rowIndex]; |
||
398 | |||
399 | // TODO: checkboxes when a package is broken dont work correctly
|
||
400 | if (tableInfo.getPackageInfo().isBroken()) {
|
||
401 | return PackageStatus.BROKEN;
|
||
402 | } |
||
403 | |||
404 | if( !installerManager.hasProviderToThisPackage( tableInfo.getPackageInfo()) ) {
|
||
405 | return PackageStatus.INSTALLATION_NOT_AVAILABLE;
|
||
406 | } |
||
407 | |||
408 | if (tableInfo.isInstalled()) {
|
||
409 | if (tableInfo.isInstallable()) {
|
||
410 | if (tableInfo.isSelected()) {
|
||
411 | return PackageStatus.TO_REINSTALL;
|
||
412 | } else {
|
||
413 | return PackageStatus.INSTALLED;
|
||
414 | } |
||
415 | } else {
|
||
416 | return PackageStatus.INSTALLED_NOT_INSTALLABLE;
|
||
417 | } |
||
418 | |||
419 | } else {
|
||
420 | if (tableInfo.isSelected()) {
|
||
421 | return PackageStatus.TO_INSTALL;
|
||
422 | } else {
|
||
423 | return PackageStatus.NOT_INSTALLED;
|
||
424 | } |
||
425 | } |
||
426 | } |
||
427 | |||
428 | private PackageOfficialRecommended checkOfficialRecommended(int rowIndex) { |
||
429 | TablePackageInfo tableInfo = currentlyVisiblePackages[rowIndex]; |
||
430 | PackageInfo packageInfo = tableInfo.getPackageInfo(); |
||
431 | |||
432 | if (packageInfo.isOfficial()) {
|
||
433 | if (currentlyVisiblePackages[rowIndex].isDefault()) {
|
||
434 | return PackageOfficialRecommended.OFFICIAL_RECOMMENDED;
|
||
435 | } else {
|
||
436 | return PackageOfficialRecommended.OFFICIAL_NOT_RECOMMENDED;
|
||
437 | } |
||
438 | } else {
|
||
439 | if (currentlyVisiblePackages[rowIndex].isDefault()) {
|
||
440 | 43088 | jjdelcerro | return PackageOfficialRecommended.COMMUNITY_RECOMMENDED;
|
441 | 40435 | jjdelcerro | } else {
|
442 | 43088 | jjdelcerro | return PackageOfficialRecommended.COMMUNITY_NOT_RECOMMENDED;
|
443 | 40435 | jjdelcerro | } |
444 | } |
||
445 | } |
||
446 | |||
447 | public PackageInfo getPackageInfoAt(int rowIndex) { |
||
448 | return currentlyVisiblePackages[rowIndex].getPackageInfo();
|
||
449 | } |
||
450 | |||
451 | public String getDescriptionAt(int rowIndex) { |
||
452 | return getPackageInfoAt(rowIndex).getDescription();
|
||
453 | } |
||
454 | |||
455 | public URL getSourcesAt(int rowIndex) { |
||
456 | return getPackageInfoAt(rowIndex).getSourcesURL();
|
||
457 | } |
||
458 | |||
459 | public URL getOwnerUrlAt(int rowIndex) { |
||
460 | return getPackageInfoAt(rowIndex).getOwnerURL();
|
||
461 | } |
||
462 | |||
463 | public String getOwnerAt(int rowIndex) { |
||
464 | return getPackageInfoAt(rowIndex).getOwner();
|
||
465 | } |
||
466 | |||
467 | @Override
|
||
468 | public boolean isCellEditable(int rowIndex, int columnIndex) { |
||
469 | return (columnIndex == 0) && currentlyVisiblePackages[rowIndex].isInstallable(); |
||
470 | } |
||
471 | |||
472 | @Override
|
||
473 | public void setValueAt(Object aValue, int rowIndex, int columnIndex) { |
||
474 | |||
475 | if (columnIndex == 0) { |
||
476 | PackageStatus status = (PackageStatus) aValue; |
||
477 | TablePackageInfo tableInfo = currentlyVisiblePackages[rowIndex]; |
||
478 | switch (status) {
|
||
479 | case INSTALLED:
|
||
480 | case NOT_INSTALLED:
|
||
481 | tableInfo.setSelected(false);
|
||
482 | break;
|
||
483 | |||
484 | case TO_REINSTALL:
|
||
485 | case TO_INSTALL:
|
||
486 | tableInfo.setSelected(true);
|
||
487 | break;
|
||
488 | } |
||
489 | } |
||
490 | } |
||
491 | |||
492 | public List<PackageInfo> getPackagesToInstall() { |
||
493 | |||
494 | List<PackageInfo> packageInfosToInstall = new ArrayList<PackageInfo>(); |
||
495 | packageInfosToInstall.addAll(selectedPackages); |
||
496 | return packageInfosToInstall;
|
||
497 | } |
||
498 | |||
499 | public boolean hasAnyPackageSelected() { |
||
500 | return (selectedPackages.size() > 0); |
||
501 | } |
||
502 | |||
503 | public final class TablePackageInfo { |
||
504 | |||
505 | private final PackageInfo packageInfo; |
||
506 | private boolean isInstalled; |
||
507 | private final boolean isInstallable; |
||
508 | // private boolean isSelected;
|
||
509 | private boolean isDefault; |
||
510 | |||
511 | public TablePackageInfo(PackageInfo packageInfo, boolean isInstalled, |
||
512 | boolean isInstallable) {
|
||
513 | this(packageInfo, isInstalled, isInstallable, false); |
||
514 | } |
||
515 | |||
516 | public void setInstalled(boolean installed) { |
||
517 | this.isInstalled = installed;
|
||
518 | } |
||
519 | |||
520 | public TablePackageInfo(PackageInfo packageInfo, boolean isInstalled, |
||
521 | boolean isInstallable, boolean isDefault) { |
||
522 | this.packageInfo = packageInfo;
|
||
523 | this.isInstalled = isInstalled;
|
||
524 | this.isInstallable = isInstallable;
|
||
525 | this.isDefault = isDefault;
|
||
526 | } |
||
527 | |||
528 | public String getID() { |
||
529 | PackageInfo pkg = this.getPackageInfo();
|
||
530 | return pkg.getID();
|
||
531 | } |
||
532 | |||
533 | public PackageInfo getPackageInfo() {
|
||
534 | return packageInfo;
|
||
535 | } |
||
536 | |||
537 | public boolean isInstalled() { |
||
538 | return isInstalled;
|
||
539 | } |
||
540 | |||
541 | public boolean isInstallable() { |
||
542 | return isInstallable;
|
||
543 | } |
||
544 | |||
545 | public boolean isSelected() { |
||
546 | return selectedPackages.contains(packageInfo);
|
||
547 | } |
||
548 | |||
549 | public void setSelected(boolean isSelected) { |
||
550 | if (isSelected) {
|
||
551 | selectedPackages.add(packageInfo); |
||
552 | } else {
|
||
553 | selectedPackages.remove(packageInfo); |
||
554 | } |
||
555 | } |
||
556 | |||
557 | public void setDefault(boolean isDefault) { |
||
558 | this.isDefault = isDefault;
|
||
559 | } |
||
560 | |||
561 | public boolean isDefault() { |
||
562 | return isDefault;
|
||
563 | } |
||
564 | |||
565 | } |
||
566 | |||
567 | /**
|
||
568 | * Returns the TablePackageInfo located in the given row.
|
||
569 | *
|
||
570 | * @param row
|
||
571 | * the TablePackageInfo located in the given row
|
||
572 | */
|
||
573 | public TablePackageInfo getPackageInfo(int row) { |
||
574 | return currentlyVisiblePackages[row];
|
||
575 | } |
||
576 | |||
577 | public void setFilter(PackageFilter filter) { |
||
578 | this.packageFilter = filter;
|
||
579 | } |
||
580 | |||
581 | public void setFilter(NameDescriptionOrCodeFilter filter) { |
||
582 | this.packageFastFilter = filter;
|
||
583 | } |
||
584 | |||
585 | private Boolean isFastFilterSet() { |
||
586 | return this.packageFastFilter != null; |
||
587 | } |
||
588 | |||
589 | private Boolean isPackageFilterSet() { |
||
590 | return this.packageFilter != null; |
||
591 | } |
||
592 | |||
593 | public PackageFilter getFilter() {
|
||
594 | return this.packageFastFilter; |
||
595 | } |
||
596 | |||
597 | public InstallPackageService getInstallPackageService() {
|
||
598 | return this.installerExecutionService; |
||
599 | } |
||
600 | } |