private JPanel createDynamicCenterPanel(PrimitiveForm primitiveForm, DOTProperty property) {
final JTable theTable = new JTable();
PrimitiveFormPropertyPair pfpPair =
new PrimitiveFormPropertyPair(primitiveForm.getName(), property);
_dynamicTables.put(pfpPair, theTable);
DOTPoint dotPoint = (DOTPoint) _dotDefinitionDialogFrame.getScratchDisplayObjectType();
final DynamicDOTItemManager tableModel =
(DynamicDOTItemManager) dotPoint.getTableModel(primitiveForm, property);
theTable.setModel(tableModel);
class NumberComparator implements Comparator<Number> {
public int compare(Number o1, Number o2) {
final double d1 = o1.doubleValue();
final double d2 = o2.doubleValue();
if (d1 < d2) {
return -1;
}
if (d1 == d2) {
return 0;
}
return 1;
}
}
TableRowSorter<DynamicDOTItemManager> tableRowSorter =
new TableRowSorter<DynamicDOTItemManager>();
tableRowSorter.setModel(tableModel);
tableRowSorter.setComparator(4, new NumberComparator());
tableRowSorter.setComparator(5, new NumberComparator());
theTable.setRowSorter(tableRowSorter);
JButton newDOTItemButton = new JButton("Neue Zeile");
newDOTItemButton.setEnabled(_dotDefinitionDialogFrame.isEditable());
JButton deleteDOTItemButton = new JButton("Zeile löschen");
deleteDOTItemButton.setEnabled(false);
JButton showConflictsButton = new JButton("Zeige Konflikte");
addButtonListeners(
primitiveForm, property, newDOTItemButton, deleteDOTItemButton, showConflictsButton);
addListSelectionListener(theTable, deleteDOTItemButton);
JPanel dotButtonsPanel = new JPanel();
dotButtonsPanel.setLayout(new SpringLayout());
dotButtonsPanel.add(newDOTItemButton);
dotButtonsPanel.add(deleteDOTItemButton);
dotButtonsPanel.add(showConflictsButton);
dotButtonsPanel.setBorder(BorderFactory.createEmptyBorder(5, 10, 5, 10));
SpringUtilities.makeCompactGrid(dotButtonsPanel, 1, 5, 20);
JPanel thePanel = new JPanel();
thePanel.setLayout(new SpringLayout());
thePanel.setBorder(BorderFactory.createMatteBorder(2, 2, 2, 2, Color.BLACK));
thePanel.add(new JScrollPane(theTable));
thePanel.add(dotButtonsPanel);
SpringUtilities.makeCompactGrid(thePanel, 2, 20, 5);
return thePanel;
}
/**
* Handles the move put from a Client.
*
* @param params is a String array containing the blocks to place
*/
public void doMovePut(String[] params) {
Map<Point, Block> moves = new HashMap<>();
for (String move : params) {
String[] moveArg = move.split("@");
int blockId = Integer.parseInt(moveArg[0]);
int moveX = Integer.parseInt(moveArg[1].split(",")[0]);
int moveY = Integer.parseInt(moveArg[1].split(",")[1]);
moves.put(new Point(moveX, moveY), new Block(blockId));
}
try {
game.doMovePut(moves);
System.out.println("[Server] (ClientHandler) - Current game situation:");
System.out.println(game.getBoard().toString());
} catch (InvalidMoveException e) {
sendError(IProtocol.Error.MOVE_INVALID.ordinal() + " Invalid move");
game.sendPlayerTurn();
} catch (TilesUnownedException e) {
sendError(
IProtocol.Error.MOVE_TILES_UNOWNED.ordinal() + " Player tried to place unowned tile");
game.sendPlayerTurn();
} catch (NullPointerException e) {
System.out.println("[Server] ClientHandler - Game ended during turn.");
}
}
/** ***************************************************************************** */
BddtHistoryBubble(BddtLaunchControl ctrl, BddtHistoryData hd) {
history_data = hd;
for_control = ctrl;
history_graph = null;
last_update = 0;
update_needed = true;
restart_needed = true;
x_scale = 1;
y_scale = 1;
thread_colors = new HashMap<BumpThread, Color>();
type_strokes = new EnumMap<LinkType, Stroke>(LinkType.class);
type_strokes.put(
LinkType.ENTER,
new BasicStroke(1, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 1.0f, DOTTED, 0));
type_strokes.put(
LinkType.RETURN,
new BasicStroke(1, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 1.0f, DASHED, 0));
type_strokes.put(LinkType.NEXT, new BasicStroke(1));
arrow_stroke = new BasicStroke(1);
updateGraph();
hd.addHistoryListener(this);
setupPanel();
draw_area.addMouseListener(new FocusOnEntry());
}
public HierarchyBrowserBaseEx(@NotNull Project project, @NotNull PsiElement element) {
super(project);
setHierarchyBase(element);
myCardLayout = new CardLayout();
myTreePanel = new JPanel(myCardLayout);
createTrees(myType2TreeMap);
final HierarchyBrowserManager.State state =
HierarchyBrowserManager.getInstance(project).getState();
for (String type : myType2TreeMap.keySet()) {
myType2ScopeMap.put(type, state.SCOPE != null ? state.SCOPE : SCOPE_ALL);
}
final Enumeration<String> keys = myType2TreeMap.keys();
while (keys.hasMoreElements()) {
final String key = keys.nextElement();
final JTree tree = myType2TreeMap.get(key);
myOccurrenceNavigators.put(
key,
new OccurenceNavigatorSupport(tree) {
@Override
@Nullable
protected Navigatable createDescriptorForNode(DefaultMutableTreeNode node) {
final HierarchyNodeDescriptor descriptor = getDescriptor(node);
if (descriptor == null) return null;
PsiElement psiElement = getOpenFileElementFromDescriptor(descriptor);
if (psiElement == null || !psiElement.isValid()) return null;
final VirtualFile virtualFile = psiElement.getContainingFile().getVirtualFile();
if (virtualFile == null) return null;
return new OpenFileDescriptor(
psiElement.getProject(), virtualFile, psiElement.getTextOffset());
}
@Override
public String getNextOccurenceActionName() {
return getNextOccurenceActionNameImpl();
}
@Override
public String getPreviousOccurenceActionName() {
return getPrevOccurenceActionNameImpl();
}
});
myTreePanel.add(ScrollPaneFactory.createScrollPane(tree), key);
}
final JPanel legendPanel = createLegendPanel();
final JPanel contentPanel;
if (legendPanel != null) {
contentPanel = new JPanel(new BorderLayout());
contentPanel.add(myTreePanel, BorderLayout.CENTER);
contentPanel.add(legendPanel, BorderLayout.SOUTH);
} else {
contentPanel = myTreePanel;
}
buildUi(createToolbar(getActionPlace(), HELP_ID).getComponent(), contentPanel);
}
private GeoPoint[] sortPoints(GeoPoint... geoPoints) {
Map<GeoPoint, Integer> pointCount = new LinkedHashMap<GeoPoint, Integer>();
for (GeoPoint gp : geoPoints) {
if (pointCount.containsKey(gp)) {
pointCount.put(gp, pointCount.get(gp) + 1);
} else {
pointCount.put(gp, 1);
}
}
GeoPoint center = null;
GeoPoint end[] = new GeoPoint[2];
GeoPoint side[] = new GeoPoint[4];
int endIdx = 0;
int sieIdx = 0;
for (Map.Entry<GeoPoint, Integer> entry : pointCount.entrySet()) {
switch (entry.getValue()) {
case 4:
assert center == null;
center = entry.getKey();
break;
case 2:
assert endIdx < end.length;
end[endIdx++] = entry.getKey();
break;
case 1:
assert sieIdx < side.length;
side[sieIdx++] = entry.getKey();
break;
}
}
return new GeoPoint[] {center, end[0], side[0], side[1], end[1], side[3], side[2]};
}
static {
FONT_NAME_TO_STYLE.put("AnkaCoder-b", Font.BOLD);
FONT_NAME_TO_STYLE.put("AnkaCoder-i", Font.ITALIC);
FONT_NAME_TO_STYLE.put("AnkaCoder-bi", Font.BOLD | Font.ITALIC);
FONT_NAME_TO_STYLE.put("SourceCodePro-It", Font.ITALIC);
FONT_NAME_TO_STYLE.put("SourceCodePro-BoldIt", Font.BOLD | Font.ITALIC);
}
public void checkWarnings() {
highlightingTypes.put(
WARNING_MARKER, new ExpectedHighlightingSet(HighlightSeverity.WARNING, false, true));
highlightingTypes.put(
END_LINE_WARNING_MARKER,
new ExpectedHighlightingSet(HighlightSeverity.WARNING, true, true));
}
public void checkInfos() {
highlightingTypes.put(
INFO_MARKER, new ExpectedHighlightingSet(HighlightSeverity.INFORMATION, false, true));
highlightingTypes.put(
"inject",
new ExpectedHighlightingSet(HighlightInfoType.INJECTED_FRAGMENT_SEVERITY, false, true));
}
public GridImpl(ViewContextEx viewContext, String sessionName) {
myViewContext = viewContext;
mySessionName = sessionName;
Disposer.register(myViewContext, this);
Disposer.register(this, myTopSplit);
Placeholder left = new Placeholder();
myPlaceInGrid2Cell.put(
PlaceInGrid.left, new GridCellImpl(myViewContext, this, left, PlaceInGrid.left));
Placeholder center = new Placeholder();
myPlaceInGrid2Cell.put(
PlaceInGrid.center, new GridCellImpl(myViewContext, this, center, PlaceInGrid.center));
Placeholder right = new Placeholder();
myPlaceInGrid2Cell.put(
PlaceInGrid.right, new GridCellImpl(myViewContext, this, right, PlaceInGrid.right));
Placeholder bottom = new Placeholder();
myPlaceInGrid2Cell.put(
PlaceInGrid.bottom, new GridCellImpl(myViewContext, this, bottom, PlaceInGrid.bottom));
setContent(mySplitter);
setOpaque(false);
setFocusCycleRoot(true);
myTopSplit.setFirstComponent(left);
myTopSplit.setInnerComponent(center);
myTopSplit.setLastComponent(right);
myTopSplit.setMinSize(48);
mySplitter.setFirstComponent(myTopSplit);
mySplitter.setSecondComponent(bottom);
}
public IconListRenderer(Config config, TokenLabUI ui) throws IOException {
this.ui = ui;
this.config = config;
icons = new HashMap<Object, Icon>();
icons.put(OK, IconCreator.createImageIcon(CHECK_ICON, OK));
icons.put(NOTOK, IconCreator.createImageIcon(X_ICON, NOTOK));
}
{
cmdmap.put(
"sz",
new Console.Command() {
public void run(Console cons, String[] args) {
if (args.length == 3) {
int w = Integer.parseInt(args[1]), h = Integer.parseInt(args[2]);
p.setSize(w, h);
pack();
Utils.setprefc("wndsz", new Coord(w, h));
} else if (args.length == 2) {
if (args[1].equals("dyn")) {
setResizable(true);
Utils.setprefb("wndlock", false);
} else if (args[1].equals("lock")) {
setResizable(false);
Utils.setprefb("wndlock", true);
}
}
}
});
cmdmap.put(
"fsmode",
new Console.Command() {
public void run(Console cons, String[] args) throws Exception {
if (args.length == 3) {
DisplayMode mode = findmode(Integer.parseInt(args[1]), Integer.parseInt(args[2]));
if (mode == null) throw (new Exception("No such mode is available"));
fsmode = mode;
Utils.setprefc("fsmode", new Coord(mode.getWidth(), mode.getHeight()));
}
}
});
cmdmap.put(
"fs",
new Console.Command() {
public void run(Console cons, String[] args) {
if (args.length >= 2) {
Runnable r;
if (Utils.atoi(args[1]) != 0) {
r =
new Runnable() {
public void run() {
setfs();
}
};
} else {
r =
new Runnable() {
public void run() {
setwnd();
}
};
}
getToolkit().getSystemEventQueue().invokeLater(r);
}
}
});
}
/**
* Сохраняет размер фрейма
*
* @param className объект класса, размер фрейма которого нужно перезаписать
* @param size размер фрейма
*/
void updateSizeWindow(Class className, Dimension size) {
sizeWindows.put(className, size);
// Запысываем размер основного фрейма, так как при его закрытии происходит остановка приложения
sizeWindows.put(MainFrame.class, MonitoringMoney.mainFrame.getSize());
writeData();
}
/**
* Сохраняет координату фоейма
*
* @param className объект класса, позицию фрейма которого нужно перезаписать
* @param position координата фрейма
*/
void updateLocationWindow(Class className, Point position) {
locationWindows.put(className, position);
// Запысываем положение основного фрейма, так как при его закрытии происходит остановка
// приложения
locationWindows.put(MainFrame.class, MonitoringMoney.mainFrame.getLocation());
writeData();
}
static {
HEADING_LIST.put("H1 head line", 35);
HEADING_LIST.put("H2 head line", 30);
HEADING_LIST.put("H3 head line", 25);
HEADING_LIST.put("H4 head line", 20);
HEADING_LIST.put("H5 head line", 15);
HEADING_LIST.put("Paragraph", 10);
HEADING_LIST.put("Quote", 10);
}
private static void initIconTypeMap() {
ICON_TYPE_MAP = new HashMap<String, Integer>();
ICON_TYPE_MAP.put("gtk-menu", Integer.valueOf(1));
ICON_TYPE_MAP.put("gtk-small-toolbar", Integer.valueOf(2));
ICON_TYPE_MAP.put("gtk-large-toolbar", Integer.valueOf(3));
ICON_TYPE_MAP.put("gtk-button", Integer.valueOf(4));
ICON_TYPE_MAP.put("gtk-dnd", Integer.valueOf(5));
ICON_TYPE_MAP.put("gtk-dialog", Integer.valueOf(6));
}
private void setEnabled(IdeaPluginDescriptor ideaPluginDescriptor, final boolean enabled) {
final Collection<String> disabledPlugins = PluginManager.getDisabledPlugins();
final PluginId pluginId = ideaPluginDescriptor.getPluginId();
if (!enabled && !disabledPlugins.contains(pluginId.toString())) {
myEnabled.put(pluginId, null);
} else {
myEnabled.put(pluginId, enabled);
}
}
{
cursors.put(1, Cursor.N_RESIZE_CURSOR);
cursors.put(2, Cursor.W_RESIZE_CURSOR);
cursors.put(4, Cursor.S_RESIZE_CURSOR);
cursors.put(8, Cursor.E_RESIZE_CURSOR);
cursors.put(3, Cursor.NW_RESIZE_CURSOR);
cursors.put(9, Cursor.NE_RESIZE_CURSOR);
cursors.put(6, Cursor.SW_RESIZE_CURSOR);
cursors.put(12, Cursor.SE_RESIZE_CURSOR);
}
public NewBotDialog(DarkBotMCUI ui) {
super(ui);
this.ui = ui;
optionsUIs = new HashMap<String, BotOptionsUI>();
optionsUIs.put("Regular", new RegularBotOptionsUI());
optionsUIs.put("Spambot", new SpamBotOptionsUI());
initComponents();
updateSelectedBotType();
typeComboBox.setModel(new DefaultComboBoxModel(optionsUIs.keySet().toArray()));
setVisible(true);
}
private static Map<String, String> tubMachine() {
if (tubMachine == null) {
tubMachine = new HashMap<>();
tubMachine.put("T502", "Mixer-2201");
tubMachine.put("T503", "Mixer-2201");
tubMachine.put("T504", "Mixer-2201");
tubMachine.put("T101", "StarPress-2402");
tubMachine.put("T102", "StarPress-2402");
}
return tubMachine;
}
public void registerSeverity(@NotNull SeverityBasedTextAttributes info, Color renderColor) {
final HighlightSeverity severity = info.getType().getSeverity(null);
myMap.put(severity.getName(), info);
if (renderColor != null) {
myRendererColors.put(severity.getName(), renderColor);
}
myOrderMap = null;
HighlightDisplayLevel.registerSeverity(
severity, getHighlightInfoTypeBySeverity(severity).getAttributesKey());
severitiesChanged();
}
@Nullable
private FrameworkSupportNode createNode(
final FrameworkSupportInModuleProvider provider,
final Map<String, FrameworkSupportNode> nodes,
final Map<FrameworkGroup<?>, FrameworkGroupNode> groupNodes,
List<FrameworkSupportNodeBase> roots,
List<FrameworkSupportInModuleProvider> providers,
Set<String> associated,
Map<String, FrameworkSupportNodeBase> associatedNodes) {
String id = provider.getFrameworkType().getId();
FrameworkSupportNode node = nodes.get(id);
if (node != null || associatedNodes.containsKey(id)) {
return node;
}
String underlyingTypeId = provider.getFrameworkType().getUnderlyingFrameworkTypeId();
FrameworkSupportNodeBase parentNode = null;
final FrameworkGroup<?> group = provider.getFrameworkType().getParentGroup();
if (underlyingTypeId != null) {
FrameworkSupportInModuleProvider parentProvider =
FrameworkSupportUtil.findProvider(underlyingTypeId, providers);
if (parentProvider == null) {
LOG.info("Cannot find id = " + underlyingTypeId);
return null;
}
parentNode =
createNode(
parentProvider, nodes, groupNodes, roots, providers, associated, associatedNodes);
} else if (group != null) {
parentNode = groupNodes.get(group);
if (parentNode == null) {
FrameworkGroupNode groupNode = new FrameworkGroupNode(group, null);
if (associated.contains(groupNode.getId())) {
associatedNodes.put(groupNode.getId(), groupNode);
} else {
groupNodes.put(group, groupNode);
parentNode = groupNode;
roots.add(groupNode);
}
}
}
node = new FrameworkSupportNode(provider, parentNode, myModel, this);
if (associated.contains(id)) {
associatedNodes.put(id, node);
} else {
nodes.put(id, node);
if (parentNode == null) {
roots.add(node);
}
}
return node;
}
protected void initFonts() {
String editorFontName = getEditorFontName();
int editorFontSize = getEditorFontSize();
myFallbackFontName =
FontPreferences.getFallbackName(editorFontName, editorFontSize, myParentScheme);
if (myFallbackFontName != null) {
editorFontName = myFallbackFontName;
}
Font plainFont = new Font(editorFontName, Font.PLAIN, editorFontSize);
Font boldFont = new Font(editorFontName, Font.BOLD, editorFontSize);
Font italicFont = new Font(editorFontName, Font.ITALIC, editorFontSize);
Font boldItalicFont = new Font(editorFontName, Font.BOLD | Font.ITALIC, editorFontSize);
myFonts.put(EditorFontType.PLAIN, plainFont);
myFonts.put(EditorFontType.BOLD, boldFont);
myFonts.put(EditorFontType.ITALIC, italicFont);
myFonts.put(EditorFontType.BOLD_ITALIC, boldItalicFont);
String consoleFontName = getConsoleFontName();
int consoleFontSize = getConsoleFontSize();
Font consolePlainFont = new Font(consoleFontName, Font.PLAIN, consoleFontSize);
Font consoleBoldFont = new Font(consoleFontName, Font.BOLD, consoleFontSize);
Font consoleItalicFont = new Font(consoleFontName, Font.ITALIC, consoleFontSize);
Font consoleBoldItalicFont =
new Font(consoleFontName, Font.BOLD | Font.ITALIC, consoleFontSize);
myFonts.put(EditorFontType.CONSOLE_PLAIN, consolePlainFont);
myFonts.put(EditorFontType.CONSOLE_BOLD, consoleBoldFont);
myFonts.put(EditorFontType.CONSOLE_ITALIC, consoleItalicFont);
myFonts.put(EditorFontType.CONSOLE_BOLD_ITALIC, consoleBoldItalicFont);
}
private String setup(
String text,
boolean isDisabled,
boolean isStrikeout,
Color background,
@Nullable TextRange range) {
Map<TextRange, ParameterInfoUIContextEx.Flag> flagsMap = new TreeMap<>(TEXT_RANGE_COMPARATOR);
if (range != null) flagsMap.put(range, ParameterInfoUIContextEx.Flag.HIGHLIGHT);
if (isDisabled)
flagsMap.put(TextRange.create(0, text.length()), ParameterInfoUIContextEx.Flag.DISABLE);
if (isStrikeout)
flagsMap.put(TextRange.create(0, text.length()), ParameterInfoUIContextEx.Flag.STRIKEOUT);
return setup(text, flagsMap, background);
}
public static ColorSampleLookupValue[] getColors() {
if (ourColors == null) {
synchronized (ColorSampleLookupValue.class) {
if (ourColors == null) {
ourColorNameToHexCodeMap = new HashMap<String, String>(25);
ourHexCodeToColorNameMap = new HashMap<String, String>(25);
List<ColorSampleLookupValue> colorsList = new LinkedList<ColorSampleLookupValue>();
StringTokenizer tokenizer = new StringTokenizer(systemColorsString, "\n");
while (tokenizer.hasMoreTokens()) {
String name = tokenizer.nextToken();
colorsList.add(new ColorSampleLookupValue(name, name, false));
tokenizer.nextToken();
}
tokenizer = new StringTokenizer(standardColorsString, ", \n");
HashMap<String, String> standardColors = new HashMap<String, String>();
while (tokenizer.hasMoreTokens()) {
String name = tokenizer.nextToken();
String value = tokenizer.nextToken();
standardColors.put(name, name);
ourColorNameToHexCodeMap.put(name, value);
ourHexCodeToColorNameMap.put(value, name);
colorsList.add(new ColorSampleLookupValue(name, value, true));
}
tokenizer = new StringTokenizer(colorsString, " \t\n");
while (tokenizer.hasMoreTokens()) {
String name = tokenizer.nextToken();
String hexValue = tokenizer.nextToken();
tokenizer.nextToken(); // skip rgb
if (!standardColors.containsKey(name)) {
colorsList.add(new ColorSampleLookupValue(name, hexValue, false));
ourColorNameToHexCodeMap.put(name, hexValue);
ourHexCodeToColorNameMap.put(hexValue, name);
}
}
colorsList.toArray(ourColors = new ColorSampleLookupValue[colorsList.size()]);
}
}
}
return ourColors;
}
/**
* Tries to calculate given line's indent column assuming that there might be a comment at the
* given indent offset (see {@link #getCommentPrefix(IElementType)}).
*
* @param line target line
* @param indentOffset start indent offset to use for the given line
* @param lineEndOffset given line's end offset
* @param fallbackColumn column to return if it's not possible to apply comment-specific indent
* calculation rules
* @return given line's indent column to use
*/
private int calcIndent(int line, int indentOffset, int lineEndOffset, int fallbackColumn) {
final HighlighterIterator it = myEditor.getHighlighter().createIterator(indentOffset);
IElementType tokenType = it.getTokenType();
Language language = tokenType.getLanguage();
TokenSet comments = myComments.get(language);
if (comments == null) {
ParserDefinition definition = LanguageParserDefinitions.INSTANCE.forLanguage(language);
if (definition != null) {
comments = definition.getCommentTokens();
}
if (comments == null) {
return fallbackColumn;
} else {
myComments.put(language, comments);
}
}
if (comments.contains(tokenType) && indentOffset == it.getStart()) {
String prefix = COMMENT_PREFIXES.get(tokenType);
if (prefix == null) {
prefix = getCommentPrefix(tokenType);
}
if (!NO_COMMENT_INFO_MARKER.equals(prefix)) {
final int indentInsideCommentOffset =
CharArrayUtil.shiftForward(
myChars, indentOffset + prefix.length(), lineEndOffset, " \t");
if (indentInsideCommentOffset < lineEndOffset) {
int indent = myEditor.calcColumnNumber(indentInsideCommentOffset, line);
indentAfterUncomment.put(line, indent - prefix.length());
return indent;
}
}
}
return fallbackColumn;
}
/**
* ** Returns an I18N instance based on the specified package name and Locale ** @param pkgName
* The resource package name ** @param loc The Locale resource from with the localized text is
* loaded
*/
public static I18N getI18N(String pkgName, Locale loc) {
if (pkgName != null) {
loc = I18N.getLocale(loc);
/* get package map for specific Locale */
Map<String, I18N> packageMap = localeMap.get(loc);
if (packageMap == null) {
packageMap = new HashMap<String, I18N>();
localeMap.put(loc, packageMap);
}
/* get I18N instance for package */
I18N i18n = packageMap.get(pkgName);
if (i18n == null) {
i18n = new I18N(pkgName, loc);
packageMap.put(pkgName, i18n);
}
return i18n;
} else {
/* no package specified */
return null;
}
}
@NotNull
private InlineProgressIndicator createInlineDelegate(
@NotNull TaskInfo info, @NotNull ProgressIndicatorEx original, final boolean compact) {
final Collection<InlineProgressIndicator> inlines = myOriginal2Inlines.get(original);
if (inlines != null) {
for (InlineProgressIndicator eachInline : inlines) {
if (eachInline.isCompact() == compact) return eachInline;
}
}
final InlineProgressIndicator inline = new MyInlineProgressIndicator(compact, info, original);
myInline2Original.put(inline, original);
myOriginal2Inlines.put(original, inline);
if (compact) {
inline
.getComponent()
.addMouseListener(
new MouseAdapter() {
@Override
public void mousePressed(MouseEvent e) {
handle(e);
}
@Override
public void mouseReleased(MouseEvent e) {
handle(e);
}
});
}
return inline;
}
private synchronized void startAnimation(
JComponent component, Part part, State startState, State endState, long millis) {
boolean isForwardAndReverse = false;
if (endState == State.DEFAULTED) {
isForwardAndReverse = true;
}
Map<Part, AnimationState> map = animationStateMap.get(component);
if (millis <= 0) {
if (map != null) {
map.remove(part);
if (map.size() == 0) {
animationStateMap.remove(component);
}
}
return;
}
if (map == null) {
map = new EnumMap<Part, AnimationState>(Part.class);
animationStateMap.put(component, map);
}
map.put(part, new AnimationState(startState, millis, isForwardAndReverse));
if (!timer.isRunning()) {
timer.start();
}
}
public Map<String, ValidationResult.Option> getResult() {
Map<String, ValidationResult.Option> result = new HashMap<String, ValidationResult.Option>();
for (Item each : myItems) {
result.put(each.validationResult.path, each.option);
}
return result;
}
@Override
public void saveAllDocuments() {
ApplicationManager.getApplication().assertIsDispatchThread();
myMultiCaster.beforeAllDocumentsSaving();
if (myUnsavedDocuments.isEmpty()) return;
final Map<Document, IOException> failedToSave = new HashMap<Document, IOException>();
final Set<Document> vetoed = new HashSet<Document>();
while (true) {
int count = 0;
for (Document document : myUnsavedDocuments) {
if (failedToSave.containsKey(document)) continue;
if (vetoed.contains(document)) continue;
try {
doSaveDocument(document);
} catch (IOException e) {
//noinspection ThrowableResultOfMethodCallIgnored
failedToSave.put(document, e);
} catch (SaveVetoException e) {
vetoed.add(document);
}
count++;
}
if (count == 0) break;
}
if (!failedToSave.isEmpty()) {
handleErrorsOnSave(failedToSave);
}
}
