Sample

Schnappinger/argoUML/org.argouml.ui.cmd.ShortcutField

Human rating uses the original dataset scale.

Human4
Lines173

Scores

MethodScoreScaleDataset rank
(0–100)
Posnett00–1; higher is more readable
42.8Δ 50.6
Scalabrino0.760–1; higher is more readable
52.4Δ 41.0
Dorn0.3140–1; higher is more readable
48.5Δ 44.9
Mi0.5760–1; higher is more readable
53.1Δ 40.3
LLOC42Logical lines; fewer is more readable
42.1Δ 51.3
DeepSeek V4 Pro140–20; mean of three runs
29.9Δ 63.5
GPT-6.1 Sol150–20; mean of three runs
25.7Δ 67.7
BTTF0.3570–1; higher is more readable
28.7Δ 64.7
Human41–4; original rating
93.4

Views

Source code

/* $Id: ShortcutField.java 17842 2010-01-12 19:21:22Z linus $ ***************************************************************************** * Copyright (c) 2009 Contributors - see below * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at * http://www.eclipse.org/legal/epl-v10.html * * Contributors: * tfmorris ***************************************************************************** * * Some portions of this file was previously release using the BSD License: */ // Copyright (c) 2006-2007 The Regents of the University of California. All // Rights Reserved. Permission to use, copy, modify, and distribute this // software and its documentation without fee, and without a written // agreement is hereby granted, provided that the above copyright notice // and this paragraph appear in all copies. This software program and // documentation are copyrighted by The Regents of the University of // California. The software program and documentation are supplied "AS // IS", without any accompanying services from The Regents. The Regents // does not warrant that the operation of the program will be // uninterrupted or error-free. The end-user understands that the program // was developed for research purposes and is advised not to rely // exclusively on the program for any reason. IN NO EVENT SHALL THE // UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, // SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, // ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF // THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF // SUCH DAMAGE. THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE // PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF // CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT, // UPDATES, ENHANCEMENTS, OR MODIFICATIONS. package org.argouml.ui.cmd; import java.awt.KeyboardFocusManager; import java.awt.event.KeyEvent; import java.awt.event.KeyListener; import java.util.Collections; import javax.swing.JTextField; import javax.swing.KeyStroke; import javax.swing.event.EventListenerList; import org.argouml.util.KeyEventUtils; /** * A special JTextField that records key strokes * * @author nirux */ public class ShortcutField extends JTextField { /** * The UID */ private static final long serialVersionUID = -62483698420802557L; private EventListenerList listenerList = new EventListenerList(); /** * Main constructor for ShortcutField * * @param text the initial text of the field * @param columns the number of columns */ public ShortcutField(String text, int columns) { super(null, text, columns); // trap focus traversal keys also this.setFocusTraversalKeys( KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, Collections.EMPTY_SET); this.setFocusTraversalKeys( KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, Collections.EMPTY_SET); // let's add the key printing logic this.addKeyListener(new KeyListener() { private int currentKeyCode = 0; public void keyPressed(KeyEvent ke) { ke.consume(); JTextField tf = (JTextField) ke.getSource(); tf.setText(toString(ke)); } public void keyReleased(KeyEvent ke) { ke.consume(); JTextField tf = (JTextField) ke.getSource(); switch(currentKeyCode) { case KeyEvent.VK_ALT: case KeyEvent.VK_ALT_GRAPH: case KeyEvent.VK_CONTROL: case KeyEvent.VK_SHIFT: tf.setText(""); return; } } public void keyTyped(KeyEvent ke) { ke.consume(); } private String toString(KeyEvent ke) { currentKeyCode = ke.getKeyCode(); int keyCode = currentKeyCode; String modifText = KeyEventUtils.getModifiersText(ke.getModifiers()); if ("".equals(modifText)) { // no modifiers - let's check if the key is valid if (KeyEventUtils.isActionEvent(ke)) { return KeyEventUtils.getKeyText(keyCode); } else { return ""; } } else { switch(keyCode) { case KeyEvent.VK_ALT: case KeyEvent.VK_ALT_GRAPH: case KeyEvent.VK_CONTROL: case KeyEvent.VK_SHIFT: return modifText; // middle of shortcut default: modifText += KeyEventUtils.getKeyText(ke.getKeyCode()); fireShortcutChangedEvent(modifText); return modifText; } } } }); } /** * Adds a ShortcutChangedListener to the listener list * * @param listener the ShortcutChangedListener to be added */ public void addShortcutChangedListener(ShortcutChangedListener listener) { listenerList.add(ShortcutChangedListener.class, listener); } /** * Inform listeners of any shortcut notifications. * * @param text the text of the field */ protected void fireShortcutChangedEvent(String text) { ShortcutChangedEvent event = null; // Guaranteed to return a non-null array Object[] listeners = listenerList.getListenerList(); KeyStroke keyStroke = ShortcutMgr.decodeKeyStroke(text); // Process the listeners last to first, notifying // those that are interested in this event for (int i = listeners.length - 2; i >= 0; i -= 2) { if (listeners[i] == ShortcutChangedListener.class) { // Lazily create the event: if (event == null) { event = new ShortcutChangedEvent(this, keyStroke); } ((ShortcutChangedListener) listeners[i + 1]) .shortcutChange(event); } } } }

Loading feature diagnosis…

Source regions

Feature contributions

Feature contributions

FeatureValueContribution
(log-odds)
Halstead volumeHow much symbolic information the code contains. It combines the total number of operators and values with the number of distinct ones.3580.657−118.162
Source linesThe number of non-empty source lines.173+69.2
Byte entropyHow varied the bytes in the source text are. Repeated bytes give a lower value; a more even mixture gives a higher value.4.736−7.104

