Unnamed: 0
int64 0
305k
| body
stringlengths 7
52.9k
| name
stringlengths 1
185
|
|---|---|---|
297,400
|
void (String representation) { this.str = representation; }
|
setRepresentation
|
297,401
|
String () { return str; }
|
toString
|
297,402
|
IParser (Format fmt, Comparator cmp, Comparator stringCmp, boolean ignoreCase, int modelIndex) { return new Parser(fmt, cmp, stringCmp, ignoreCase, modelIndex); }
|
createParser
|
297,403
|
Comparator<String> (boolean ignoreCase) { if (ignoreCase) { if (icStrComparator == null) { icStrComparator = String.CASE_INSENSITIVE_ORDER; } return icStrComparator; } if (strComparator == null) { strComparator = Comparator.naturalOrder(); } return strComparator; }
|
stringComparator
|
297,404
|
Format (Class<?> cl) { // for Strings, we just use null. Format fmt = basicFormats.get(cl); if (fmt == null) { if (cl == String.class) { fmt = new StringTypeFormat(); } else if (cl == Boolean.class) { fmt = new BooleanTypeFormat(); } else if (cl == Integer.class) { fmt = new IntegerTypeFormat(); } else if (cl == Long.class) { fmt = new LongTypeFormat(); } else if (cl == Short.class) { fmt = new ShortTypeFormat(); } else if (cl == Float.class) { fmt = new FloatTypeFormat(); } else if (cl == Double.class) { fmt = new DoubleTypeFormat(); } else if (cl == Byte.class) { fmt = new ByteTypeFormat(); } else if (cl == Character.class) { fmt = new CharacterTypeFormat(); } else if (cl == Date.class) { fmt = getDefaultDateFormat(); } if (fmt != null) { basicFormats.put(cl, fmt); } } return fmt; }
|
getBasicFormat
|
297,405
|
DateFormat () { String definition = FilterSettings.dateFormat; if (definition != null) { try { return new SimpleDateFormat(definition); } catch (Exception ex) { // return the basic format } } return DateFormat.getDateInstance(DateFormat.SHORT); }
|
getDefaultDateFormat
|
297,406
|
void (boolean set) { if (set) { JTable table = handler.getTable(); if (table != null) { if (listenedModel != null) { if (listenedModel == table.getModel()) { return; } setEnableTableModelEvents(false); } listenedModel = table.getModel(); listenedModel.addTableModelListener(this); } } else if (listenedModel != null) { listenedModel.removeTableModelListener(this); listenedModel = null; } }
|
setEnableTableModelEvents
|
297,407
|
int () { return model.getRowCount(); }
|
getModelRowCount
|
297,408
|
Format[] () { return formatters; }
|
getFormatters
|
297,409
|
IParserModel () { try { return parserModelClass.newInstance(); } catch (Exception ex) { throw new RuntimeException("Error creating parser model of type " + parserModelClass, ex); } }
|
newParserModel
|
297,410
|
String (String name, String defaultValue) { String ret = getString(name); return (ret == null) ? defaultValue : ret; }
|
getString
|
297,411
|
String (String name) { try { return System.getProperty(PROPERTIES_PREFIX + name); } catch (Exception ex) { return null; } }
|
getString
|
297,412
|
int (String name, int defaultValue) { String ret = getString(name); if (ret != null) { try { return Integer.parseInt(ret); } catch (Exception ex) { // return defaultValue } } return defaultValue; }
|
getInteger
|
297,413
|
Color (String name, Color defaultValue) { String prop = getString(name); if (prop != null) { try { return Color.decode(prop); } catch (Exception ex) { // return defaultValue } } return defaultValue; }
|
getColor
|
297,414
|
void (@Nullable RowFilter<?, ?> filter) { currentFilter = filter; RowSorter<?> sorter = getSorter(); if (sorter != null) { ((DefaultRowSorter)sorter).setRowFilter(filter); } }
|
setCurrentFilter
|
297,415
|
ChoicesHandler () { return choicesHandler; }
|
getChoicesHandler
|
297,416
|
boolean () { return filterOnUpdates; }
|
isFilterOnUpdates
|
297,417
|
void (boolean enable) { filterOnUpdates = enable; if (getSorter() != null) { ((DefaultRowSorter<?, ?>)getSorter()).setSortsOnUpdates(enable); } }
|
setFilterOnUpdates
|
297,418
|
boolean () { return choicesHandler instanceof AdaptiveChoicesHandler; }
|
isAdaptiveChoices
|
297,419
|
void (boolean enableAdaptiveChoices) { boolean reenable = false; if (choicesHandler != null) { if (enableAdaptiveChoices == isAdaptiveChoices()) { return; } enableNotifications(false); if (choicesHandler != null) { choicesHandler.setInterrupted(true); } reenable = true; } if (enableAdaptiveChoices) { choicesHandler = new AdaptiveChoicesHandler(this); } else { choicesHandler = new NonAdaptiveChoicesHandler(this); } if (reenable) { enableNotifications(true); } }
|
setAdaptiveChoices
|
297,420
|
void (FilterEditor editor) { AutoChoices autoChoices = editor.getAutoChoices(); if (autoChoices == AutoChoices.DISABLED) { editor.setChoices(editor.getCustomChoices()); } else { TableModel model = handler.getTable().getModel(); Class<?> c = model.getColumnClass(editor.getModelIndex()); boolean asEnum = c.equals(Boolean.class) || c.isEnum(); if (asEnum && (autoChoices != AutoChoices.ENUMS)) { editor.setAutoChoices(AutoChoices.ENUMS); } else if (!asEnum && (autoChoices == AutoChoices.ENUMS)) { editor.setAutoChoices(AutoChoices.DISABLED); } else if (asEnum) { Set choices = editor.getCustomChoices(); if (c.equals(Boolean.class)) { choices.add(true); choices.add(false); } else { Collections.addAll(choices, c.getEnumConstants()); } editor.setChoices(choices); } else { setChoicesFromModel(editor, model); } } }
|
initEditorChoices
|
297,421
|
void (FilterEditor editor, TableModel model) { editor.setChoices(modelExtract(editor, model, 0, model.getRowCount() - 1, editor.getCustomChoices())); }
|
setChoicesFromModel
|
297,422
|
Set (FilterEditor editor, TableModel model, int firstRow, int lastRow, Set fill) { return fill; }
|
modelExtract
|
297,423
|
void () { // recreate the filtersMap filtersMap.clear(); if (handler.getTable() != null) { for (FilterEditor fe : handler.getEditors()) { filtersMap.put(fe.getFilter(), fe); } // and the RowEntry Collection<FilterEditor> eds = handler.getEditors(); rowEntry = new RowEntry(handler.getTable().getModel(), eds.toArray(new FilterEditor[eds.size()])); } }
|
initialiseFiltersInfo
|
297,424
|
IFilterEditor (int modelColumn) { return (getColumnsController() == null) ? null : ((FilterColumnsControllerPanel)getColumnsController()).getFilterEditor(getTable().convertColumnIndexToView(modelColumn)); }
|
getFilterEditor
|
297,425
|
JTable () { return filtersHandler == null ? null : filtersHandler.getTable(); }
|
getTable
|
297,426
|
void (@Nullable JTable table) { filtersHandler.setTable(table); }
|
setTable
|
297,427
|
void (@Nullable JTable table) { filtersHandler.enableNotifications(false); super.installTable(table); filtersHandler.enableNotifications(true); }
|
installTable
|
297,428
|
void (boolean enable) { filtersHandler.setAdaptiveChoices(enable); }
|
setAdaptiveChoices
|
297,429
|
void () { getColumnsController().detach(); }
|
detachController
|
297,430
|
ColumnsControllerPanel () { JTable currentTable = Objects.requireNonNull(getTable()); return new TableFilterHeader.FilterColumnsControllerPanel(currentTable, getFont(), getForeground()); }
|
createColumnsController
|
297,431
|
FilterColumnPanel (int columnView) { boolean enabled = filtersHandler.isEnabled(); int columnModel = getTable().convertColumnIndexToModel(columnView); FilterEditor editor = createEditor(columnModel, enabled); FilterColumnPanel column = new FilterColumnPanel(getTableColumnModel().getColumn(columnView), editor); column.updateHeight(); getColumns().add(column); add(column); return column; }
|
createColumn
|
297,432
|
FilterEditor (int modelColumn, boolean enableIt) { FilterEditor ret = new FilterEditor(filtersHandler, modelColumn, getTable().getModel().getColumnClass(modelColumn)); ret.setMaxHistory(maxHistory); ret.setInstantFiltering(instantFilteringEnabled); ret.setAutoCompletion(autoCompletionEnabled); ret.getFilter().setEnabled(enableIt); filtersHandler.addFilterEditor(ret); return ret; }
|
createEditor
|
297,433
|
FilterEditor (int viewColumn) { return (getColumns().size() > viewColumn) ? ((FilterColumnPanel)getColumns().get(viewColumn)).editor : null; }
|
getFilterEditor
|
297,434
|
void () { // see the comment on columnAdded if ((--autoRun == 0)) { getTable(); handlerEnabled = null; updateHeight(); } filtersHandler.enableNotifications(true); }
|
updateColumns
|
297,435
|
void () { int h = 0; for (AdditionalPanel c : getColumns()) { h = Math.max(h, c.getMyHeight()); } myPreferredSize.height = h + filterRowHeightDelta; placeComponents(); repaint(); }
|
updateHeight
|
297,436
|
Dimension () { int count = getTableColumnModel().getColumnCount(); return new Dimension(0, (count == 0) ? 0 : (getColumns().get(0).getMyHeight() + filterRowHeightDelta)); }
|
computeMyPreferredSize
|
297,437
|
void () { if (editor != null) { filtersHandler.removeFilterEditor(editor); remove(editor); editor.getFilter().removeFilterObserver(this); for (IFilterHeaderObserver observer : observers) { observer.tableFilterEditorExcluded( TableFilterHeader.this, editor, getTableColumn()); } } getTableColumn().removePropertyChangeListener(this); }
|
detach
|
297,438
|
void () { setMyHeight(getPreferredSize().height); revalidate(); }
|
updateHeight
|
297,439
|
void (boolean set) { this.focusOnList = set; }
|
setFocusOnList
|
297,440
|
boolean () { return focusOnList; }
|
isFocusOnList
|
297,441
|
void (ChoiceRenderer cellRenderer) { renderer = cellRenderer; }
|
setUserRenderer
|
297,442
|
ChoiceRenderer () { return renderer; }
|
getUserRenderer
|
297,443
|
Component (Object value, int finalWidth, boolean focused) { setupRenderer(referenceList, value, -1, focused, false); width = finalWidth; showArrow = false; xDeltaBase = 0; return this; }
|
getCellRendererComponent
|
297,444
|
void (JList list, Object value, int index, boolean selected, boolean cellHasFocus) { inner = null; if (renderer != null) { try { inner = renderer.getRendererComponent(editor, value, selected); } catch (Exception ex) { // inner still null } } if (inner == null) { inner = defaultRenderer.getListCellRendererComponent(list, value, index, selected, cellHasFocus); } }
|
setupRenderer
|
297,445
|
boolean (Comparator choicesComparator, Comparator<String> stringComparator) { if (updateComparators(choicesComparator, stringComparator) || !renderedContent) { renderedContent = true; this.strComparator = stringComparator; clearContent(); return true; } return false; }
|
setRenderedContent
|
297,446
|
boolean (Format format, Comparator choicesComparator, Comparator<String> stringComparator) { if (stringComparator.equals(choicesComparator)) { choicesComparator = null; } boolean change = updateComparators(choicesComparator, stringComparator) || renderedContent; if (!change && (format != this.format)) { change = (this.format == null) || (format == null) || !this.format.equals(format); } if (change) { this.format = format; this.strComparator = stringComparator; renderedContent = false; clearContent(); } return change; }
|
setStringContent
|
297,447
|
void () { int currentSize = size; content.clear(); content.add(new Choice(CustomChoice.MATCH_ALL, null)); fireIntervalRemoved(this, size = 1, currentSize); }
|
clearContent
|
297,448
|
boolean (Collection addedContent, IChoicesParser parser) { boolean changed = false; for (Object o : addedContent) { String s = null; if (o == null) { o = CustomChoice.MATCH_EMPTY; } else if (!renderedContent && !(o instanceof CustomChoice)) { // if null, content is rendered, no need to handle strings s = (format == null) ? o.toString() : format.format(o); if (s.length() == 0) { o = CustomChoice.MATCH_EMPTY; } else { s = parser.escapeChoice(s); } } changed = content.add(new Choice(o, s)) || changed; } if (changed) { flatContent = null; alphaSortedContent = null; fireContentsChanged(this, 0, size = content.size()); } return changed; }
|
addContent
|
297,449
|
ChoiceMatch (Object hint) { String str = null; if (!renderedContent && (hint instanceof String)) { // is a string (what the user enters), but if there is a format, it // can correspond to an existing element. For example, the right // format being for a date "07/05/12", but the user enters // "7/5/12". In this case, we should automatically return the // updated string. For the time being, this conversion is not yet // made (requires changes on the EditorComponent, and side effects // must be checked...) str = (String) hint; hint = null; // for the time being, we } Choice choice = new Choice(hint, str); ChoiceMatch ret = new ChoiceMatch(); Choice match = (hint == null) ? null : content.floor(choice); if ((match != null) && match.equals(choice)) { flatContent(); // ensure that the positions are calculated ret.content = match.get(renderedContent); ret.index = match.idx; ret.exact = true; } else if (!renderedContent) { TreeSet<Choice> alphaContent = getAlphabeticallySortedContent(); Choice top = alphaContent.ceiling(choice); Choice low = alphaContent.floor(choice); int len = choice.str.length(); int clen = (top == null) ? -1 : ChoiceMatch.getMatchingLength(top.str, choice.str, strComparator); int flen = (low == null) ? -1 : ChoiceMatch.getMatchingLength(low.str, choice.str, strComparator); match = (clen > flen) ? top : low; ret.index = match.idx; ret.content = match.get(renderedContent); ret.len = Math.max(clen, flen); ret.exact = (match.str.length() == ret.len) && (len == 0 || ret.len > 0); } return ret; }
|
getBestMatch
|
297,450
|
String (String base, List<?> unsortedList) { int minLen = base.length(); int maxLen = Integer.MAX_VALUE; String ret = null; Iterator<Choice> it = getAlphabeticallySortedContent().tailSet( new Choice(base, base), true) .iterator(); Iterator<?> its = unsortedList.iterator(); while ((maxLen > minLen) && (it.hasNext() || its.hasNext())) { String s = it.hasNext() ? it.next().str : its.next().toString(); int match = ChoiceMatch.getMatchingLength(base, s, strComparator); if (match == minLen) { if (ret == null) { ret = s; maxLen = s.length(); } else { maxLen = Math.min(maxLen, ChoiceMatch.getMatchingLength(ret, s, strComparator)); } } } return (ret == null) ? "" : ret.substring(minLen, maxLen); }
|
getCompletion
|
297,451
|
TreeSet<Choice> () { if (alphaSortedContent == null) { flatContent(); // ensure we have the positions on the Choices alphaSortedContent = new TreeSet<>(new ChoiceTextComparator(strComparator)); alphaSortedContent.addAll(content); } return alphaSortedContent; }
|
getAlphabeticallySortedContent
|
297,452
|
Object[] () { if (flatContent == null) { int i = size; flatContent = new Object[size]; Iterator<Choice> it = content.descendingIterator(); while (i-- > 0) { flatContent[i] = it.next().index(i).get(renderedContent); } } return flatContent; }
|
flatContent
|
297,453
|
boolean (Comparator choicesComparator, Comparator<String> stringComparator) { boolean same = this.strComparator.equals(stringComparator); if (same){ if (choicesComparator==null){ same = this.contentComparator==null; } else { same = choicesComparator.equals(this.contentComparator); } } this.contentComparator = choicesComparator; this.strComparator = stringComparator; return !same; }
|
updateComparators
|
297,454
|
Comparator<String> () { return strComparator; }
|
getStringComparator
|
297,455
|
Choice (int position) { this.idx = position; return this; }
|
index
|
297,456
|
Object (boolean rendered) { return (rendered || (o instanceof CustomChoice)) ? o : str; }
|
get
|
297,457
|
void (List<Object> history) { this.lastAdded = null; this.shownHistory = history; this.history.clear(); if (!history.isEmpty()){ this.history.addAll(history.subList (0, Math.min(maxHistory, history.size()))); } }
|
initialize
|
297,458
|
List<Object> () { return new ArrayList<>(shownHistory); }
|
getShownHistory
|
297,459
|
void (Comparator<String> stringComparator) { if (this.stringComparator != stringComparator) { this.stringComparator = stringComparator; clear(); } }
|
setStringContent
|
297,460
|
int () { shownHistory = history; return shownHistory.size(); }
|
clearRestrictions
|
297,461
|
boolean (Object exclude) { int index = shownHistory.indexOf(exclude); if (index != -1) { if (shownHistory == history) { shownHistory = new ArrayList<>(history); } shownHistory.remove(index); fireIntervalAdded(this, index, index); return true; } return false; }
|
restrict
|
297,462
|
boolean (Object st) { // never add the passed element (which is now selected on the // editor). We will add it when the next element is passed boolean ret = false; boolean removed = history.remove(st); if ((maxHistory > 0) && (lastAdded != null) && (lastAdded.toString().length() > 0) && !lastAdded.equals(st)) { history.add(0, lastAdded); int size = history.size(); if (size > maxHistory) { history.remove(--size); removed = true; } else { ret = true; if (!removed) { fireIntervalAdded(this, 0, 0); } } } if (removed) { fireContentsChanged(this, 0, history.size()); ret = true; } lastAdded = st; shownHistory = history; return ret; }
|
add
|
297,463
|
boolean () { return shownHistory.isEmpty(); }
|
isEmpty
|
297,464
|
void () { int size = history.size(); if (size > 0) { history.clear(); shownHistory = history; fireIntervalRemoved(this, 0, size); } lastAdded = null; }
|
clear
|
297,465
|
void (int size) { maxHistory = size; int current = history.size(); if (current > size) { history.subList(size, current).clear(); shownHistory = history; fireContentsChanged(this, maxHistory, current); } }
|
setMaxHistory
|
297,466
|
int () { return maxHistory; }
|
getMaxHistory
|
297,467
|
List () { return history; }
|
getList
|
297,468
|
ChoiceMatch (Object hint) { ChoiceMatch ret = new ChoiceMatch(); if ((stringComparator != null) && (hint instanceof String strStart)) { int strLen = strStart.length(); int historyLen = shownHistory.size(); while (historyLen-- > 0) { Object content = shownHistory.get(historyLen); String str = content.toString(); int len = ChoiceMatch.getMatchingLength(strStart, str, stringComparator); if (((len > 0) && (len >= ret.len)) || (ret.len == 0)) { ret.content = content; ret.index = historyLen; ret.len = len; if ((len == strLen) && (str.length() == strLen)) { ret.exact = true; return ret; } } } } else { ret.index = shownHistory.indexOf(hint); if (ret.index != -1) { ret.exact = true; ret.content = hint; } } return ret; }
|
getClosestMatch
|
297,469
|
int (String a, String b, Comparator stringComparator) { int max = Math.min(a.length(), b.length()); for (int i = 0; i < max; i++) { char f = a.charAt(i); char s = b.charAt(i); if ((f != s) && (stringComparator.compare(String.valueOf(f), String.valueOf(s)) != 0)) { return i; } } return max; }
|
getMatchingLength
|
297,470
|
void (Object selection) { popupSelection(selection); }
|
choiceSelected
|
297,471
|
int () { return modelIndex; }
|
getModelIndex
|
297,472
|
IFilter () { return filter; }
|
getFilter
|
297,473
|
void () { popup.clearHistory(); setEditorContent(CustomChoice.MATCH_ALL); requestChoices(); }
|
resetFilter
|
297,474
|
void (Object content) { setEditorContent((content == null || "".equals(content)) ? CustomChoice.MATCH_ALL : content); }
|
setContent
|
297,475
|
Object () { return editor.getContent(); }
|
getContent
|
297,476
|
void (AutoChoices autoChoices) { if ((autoChoices != null) && (autoChoices != this.autoChoices)) { this.autoChoices = autoChoices; Object[] enums = modelClass.getEnumConstants(); if ((Boolean.class == modelClass) || ((enums != null) && (enums.length <= 8))) { setEditable(editor.isAutoCompletion() || (autoChoices == AutoChoices.DISABLED)); // the call to setEditable already invokes requestChoices setMaxHistory(0); } else { requestChoices(); } } }
|
setAutoChoices
|
297,477
|
AutoChoices () { return autoChoices; }
|
getAutoChoices
|
297,478
|
void (Set<CustomChoice> choices) { if ((choices == null) || choices.isEmpty()) { this.customChoices = null; } else { this.customChoices = new HashSet<>(choices); } requestChoices(); }
|
setCustomChoices
|
297,479
|
Set<CustomChoice> () { return (customChoices == null) ? new HashSet<>() : new HashSet<>(customChoices); }
|
getCustomChoices
|
297,480
|
void (boolean enable) { enabledUI = enable; setFilterEnabled(filter.isEnabled()); }
|
setUserInteractionEnabled
|
297,481
|
boolean () { return enabledUI; }
|
isUserInteractionEnabled
|
297,482
|
void (boolean editable) { if (getRenderer() == null) { editor.setTextMode(editable); requestChoices(); // escaping works now differently } }
|
setEditable
|
297,483
|
boolean () { return editor.isEditableContent(); }
|
isEditable
|
297,484
|
void (boolean set) { if (ignoreCase != set) { ignoreCase = set; formatOrComparatorUpdated(); } }
|
setIgnoreCase
|
297,485
|
boolean () { return ignoreCase; }
|
isIgnoreCase
|
297,486
|
void (Format format) { if (this.format != format) { this.format = format; // as bonus, override default Comparator for dates // if the instance is not a DateComparator, the user has set // its own comparator (perhaps has done it as well and it is // a DateComparator, but seems unlikely) if ((format != null) && (comparator instanceof DateComparator) && Date.class.isAssignableFrom(modelClass)) { setComparator(DateComparator.getDateComparator(format)); } else { formatOrComparatorUpdated(); } } }
|
setFormat
|
297,487
|
Format () { return format; }
|
getFormat
|
297,488
|
void (Comparator comparator) { // the comparator is used for sorting rendered choices, and for // comparison operations on the text parser if ((comparator != this.comparator) && (comparator != null)) { this.comparator = comparator; formatOrComparatorUpdated(); } }
|
setComparator
|
297,489
|
Comparator () { return comparator; }
|
getComparator
|
297,490
|
void (Comparator comparator) { this.choicesComparator = comparator; formatOrComparatorUpdated(); }
|
setChoicesComparator
|
297,491
|
Comparator () { return choicesComparator; }
|
getChoicesComparator
|
297,492
|
void (boolean enable) { editor.setAutoCompletion(enable); }
|
setAutoCompletion
|
297,493
|
boolean () { return editor.isAutoCompletion(); }
|
isAutoCompletion
|
297,494
|
void (boolean enable) { editor.setInstantFiltering(enable); }
|
setInstantFiltering
|
297,495
|
boolean () { return editor.isAllowedInstantVanishing(); }
|
isAllowedInstantVanishing
|
297,496
|
void (boolean enable) { editor.setAllowedInstantVanishing(enable); }
|
setAllowedInstantVanishing
|
297,497
|
boolean () { return editor.isInstantFiltering(); }
|
isInstantFiltering
|
297,498
|
void (int size) { popup.setMaxHistory(size); }
|
setMaxHistory
|
297,499
|
int () { return popup.getMaxHistory(); }
|
getMaxHistory
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.