private void bindListeners() {
if (listener == null) {
listener = new Listeners();
model.addDataChangedListener(listener);
model.addSelectionListener(listener);
}
}
@Override
protected void doOKAction() {
apply((SeverityBasedTextAttributes) myOptionsList.getSelectedValue());
final Collection<SeverityBasedTextAttributes> infoTypes =
new HashSet<SeverityBasedTextAttributes>(
SeverityUtil.getRegisteredHighlightingInfoTypes(mySeverityRegistrar));
final ListModel listModel = myOptionsList.getModel();
final List<HighlightSeverity> order = new ArrayList<HighlightSeverity>();
for (int i = listModel.getSize() - 1; i >= 0; i--) {
final SeverityBasedTextAttributes info =
(SeverityBasedTextAttributes) listModel.getElementAt(i);
order.add(info.getSeverity());
if (!mySeverityRegistrar.isDefaultSeverity(info.getSeverity())) {
infoTypes.remove(info);
final Color stripeColor = info.getAttributes().getErrorStripeColor();
mySeverityRegistrar.registerSeverity(
info, stripeColor != null ? stripeColor : LightColors.YELLOW);
}
}
for (SeverityBasedTextAttributes info : infoTypes) {
mySeverityRegistrar.unregisterSeverity(info.getSeverity());
}
mySeverityRegistrar.setOrder(order);
super.doOKAction();
}
/**
* Initializes the contents of the dialog from the given font object.
*
* @param font the font from which to read the properties.
*/
public void setSelectedFont(final Font font) {
if (font == null) {
throw new NullPointerException();
}
this.boldCheck.setSelected(font.isBold());
this.italicCheck.setSelected(font.isItalic());
final String fontName = font.getName();
ListModel model = this.fontlist.getModel();
for (int i = 0; i < model.getSize(); i++) {
if (fontName.equals(model.getElementAt(i))) {
this.fontlist.setSelectedIndex(i);
break;
}
}
final String fontSize = String.valueOf(font.getSize());
model = this.sizelist.getModel();
for (int i = 0; i < model.getSize(); i++) {
if (fontSize.equals(model.getElementAt(i))) {
this.sizelist.setSelectedIndex(i);
break;
}
}
}
/**
* Returns an array of the values for the selected cells. The returned values are sorted in
* increasing index order.
*
* @return the selected values or an empty list if nothing is selected
* @see #isSelectedIndex
* @see #getModel
* @see #addListSelectionListener
*/
public Object[] getCheckBoxListSelectedValues() {
CheckBoxListSelectionModel listSelectionModel = getCheckBoxListSelectionModel();
ListModel model = getModel();
int iMin = listSelectionModel.getMinSelectionIndex();
int iMax = listSelectionModel.getMaxSelectionIndex();
if ((iMin < 0) || (iMax < 0)) {
return new Object[0];
}
Object[] temp = new Object[1 + (iMax - iMin)];
int n = 0;
for (int i = iMin; i <= iMax; i++) {
if (listSelectionModel.isAllEntryConsidered() && i == listSelectionModel.getAllEntryIndex()) {
continue;
}
if (listSelectionModel.isSelectedIndex(i)) {
temp[n] = model.getElementAt(i);
n++;
}
}
Object[] indices = new Object[n];
System.arraycopy(temp, 0, indices, 0, n);
return indices;
}
/**
* Returns the current/last selected item
*
* @return selected item or null
*/
public Object getSelectedItem() {
int i = model.getSelectedIndex();
if (i > -1) {
return model.getItemAt(i);
}
return null;
}
public static String print(ListModel model) {
StringBuilder result = new StringBuilder();
for (int i = 0; i < model.getSize(); i++) {
result.append(toString(model.getElementAt(i), null));
result.append("\n");
}
return result.toString();
}
void profileList_mouseClicked(MouseEvent e) {
JList theList = (JList) e.getSource();
ListModel aModel = theList.getModel();
int index = theList.locationToIndex(e.getPoint());
if (index < 0) return;
UniProfile aProfile = (UniProfile) aModel.getElementAt(index);
nameTextField.setText(aProfile.toString());
}
private void updateListHeight(ListModel model) {
myList.setFixedCellHeight(
myCellRenderer
.getListCellRendererComponent(myList, model.getElementAt(0), 0, false, false)
.getPreferredSize()
.height);
myList.setVisibleRowCount(
Math.min(model.getSize(), UISettings.getInstance().MAX_LOOKUP_LIST_HEIGHT));
}
public boolean fillInCommonPrefix(boolean explicitlyInvoked) {
if (explicitlyInvoked) {
setFocusDegree(FocusDegree.FOCUSED);
}
if (explicitlyInvoked && myCalculating) return false;
if (!explicitlyInvoked && mySelectionTouched) return false;
ListModel listModel = getListModel();
if (listModel.getSize() <= 1) return false;
if (listModel.getSize() == 0) return false;
final LookupElement firstItem = (LookupElement) listModel.getElementAt(0);
if (listModel.getSize() == 1 && firstItem instanceof EmptyLookupItem) return false;
final PrefixMatcher firstItemMatcher = itemMatcher(firstItem);
final String oldPrefix = firstItemMatcher.getPrefix();
final String presentPrefix = oldPrefix + getAdditionalPrefix();
String commonPrefix = getCaseCorrectedLookupString(firstItem);
for (int i = 1; i < listModel.getSize(); i++) {
LookupElement item = (LookupElement) listModel.getElementAt(i);
if (item instanceof EmptyLookupItem) return false;
if (!oldPrefix.equals(itemMatcher(item).getPrefix())) return false;
final String lookupString = getCaseCorrectedLookupString(item);
final int length = Math.min(commonPrefix.length(), lookupString.length());
if (length < commonPrefix.length()) {
commonPrefix = commonPrefix.substring(0, length);
}
for (int j = 0; j < length; j++) {
if (commonPrefix.charAt(j) != lookupString.charAt(j)) {
commonPrefix = lookupString.substring(0, j);
break;
}
}
if (commonPrefix.length() == 0 || commonPrefix.length() < presentPrefix.length()) {
return false;
}
}
if (commonPrefix.equals(presentPrefix)) {
return false;
}
for (int i = 0; i < listModel.getSize(); i++) {
LookupElement item = (LookupElement) listModel.getElementAt(i);
if (!itemMatcher(item).cloneWithPrefix(commonPrefix).prefixMatches(item)) {
return false;
}
}
myOffsets.setInitialPrefix(presentPrefix, explicitlyInvoked);
replacePrefix(presentPrefix, commonPrefix);
return true;
}
private void applyConstraint() {
filteredSize = 0;
ListModel filteredListModel = getFilteredModel();
for (int i = 0, size = filteredListModel.getSize(); i < size; i++) {
Object element = filteredListModel.getElementAt(i);
if (constraint.test(element)) {
indexes[filteredSize++] = i;
onMatchingElement(element);
}
}
postConstraintApplied();
}
public void OnManage() {
ListModel model = (ListModel) getWindow();
java.util.ArrayList<EntityModel> items = Linq.<EntityModel>Cast(model.getItems());
java.util.ArrayList<network> networks = Linq.<network>Cast(getItems());
if (getEntity() == null) {
Cancel();
return;
}
java.util.ArrayList<VdcActionParametersBase> prms1 =
new java.util.ArrayList<VdcActionParametersBase>();
for (EntityModel a : items) {
boolean value = false;
for (network b : networks) {
if (b.getId().equals(((network) a.getEntity()).getId())) {
value = true;
break;
}
}
if (a.getIsSelected() && !value) {
prms1.add(new AttachNetworkToVdsGroupParameter(getEntity(), (network) a.getEntity()));
}
}
// Call the command only if necessary (i.e. only if there are paramters):
if (prms1.size() > 0) {
Frontend.RunMultipleAction(VdcActionType.AttachNetworkToVdsGroup, prms1);
}
java.util.ArrayList<VdcActionParametersBase> prms2 =
new java.util.ArrayList<VdcActionParametersBase>();
for (EntityModel a : items) {
boolean value = true;
for (network b : networks) {
if (b.getId().equals(((network) a.getEntity()).getId())) {
value = false;
break;
}
}
if (!a.getIsSelected() && !value) {
prms2.add(new AttachNetworkToVdsGroupParameter(getEntity(), (network) a.getEntity()));
}
}
// Call the command only if necessary (i.e. only if there are paramters):
if (prms2.size() > 0) {
Frontend.RunMultipleAction(VdcActionType.DetachNetworkToVdsGroup, prms2);
}
Cancel();
}
private void showFailureDetail(Test test) {
if (test != null) {
ListModel failures = getFailures();
for (int i = 0; i < failures.getSize(); i++) {
TestFailure failure = (TestFailure) failures.getElementAt(i);
if (failure.failedTest() == test) {
fFailureView.showFailure(failure);
return;
}
}
}
fFailureView.clear();
}
/** Initialize the CheckBoxList. */
protected void init() {
_checkBoxListSelectionModel = createCheckBoxListSelectionModel(getModel());
setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
_listCellRenderer = createCellRenderer();
_handler = createHandler();
_checkBoxListSelectionModel.addListSelectionListener(_handler);
JideSwingUtilities.insertMouseListener(this, _handler, 0);
addKeyListener(_handler);
addPropertyChangeListener("model", _handler);
ListModel model = getModel();
if (model != null) {
model.addListDataListener(_handler);
}
}
/**
* Deselects the specified object from the list.
*
* @param anObject the object to select
* @param shouldScroll true if the list should scroll to display the selected object, if one
* exists; otherwise false
*/
public void removeCheckBoxListSelectedValue(Object anObject, boolean shouldScroll) {
if (anObject != null) {
int i, c;
ListModel model = getModel();
for (i = 0, c = model.getSize(); i < c; i++)
if (anObject.equals(model.getElementAt(i))) {
removeCheckBoxListSelectedIndex(i);
if (shouldScroll) ensureIndexIsVisible(i);
repaint();
/** FIX-ME setSelectedIndex does not redraw all the time with the basic l&f* */
return;
}
}
}
/** {@inheritDoc} */
public Object getPropertyValue(String name) {
if (name.equals("ListItems")) {
Object[] obj = new Object[model.getSize()];
int olen = obj.length;
for (int iter = 0; iter < olen; iter++) {
obj[iter] = model.getItemAt(iter);
}
return obj;
}
if (name.equals("Renderer")) {
return getRenderer();
}
return null;
}
/**/ boolean doSort(boolean ascending) {
final Comparator cmpr = ascending ? _sortAsc : _sortDsc;
if (cmpr == null) return false;
final Listbox box = getListbox();
if (box == null) return false;
// comparator might be zscript
Scopes.beforeInterpret(this);
try {
final ListModel model = box.getModel();
boolean isPagingMold = box.inPagingMold();
int activePg = isPagingMold ? box.getPaginal().getActivePage() : 0;
if (model != null) { // live data
if (model instanceof GroupsSortableModel) {
sortGroupsModel(box, (GroupsSortableModel) model, cmpr, ascending);
} else {
if (!(model instanceof Sortable))
throw new UiException(
GroupsSortableModel.class
+ " or "
+ Sortable.class
+ " must be implemented in "
+ model.getClass().getName());
sortListModel((Sortable) model, cmpr, ascending);
}
} else { // not live data
sort0(box, cmpr);
}
if (isPagingMold) box.getPaginal().setActivePage(activePg);
// Because of maintaining the number of the visible item, we cause
// the wrong active page when dynamically add/remove the item (i.e. sorting).
// Therefore, we have to reset the correct active page.
} finally {
Scopes.afterInterpret();
}
_ignoreSort = true;
// maintain
for (Iterator it = box.getListhead().getChildren().iterator(); it.hasNext(); ) {
final Listheader hd = (Listheader) it.next();
hd.setSortDirection(hd != this ? "natural" : ascending ? "ascending" : "descending");
}
_ignoreSort = false;
// sometimes the items at client side are out of date
box.invalidate();
return true;
}
@TestOnly
public boolean setSelectedTemplate(String group, String name) {
ListModel model = myProjectTypeList.getModel();
for (int i = 0; i < model.getSize(); i++) {
TemplatesGroup templatesGroup = (TemplatesGroup) model.getElementAt(i);
if (group.equals(templatesGroup.getName())) {
myProjectTypeList.setSelectedIndex(i);
if (name == null) return getSelectedGroup().getName().equals(group);
Collection<ProjectTemplate> templates = myTemplatesMap.get(templatesGroup);
setTemplatesList(templatesGroup, templates, false);
return myTemplatesList.setSelectedTemplate(name);
}
}
return false;
}
public void PostManage(java.util.ArrayList<network> networkList, ListModel model) {
Collections.sort(networkList, new Linq.NetworkByNameComparer());
java.util.ArrayList<EntityModel> items = new java.util.ArrayList<EntityModel>();
for (network a : networkList) {
if (!a.getname().equals("engine")) {
EntityModel tempVar = new EntityModel();
tempVar.setEntity(a);
tempVar.setTitle(a.getname());
items.add(tempVar);
}
}
model.setItems(items);
boolean noItems = items.isEmpty();
java.util.ArrayList<network> networks = Linq.<network>Cast(getItems());
java.util.ArrayList<EntityModel> selectedItems = new java.util.ArrayList<EntityModel>();
for (EntityModel item : items) {
network net = (network) item.getEntity();
boolean value = false;
for (network a : networks) {
if (a.getId().equals(net.getId())) {
value = true;
break;
}
}
item.setIsSelected(value);
if (value) {
selectedItems.add(item);
}
}
model.setSelectedItems(selectedItems);
UICommand tempVar2 = new UICommand("Cancel", this);
tempVar2.setTitle("Cancel");
tempVar2.setIsDefault(noItems);
tempVar2.setIsCancel(true);
model.getCommands().add(tempVar2);
if (!noItems) {
UICommand tempVar3 = new UICommand("OnManage", this);
tempVar3.setTitle("OK");
tempVar3.setIsDefault(true);
model.getCommands().add(0, tempVar3);
}
}
/**
* Sets the current selected offset in the list, by default this implementation will scroll the
* list to the selection if the selection is outside of the screen
*
* @param index the current selected offset in the list
*/
public void setSelectedIndex(int index) {
if (index < 0) {
throw new IllegalArgumentException("Selection index is negative:" + index);
}
getComponentAt(index).requestFocus();
model.setSelectedIndex(index);
}
/**
* Set the model for the container list
*
* @param model a model class that is mapped into the internal components
*/
public void setModel(ListModel model) {
if (this.model != null && listener != null) {
this.model.removeDataChangedListener(listener);
this.model.removeSelectionListener(listener);
listener = null;
}
this.model = model;
updateComponentCount();
if (model.getSelectedIndex() > 0) {
getComponentAt(model.getSelectedIndex()).requestFocus();
}
if (isInitialized()) {
bindListeners();
}
repaint();
}
/** {@inheritDoc} */
@Override
public List getRootNodes() {
if (rootModel != null) {
return rootModel.getList();
} else {
return null;
}
}
/** ********************************************************************** */
public void paintComponent(Graphics g) {
for (int i = 0; i < model.size(); i++) {
int y = i * cell_height;
if (y + cell_height < g.getClipY()) continue;
else if (y > g.getClipY() + g.getClipHeight()) break;
//
g.translate(0, y);
IComponent c =
renderer.getListCellRendererComponent(
this, model.elementAt(i), i, selection.isSelectedIndex(i), (rollover == i));
c.setBounds(0, 0, bounds.width, cell_height);
c.setFont(font);
c.setEnabled(enabled);
c.paint(g);
g.translate(0, -y);
}
}
/** {@inheritDoc} */
protected void initComponent() {
if (model != null) {
int i = model.getSelectedIndex();
if (i > 0) {
getComponentAt(i).requestFocus();
}
bindListeners();
}
}
public int compare(Object o1, Object o2) {
switch (nOrder) {
case BYSIZE:
break;
case BYDATE:
break;
case BYNAME:
default:
if (o1 instanceof FileInfo && o2 instanceof FileInfo) {
FileInfo file1 = (FileInfo) o1;
FileInfo file2 = (FileInfo) o2;
int t1 = ListModel.getType(file1), t2 = ListModel.getType(file2);
String s1 = ListModel.getFileName(file1), s2 = ListModel.getFileName(file2);
if (t1 != t2) {
if (FileInfo.DIRECTORY_TYPE == t1) {
return -1;
} else if (FileInfo.DIRECTORY_TYPE == t2) {
return 1;
} else if (FileInfo.SOFTLINK_TYPE == t1) {
return -1;
} else if (FileInfo.SOFTLINK_TYPE == t2) {
return 1;
} else if (FileInfo.FILE_TYPE == t1) {
return -1;
} else if (FileInfo.FILE_TYPE == t2) {
return 1;
} else if (FileInfo.UNKNOWN_TYPE == t1) {
return -1;
} else {
return 1;
}
} else {
if (s1.equals("..")) {
return -1;
} else if (s2.equals("..")) {
return 1;
}
return Collator.getInstance().compare(s1, s2);
}
}
break;
}
return 0;
}
private void update() {
if (filter == null || filter.length() == 0) {
super.setModel(originalModel);
}
DefaultListModel v = new DefaultListModel();
for (int i = 0; i < originalModel.getSize(); i++) {
Object o = originalModel.getElementAt(i);
String s = String.valueOf(o).toLowerCase();
if (s.contains(filter)) {
v.addElement(o);
}
}
super.setModel(v);
if (v.getSize() == 1) {
setSelectedIndex(0);
}
revalidate();
}
/**
* Deselects the specified objects from the list and keep all previous selections.
*
* @param objects the objects to be selected
*/
public void removeCheckBoxListSelectedValues(Object[] objects) {
if (objects != null) {
Map<Object, String> map = new HashMap<Object, String>();
for (Object o : objects) {
map.put(o, "");
}
int i, c;
ListModel model = getModel();
boolean changed = false;
for (i = 0, c = model.getSize(); i < c; i++)
if (map.get(model.getElementAt(i)) != null) {
removeCheckBoxListSelectedIndex(i);
changed = true;
}
if (changed) {
repaint();
}
map.clear();
}
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder holder = null;
if (convertView == null) {
convertView = inflater.inflate(R.layout.item, null);
holder = new ViewHolder(convertView);
convertView.setTag(holder);
} else {
holder = (ViewHolder) convertView.getTag();
}
int colorResId = position % 2 == 0 ? R.color.even : R.color.odd;
holder.text.setBackgroundColor(res.getColor(colorResId));
holder.text.setText(ListModel.getModelItem(position));
return convertView;
}
private void updateComponentCount() {
int cc = getComponentCount();
int modelCount = model.getSize();
if (cc != modelCount) {
if (cc < modelCount) {
for (int iter = cc; iter < modelCount; iter++) {
addComponent(new Entry(iter));
}
} else {
while (getComponentCount() > modelCount) {
removeComponent(getComponentAt(getComponentCount() - 1));
}
}
Form f = getComponentForm();
if (f != null) {
f.revalidate();
}
}
}
private void fillListModel(SortedListModel1 model, ListModel newValues) {
int size = newValues.getSize();
for (int i = 0; i < size; i++) {
model.add(newValues.getElementAt(i));
}
}
private void defaultNonOverriddenConfigurations() {
ListModel model = herolabsCharacterList.getModel();
for (int i = 0; i < model.getSize(); i++) {
config.populateCharacterWithDefaults(((Character) model.getElementAt(i)).getName(), false);
}
}