Intercept 8.87 + feature contributions = -47.195 (log-odds).
Score = sigmoid(-47.195) = 0.

Score0.76

Feature contributions

FeatureValueContribution
(log-odds)
Comment layout frequencyHow frequently the layout switches between lines containing only comments or whitespace and lines containing code.174−5.124
Indentation frequencyHow rapidly indentation changes from line to line.111+3.102
Number layout frequencyHow rapidly the number of numeric values per line changes through the code.111−2.126
Identifier layout (vertical)How rapidly the visual pattern of identifier characters changes from top to bottom.172.887+2.007
Operator visual areaThe share of the code’s visual area occupied by operators such as +, =, and *.0.042+0.53
Comment layout (horizontal)How rapidly the visual pattern of comment characters changes from left to right.77.19+0.441
Identifier layout (horizontal)How rapidly the visual pattern of identifier characters changes from left to right. It measures spatial frequency, not the meaning of the names.78.971+0.32

Intercept 0.07 + feature contributions = -0.78 (log-odds).
Score = sigmoid(-0.78) = 0.314.

Score0.576
Score42
Run 1

The code has a reasonable class structure with clear method separation, but it suffers from excessive copyright comments (around 50 lines) before the actual code, hurting readability. The constructor contains a large anonymous inner KeyListener class with multiple methods and logic, making it harder to follow. The toString method within the listener has nested conditionals and a switch statement, creating moderate nesting depth. Intent is mostly clear from method names, but the inline comments are sparse for the complex key handling logic. Some methods do multiple things per line, like the event firing logic, reducing readability. The reading flow is disrupted by the long constructor and anonymous class. Overall, it's maintainable but could be improved by extracting the KeyListener into a separate class, reducing comments, and breaking down complex methods.

Run 2

The code is well-structured with clear separation of concerns: field initialization, listener setup, and event firing. Nesting is reasonable—the anonymous KeyListener contains a switch statement but depth is manageable. Intent is clear from method names and comments; 'toString' inside the listener could be confusing but its behavior is consistent. Code length is slightly verbose due to legacy license headers but the logic itself is concise. Action granularity is mostly one action per line, though a few lines combine logic (e.g., keyCode assignment and currentKeyCode update). Reading flow is natural: constructor initializes components, adds listeners, then defines helper methods, followed by public API and event firing. The main weakness is the anonymous inner class containing multi-line formatting and slightly dense conditional logic in toString, but overall readability remains high.

Run 3

The code has a clear overall structure with logical class organization, but suffers from a large anonymous inner class that is overly long and contains nested logic. The keyPressed/keyReleased methods are concise, but the private toString() method has deep nesting and mixed concerns (formatting, validation, event firing). Action granularity is mostly one action per line, improving readability. The reading flow is disrupted by the monolithic constructor and the event listener implementation embedded within it. Redundant comments and excessive boilerplate (e.g. copyright headers) slightly reduce clarity. The event firing method is straightforward and well-named, but the listener logic is verbose. Overall, readable but could benefit from extracting the key handling logic into a separate named class and flattening nested conditional branches.

Run 1

Code Structure: The class logically separates initialization, listener registration, and event notification, but substantial shortcut-processing logic is embedded in an anonymous listener inside the constructor. Nesting: Mostly moderate, with deeper constructor/listener/method/conditional nesting and nested checks in notification dispatch. Clarity of intent: Descriptive class and method names and useful comments communicate the purpose; abbreviated variables such as ke, tf, and modifText and the stateful toString helper make details less obvious. Code length: Reasonably compact implementation, although repeated modifier-key cases and some redundant comments add verbosity. Action granularity: Statements generally perform one action per line, making operations easy to follow. Reading flow: Event handlers and public methods follow a coherent sequence, but the long constructor, inconsistent spacing, and interleaving of formatting, state updates, and event dispatch interrupt the flow.

Run 2

Code Structure: The class separates listener registration and notification cleanly, but embeds substantial keyboard-processing logic in an anonymous listener inside the constructor. Nesting: Mostly moderate, though the constructor, anonymous class, helper method, and conditional switches create several nested levels. Clarity of intent: Class documentation, descriptive event methods, and comments explain shortcut capture; however, the helper named toString, abbreviated variables, and shared currentKeyCode state require closer inspection. Code length: Reasonably compact implementation, with some redundant local variables and extensive license boilerplate increasing reading overhead. Action granularity: Statements generally perform one action per line, making individual operations easy to follow. Reading flow: Initialization, keyboard handling, and listener notification follow a logical sequence, but inconsistent whitespace and placing conversion plus event dispatch inside the same helper interrupt an otherwise clear flow.

Run 3

Code Structure: The class separates construction, listener registration, and notification logically, but embeds substantial shortcut-processing logic in an anonymous listener inside the constructor. Nesting: Mostly moderate, with deeper conditional and switch nesting in key conversion and event dispatch. Clarity of intent: Class documentation, descriptive APIs, and comments make the purpose clear; abbreviated names such as ke, tf, and modifText, plus the generic toString method name, reduce precision. Code length: Reasonably compact implementation, though lengthy license headers and some redundant comments slow scanning. Action granularity: Statements generally perform one action per line, making operations easy to follow. Reading flow: Consistent formatting and grouped event handlers support comprehension, but mutable currentKeyCode state shared across callbacks and event notification occurring inside string conversion require extra attention.