Revision 1763

Date:
2007/10/06 12:47:06
Author:
karlo
Revision Log:
Worker-Progress mit Bytes und Abschätzung der Restzeit
Files:

Legend:

 
Added
 
Removed
 
Modified

  • branches/Branch-To-Release-1_4-Neu/src/net/sourceforge/cridmanager/cridmanager.properties

     
    106 106 # Anzahl Worker parallel
    107 107 global.workers.parallel=1
    108 108
    109 # Worker zeigt Byte-Fortschritt an
    110 global.workers.byteprogress=true
    111
    112 # Meldung für den Byte-Fortschritt
    113 global.workers.bytemessage= (%0% von %1%)
    114
    115 # Worker zeigt Geschwindigkeit an
    116 global.workers.speed=true
    117
    118 # Meldung für die Geschwindigkeit
    119 global.workers.speedmessage=%0%/s
    120
    121 # Worker zeigt Abschätzung der benötigten Zeit
    122 global.workers.estimatedtime=true
    123
    124 # Meldung für die abgeschätzte Zeit
    125 global.workers.estimationmessage= (%0% - noch %1%)
    126
    109 127 # Unterdrücken von Meldungen (alles auf AUS)
    110 128 suppress.newboxwizard.welcome=false
    111 129
    … …  
    194 212 option.typ.global.window.height=Text
    195 213 option.typ.global.window.width=Text
    196 214 option.typ.global.workers.parallel=Text
    215 option.typ.global.workers.estimatedtime=Check
    216 option.typ.global.workers.estimationmessage=Text
    217 option.typ.global.workers.byteprogress=Check
    218 option.typ.global.workers.bytemessage=Text
    197 219 option.typ.suppress.messages.newbox_welcome=Check
    198 220 option.typ.tree.tooltip.description_length=Text
    199 221 option.typ.tree.tooltip.description=Check

  • branches/Branch-To-Release-1_4-Neu/src/net/sourceforge/cridmanager/Utils.java

     
    32 32 * Logger for this class
    33 33 */
    34 34 private static final Logger logger = Logger.getLogger(Utils.class);
    35
    35 36 // deutschsprachiges Datumsformat
    36 37 private static SimpleDateFormat SDF;
    38
    37 39 private static File userHome = null;
    40
    38 41 private static ISettings settings = null;
    39 42
    40 43 public static Icon getIcon(String path) {
    … …  
    50 53 return returnIcon;
    51 54 } else {
    52 55 if (logger.isInfoEnabled()) {
    53 logger.info("getIcon(String) - Icon nicht gefunden - path=" + path); //$NON-NLS-1$
    56 logger
    57 .info("getIcon(String) - Icon nicht gefunden - path=" + path); //$NON-NLS-1$
    54 58 }
    55 59 if (logger.isDebugEnabled()) {
    56 60 logger.debug("getIcon(String) - end"); //$NON-NLS-1$
    … …  
    75 79 }
    76 80
    77 81 /**
    78 * Liefert das Verzeichnis, in dem die Anwendung ihre benutzerbezogenen Daten abspeichert. Dieses
    79 * ist standardmäßig ${user.home}/cridmanager. Wenn das Verzeichnis nicht existiert, wird es neu
    80 * angelegt. Kann es nicht angelegt werden, so wird ${user.home} zurückgeliefert.
    82 * Liefert das Verzeichnis, in dem die Anwendung ihre benutzerbezogenen
    83 * Daten abspeichert. Dieses ist standardmäßig ${user.home}/cridmanager.
    84 * Wenn das Verzeichnis nicht existiert, wird es neu angelegt. Kann es nicht
    85 * angelegt werden, so wird ${user.home} zurückgeliefert.
    81 86 *
    82 87 * @return Das aktuelle Benutzerverzeichnis
    83 88 * @see System#getProperty(java.lang.String)
    … …  
    129 134 }
    130 135
    131 136 /**
    132 * Liefert ein File-Objekt für ein Objekt (Verzeichnis oder Datei), das sich an einem relativen
    133 * Pfad vom Benutzerverzeichnis aus befindet.
    137 * Liefert ein File-Objekt für ein Objekt (Verzeichnis oder Datei), das sich
    138 * an einem relativen Pfad vom Benutzerverzeichnis aus befindet.
    134 139 *
    135 * @param relpath Relativer Pfad zum Objekt, ausgehend von dem Benutzerverzeichnis.
    140 * @param relpath
    141 * Relativer Pfad zum Objekt, ausgehend von dem
    142 * Benutzerverzeichnis.
    136 143 * @return File-Objekt für das gewünschte Objekt.
    137 144 */
    138 145 public static File getUserHome(String relpath) {
    … …  
    148 155 }
    149 156
    150 157 /**
    151 * Liefert ein formatiertes Datum. Sofern der Benutzer in seinen Properties ein Datumsformat
    152 * definiert hat, wird dieses benutzt. Ansonsten wird ein Format benutzt, das in der
    153 * Lokalisierungsdatei der eingestellten Locale steht. Ist auch dort nichts definiert, so wird der
    154 * Standard der eingestellten Locale verwendet.
    158 * Liefert ein formatiertes Datum. Sofern der Benutzer in seinen Properties
    159 * ein Datumsformat definiert hat, wird dieses benutzt. Ansonsten wird ein
    160 * Format benutzt, das in der Lokalisierungsdatei der eingestellten Locale
    161 * steht. Ist auch dort nichts definiert, so wird der Standard der
    162 * eingestellten Locale verwendet.
    155 163 *
    156 * @param date Das zu formatierende Datum
    164 * @param date
    165 * Das zu formatierende Datum
    157 166 * @param dateProp
    158 167 * @return Eine String mit dem formatierten Datum.
    159 168 * @see Utils#DATEFORMAT
    … …  
    167 176 // hole einen DateFormatter für die Default-Locale
    168 177 SDF = new SimpleDateFormat();
    169 178 // schaue nach einem Pattern, das der Benutzer bevorzugt
    170 String pattern = ServiceProvider.instance().getSettings().read(dateProp, ""); //$NON-NLS-1$
    179 String pattern = ServiceProvider.instance().getSettings().read(
    180 dateProp, ""); //$NON-NLS-1$
    171 181 // falls nichts vom Benutzer, dann in der Lokalisierung
    172 182 if (pattern.length() == 0) {
    173 183 pattern = Messages.getString("Utils.DatePattern"); //$NON-NLS-1$
    … …  
    206 216 // hole einen DateFormatter für die Default-Locale
    207 217 SDF = new SimpleDateFormat();
    208 218 // schaue nach einem Pattern, das der Benutzer bevorzugt
    209 String pattern = ServiceProvider.instance().getSettings().read(Utils.DATEFORMAT, ""); //$NON-NLS-1$
    219 String pattern = ServiceProvider.instance().getSettings().read(
    220 Utils.DATEFORMAT, ""); //$NON-NLS-1$
    210 221 // falls nichts vom Benutzer, dann in der Lokalisierung
    211 222 if (pattern.length() == 0) {
    212 223 pattern = Messages.getString("Utils.DatePattern"); //$NON-NLS-1$
    … …  
    221 232 }
    222 233
    223 234 /**
    224 * Extrahiert aus einer Exception den Text des Stacktraces und gibt ihn zurueck
    235 * Extrahiert aus einer Exception den Text des Stacktraces und gibt ihn
    236 * zurueck
    225 237 *
    226 * @param e Exception, dessen Stacktrce extrahiert werden soll
    238 * @param e
    239 * Exception, dessen Stacktrce extrahiert werden soll
    227 240 * @return Text des Stacktraces
    228 241 */
    229 242 public static String getStacktrace(Throwable e) {
    … …  
    241 254 }
    242 255
    243 256 /**
    244 * Diese Methode fuehrt ein <code>trim()</code> auf den uebergebenen String aus. Wenn der String
    245 * <code>null</code> ist, wird ein leerer String zurueckgegeben.
    257 * Diese Methode fuehrt ein <code>trim()</code> auf den uebergebenen
    258 * String aus. Wenn der String <code>null</code> ist, wird ein leerer
    259 * String zurueckgegeben.
    246 260 *
    247 * @param aString zu trimmender String
    248 * @return getrimmter String oder bei <code>null</code> als Uebergabewert ein leeren String
    261 * @param aString
    262 * zu trimmender String
    263 * @return getrimmter String oder bei <code>null</code> als Uebergabewert
    264 * ein leeren String
    249 265 */
    250 266 public static String trimNull(String aString) {
    251 267 if (logger.isDebugEnabled()) {
    … …  
    259 275 }
    260 276
    261 277 /**
    262 * Bricht einen String mit &lt;BR /&gt;-Tags so um, dass die angegebene Zeilenlänge nicht
    263 * überschritten wird.
    278 * Bricht einen String mit &lt;BR /&gt;-Tags so um, dass die angegebene
    279 * Zeilenlänge nicht überschritten wird.
    264 280 *
    265 * @param text Der Text
    266 * @param len Die maximale Zeilenlänge
    281 * @param text
    282 * Der Text
    283 * @param len
    284 * Die maximale Zeilenlänge
    267 285 * @return Die formatierte Zeichenkette
    268 286 */
    269 287 public static String formatStringHtml(String text, int len) {
    … …  
    299 317 }
    300 318
    301 319 /**
    302 * Einfache Ersetzung von variablen Inhalten in einen String. Es werden keine weiteren
    303 * Formatierungen angeboten, diese müssen bereits auf den einzusetzenden Daten ausgeführt worden
    304 * sein. <br>
    305 * Im übergebenen String werden Vorkommen des Musters <code>%nn%</code> gesucht und durch den
    306 * nn-ten Eintrag im <code>data</code> -Array ersetzt (also <code>%0% %1%</code> usw.), wobei
    307 * bei dem Objekt die <code>toString()</code> -Methode aufgerufen wird.
    320 * Einfache Ersetzung von variablen Inhalten in einen String. Es werden
    321 * keine weiteren Formatierungen angeboten, diese müssen bereits auf den
    322 * einzusetzenden Daten ausgeführt worden sein. <br>
    323 * Im übergebenen String werden Vorkommen des Musters <code>%nn%</code>
    324 * gesucht und durch den nn-ten Eintrag im <code>data</code> -Array
    325 * ersetzt (also <code>%0% %1%</code> usw.), wobei bei dem Objekt die
    326 * <code>toString()</code> -Methode aufgerufen wird.
    308 327 *
    309 * @param string String mit Ersetzungsmustern
    310 * @param data Array von Ersetzungstexten
    328 * @param string
    329 * String mit Ersetzungsmustern
    330 * @param data
    331 * Array von Ersetzungstexten
    311 332 * @return Der fertige String
    312 333 */
    313 334 public static String format(String string, Object[] data) {
    … …  
    335 356 }
    336 357
    337 358 /**
    338 * Formatiert eine Dateigröße in einem Benutzer-lesbaren Format. Dabei wird eine sinnvolle
    339 * Darstellung in B, KB, MB oder GB gewählt, wobei ab 1000 Einheiten auf die nächstgrößere
    340 * Darstellung gewechselt wird. Also 999 -> 999 B; 1000 -> 0,98 KB
    359 * Formatiert eine Dateigröße in einem Benutzer-lesbaren Format. Dabei wird
    360 * eine sinnvolle Darstellung in B, KB, MB oder GB gewählt, wobei ab 1000
    361 * Einheiten auf die nächstgrößere Darstellung gewechselt wird. Also 999 ->
    362 * 999 B; 1000 -> 0,98 KB
    341 363 *
    342 364 * @param size
    343 365 * @return
    344 366 */
    345 367 private static String[] einheiten = new String[] { " GB", " MB", " KB", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
    346 " B" }; //$NON-NLS-1$
    347 private static long[] divider = new long[] { 1024L * 1024L * 1024L, 1024L * 1024L, 1024L, 1L };
    348 private static long[] border = new long[] { 1000L * 1024L * 1024L, 1000L * 1024L, 1000L, 0L };
    368 " B" }; //$NON-NLS-1$
    349 369
    370 private static long[] divider = new long[] { 1024L * 1024L * 1024L,
    371 1024L * 1024L, 1024L, 1L };
    372
    373 private static long[] border = new long[] { 1000L * 1024L * 1024L,
    374 1000L * 1024L, 1000L, 0L };
    375
    350 376 public static String formatFilesize(long size) {
    351 377 if (logger.isDebugEnabled()) {
    352 378 logger.debug("formatFilesize(long) - start"); //$NON-NLS-1$
    … …  
    355 381 for (int i = 0; i < einheiten.length; i++) {
    356 382 if (size >= border[i]) {
    357 383 double part = (double) size / (double) divider[i];
    358 result = Double.toString(Math.round(part * 100) / 100.0) + einheiten[i];
    384 String number = Double.toString(Math.round(part * 100) / 100.0);
    385 if (number.indexOf('.') < 0) {
    386 number += ".00"; //$NON-NLS-1$
    387 } else
    388 while (number.length() - number.indexOf('.') < 3) {
    389 number += "0"; //$NON-NLS-1$
    390 }
    391 result = number + einheiten[i];
    359 392 break;
    360 393 }
    361 394 }
    … …  
    365 398 return result;
    366 399 }
    367 400
    401 public static String formatTime(long seconds) {
    402 long hours = seconds / (60 * 60);
    403 long mins = (seconds / 60) % 60;
    404 long secs = seconds % 60;
    405 String sHours = getNullPaddedNumber(hours);
    406 String sMins = getNullPaddedNumber(mins);
    407 String sSecs = getNullPaddedNumber(secs);
    408 String result = format(
    409 "%0%:%1%:%2%", new Object[] { sHours, sMins, sSecs }); //$NON-NLS-1$
    410 return result;
    411 }
    412
    413 private static String getNullPaddedNumber(long hours) {
    414 String result = "00" + Long.toString(hours); //$NON-NLS-1$
    415 result = result.substring(result.length() - 2);
    416 return result;
    417 }
    418
    368 419 // [#1155469] kein Zusammenfuegen moeglich
    369 420 /**
    370 421 * @param string
    … …  
    406 457 }
    407 458
    408 459 /**
    409 * Erstellt einen legalen Dateinamen mit Datum, sofern die Property APPEND_AUTO_DATE gesetzt ist.
    460 * Erstellt einen legalen Dateinamen mit Datum, sofern die Property
    461 * APPEND_AUTO_DATE gesetzt ist.
    410 462 *
    411 463 * @param name
    412 464 * @param datum
    413 465 * @return
    414 466 * @see ISettings.APPEND_AUTO_DATE
    415 467 */
    416 public static String legalFilenameWithDate(String name, Date datum, boolean noFiletype) {
    468 public static String legalFilenameWithDate(String name, Date datum,
    469 boolean noFiletype) {
    417 470 if (logger.isDebugEnabled()) {
    418 logger.debug("legalFilenameWithDate(String, Date, boolean) - start"); //$NON-NLS-1$
    471 logger
    472 .debug("legalFilenameWithDate(String, Date, boolean) - start"); //$NON-NLS-1$
    419 473 }
    420 474 if (settings == null) {
    421 475 settings = ServiceProvider.instance().getSettings();
    … …  
    423 477 String dateName = name;
    424 478 int dotPos;
    425 479 if (settings.isSet(AppendDateAction.APPEND_DATE_AUTO)) {
    426 String date = getFormattedDate(datum, AppendDateAction.APPEND_DATE_FORMAT);
    480 String date = getFormattedDate(datum,
    481 AppendDateAction.APPEND_DATE_FORMAT);
    427 482 if (settings.isSet(AppendDateAction.APPEND_DATE_PREFIX)) {
    428 483 dateName = date + name;
    429 484 } else {
    … …  
    431 486 if (dotPos < 0) {
    432 487 dateName = name + date;
    433 488 } else {
    434 dateName = name.substring(0, dotPos) + date + name.substring(dotPos);
    489 dateName = name.substring(0, dotPos) + date
    490 + name.substring(dotPos);
    435 491 }
    436 492 }
    437 493 }
    … …  
    478 534 }
    479 535 int size = settings.read(prop, 16);
    480 536 int dotPos = name.lastIndexOf('.');
    481 String sizedName = name.substring(0, dotPos) + Integer.toString(size) + name.substring(dotPos);
    537 String sizedName = name.substring(0, dotPos) + Integer.toString(size)
    538 + name.substring(dotPos);
    482 539 Icon icon = getIcon(sizedName);
    483 540 if (icon == null) {
    484 541 icon = getIcon(name);
    … …  
    515 572 * Definiert ein persönliches Format für Datums- und Zeitangaben
    516 573 */
    517 574 public static final String DATEFORMAT = "global.locale.dateformat"; //$NON-NLS-1$
    575
    518 576 public static final String MENU_ICON_SIZE = "global.look.menu_iconsize"; //$NON-NLS-1$
    577
    519 578 public static final String BUTTON_ICON_SIZE = "global.look.button_iconsize"; //$NON-NLS-1$
    579
    520 580 public static final String TREE_ICON_SIZE = "global.look.tree_iconsize"; //$NON-NLS-1$
    521 581 }

  • branches/Branch-To-Release-1_4-Neu/src/net/sourceforge/cridmanager/worker/AbstractWorker.java

     
    17 17 import java.awt.event.MouseEvent;
    18 18 import java.util.ArrayList;
    19 19 import java.util.Iterator;
    20
    20 21 import javax.swing.JComponent;
    21 22 import javax.swing.JMenuItem;
    22 23 import javax.swing.JPanel;
    23 24 import javax.swing.JPopupMenu;
    24 25 import javax.swing.JProgressBar;
    26
    25 27 import net.sourceforge.cridmanager.CridController;
    26 28 import net.sourceforge.cridmanager.CridInfo;
    27 29 import net.sourceforge.cridmanager.ISettings;
    … …  
    29 31 import net.sourceforge.cridmanager.Utils;
    30 32 import net.sourceforge.cridmanager.error.ErrorHandler;
    31 33 import net.sourceforge.cridmanager.services.ServiceProvider;
    34
    32 35 import org.apache.log4j.Logger;
    33 36
    34 public abstract class AbstractWorker extends Thread implements IWorker, ActionListener {
    37 public abstract class AbstractWorker extends Thread implements IWorker,
    38 ActionListener {
    35 39
    40 private static final double MIN_PERCENTAGE_BEFORE_ESTIMATION = 0.005d;
    41
    36 42 private static Logger logger = Logger.getLogger(AbstractWorker.class);
    43
    37 44 private CridController cridController;
    45
    38 46 protected String message;
    47
    39 48 protected int progress;
    49
    40 50 protected JComponent display;
    51
    41 52 protected boolean displayed;
    53
    42 54 protected JProgressBar progressBar;
    55
    43 56 private ArrayList listenerList;
    44 57
    58 private boolean showProgress;
    59
    60 private boolean showEstimation;
    61
    45 62 public AbstractWorker(CridController controller) {
    46 63 this.cridController = controller;
    47 64 settings = ServiceProvider.instance().getSettings();
    … …  
    50 67 displayed = true;
    51 68 progress = 0;
    52 69 errorTxt = ""; //$NON-NLS-1$
    70 showProgress = settings.isSet(SHOWPROGRESSBYTE);
    71 showEstimation = settings.isSet(SHOWESTIMATEDTIME);
    72 showSpeed = settings.isSet(SHOWSPEED);
    53 73 }
    54 74
    55 75 protected JMenuItem mnuCancel;
    76
    56 77 protected JMenuItem mnuPause;
    78
    57 79 protected JMenuItem mnuContinue;
    80
    58 81 protected boolean cancelled;
    82
    59 83 protected boolean paused;
    84
    60 85 protected CridInfo[] cridInfos;
    86
    61 87 private long progressMax = 0;
    88
    62 89 private long progressCount = 0;
    90
    63 91 protected boolean showGui;
    92
    64 93 protected String errorTxt;
    94
    65 95 protected ISettings settings;
    66 96
    97 private long startTime;
    98
    99 private long lastExpired;
    100
    101 private long remaining;
    102
    103 private boolean showSpeed;
    104
    105 /*
    106 * (non-Javadoc)
    107 *
    108 * @see java.lang.Thread#start()
    109 */
    110 public synchronized void start() {
    111 startTime = System.currentTimeMillis();
    112 super.start();
    113 }
    114
    67 115 /**
    68 * Aktualisiert den Fortschritt. Wenn ein <code>ProgressBar</code> existiert wird sein Wert
    69 * angepasst. Alle registrierten <code>ActionListener</code> werden informiert.
    116 * Aktualisiert den Fortschritt. Wenn ein <code>ProgressBar</code>
    117 * existiert wird sein Wert angepasst. Alle registrierten
    118 * <code>ActionListener</code> werden informiert.
    70 119 *
    71 * @param percent Akueller Bearbeitungsfortschritt in Prozent.
    120 * @param percent
    121 * Akueller Bearbeitungsfortschritt in Prozent.
    72 122 */
    73 123 protected void progress(int percent) {
    74 124 testPause();
    … …  
    82 132 private synchronized void testPause() {
    83 133 if (paused) {
    84 134 String oldMessage = message;
    85 String pauseMessage = Utils.format(
    86 Messages.getString("Worker.Pausing"), new Object[] { oldMessage }); //$NON-NLS-1$
    135 String pauseMessage = Utils.format(Messages
    136 .getString("Worker.Pausing"), new Object[] { oldMessage }); //$NON-NLS-1$
    87 137 setMessage(pauseMessage);
    88 138 while (paused && !cancelled) {
    89 139 try {
    90 140 wait(500);
    91 } catch (InterruptedException e) {}
    141 } catch (InterruptedException e) {
    142 }
    92 143 }
    93 144 if (!cancelled) {
    94 145 setMessage(oldMessage);
    … …  
    115 166 }
    116 167
    117 168 /**
    118 * Setzt eine neue Fortschrittsmeldung. Wenn ein <code>ProgressBar</code> angezeigt wird, wird
    119 * die Meldung dort angezeigt. Alle registrierten <code>ActionListener</code> werden informiert.
    169 * Setzt eine neue Fortschrittsmeldung. Wenn ein <code>ProgressBar</code>
    170 * angezeigt wird, wird die Meldung dort angezeigt. Alle registrierten
    171 * <code>ActionListener</code> werden informiert.
    120 172 *
    121 * @param msg Die neue Fortschrittsnachricht.
    173 * @param msg
    174 * Die neue Fortschrittsnachricht.
    122 175 */
    123 176 protected void setMessage(String msg) {
    124 177 this.message = msg;
    178 setMessageWithEstimation();
    179 }
    180
    181 private void setMessageWithEstimation() {
    182 String localMessage = message;
    183 if (showProgressAndEstimation()) {
    184 if (showProgress) {
    185 String progress = getFormattedProgressString(progressCount,
    186 progressMax);
    187 if (progress != null && progress.length() > 0) {
    188 localMessage += " " + progress; //$NON-NLS-1$
    189 }
    190 }
    191 if (showEstimation || showSpeed) {
    192 double percentage = (double) progressCount
    193 / (double) progressMax;
    194 if (percentage >= MIN_PERCENTAGE_BEFORE_ESTIMATION) {
    195 long current = System.currentTimeMillis();
    196 long expired = (current - startTime) / 1000;
    197 if (expired > lastExpired) {
    198 lastExpired = expired;
    199 remaining = (long) (expired / percentage) - expired;
    200 }
    201 if (showEstimation) {
    202 String sExpired = Utils.formatTime(expired);
    203 String sExpected = Utils.formatTime(remaining);
    204 String msgFormat = settings.read(ESTIMATIONSTRING,
    205 "(%0% - noch %1%)"); //$NON-NLS-1$
    206 String msg = Utils.format(msgFormat, new Object[] {
    207 sExpired, sExpected });
    208 localMessage += " " + msg; //$NON-NLS-1$
    209 }
    210 if (showSpeed) {
    211 String speed = getFormattedSpeed(progressCount, expired);
    212 if (speed != null && speed.length() > 0) {
    213 localMessage += " " + speed; //$NON-NLS-1$
    214 }
    215 }
    216 }
    217 }
    218 }
    125 219 if (progressBar != null) {
    126 progressBar.setString(message);
    220 progressBar.setString(localMessage);
    127 221 }
    128 222 fireActionPerformed("Message"); //$NON-NLS-1$
    129 223 }
    130 224
    225 protected String getFormattedProgressString(long done, long max) {
    226 return null; // defaults to no string to display
    227 }
    228
    229 protected String getFormattedSpeed(long progress, long seconds) {
    230 return null; // defaults to no string to display
    231 }
    232
    131 233 public void addActionListener(ActionListener listener) {
    132 234 if (listenerList == null) {
    133 235 listenerList = new ArrayList();
    … …  
    148 250 /**
    149 251 * Sendet eine Nachricht an alle regsitrierten Listener.
    150 252 *
    151 * @param type Der Typ der Nachricht. Zurzeit gibt es "Progress" bei einer Veränderung des
    152 * Fortschrittwertes und "Message" bei einer Veränderung der Nachricht.
    253 * @param type
    254 * Der Typ der Nachricht. Zurzeit gibt es "Progress" bei einer
    255 * Veränderung des Fortschrittwertes und "Message" bei einer
    256 * Veränderung der Nachricht.
    153 257 */
    154 258 protected void fireActionPerformed(String type) {
    155 259 if (listenerList != null) {
    … …  
    199 303 popup.show(e.getComponent(), e.getX(), e.getY());
    200 304 }
    201 305 } catch (RuntimeException exc) {
    202 ErrorHandler.showError("Popupmenü kann nicht angezeigt werden.", exc); //$NON-NLS-1$
    306 ErrorHandler.showError(
    307 "Popupmenü kann nicht angezeigt werden.", exc); //$NON-NLS-1$
    203 308 }
    204 309 }
    205 310 });
    … …  
    233 338 }
    234 339
    235 340 /**
    236 * Erhöhe den Fortschritt um den angegebenen absoluten Wert, berechne und setze den neuen
    237 * prozentualen Fortschrittswert.
    341 * Erhöhe den Fortschritt um den angegebenen absoluten Wert, berechne und
    342 * setze den neuen prozentualen Fortschrittswert.
    238 343 *
    239 * @param increment Gerade getätigter Fortschritt
    344 * @param increment
    345 * Gerade getätigter Fortschritt
    240 346 */
    241 347 protected void progressInc(long increment) {
    242 348 progressCount += increment;
    243 349 if (progressMax > 0) {
    244 350 int percent = (int) (progressCount * 100L / progressMax);
    245 351 progress(percent);
    352 if (showProgressAndEstimation()) {
    353 setMessageWithEstimation();
    354 }
    246 355 }
    247 356 }
    248 357
    358 private boolean showProgressAndEstimation() {
    359 return showEstimation || showProgress || showSpeed;
    360 }
    361
    249 362 /**
    250 * Setze den 100 Prozent Wert für die Fortschrittsberechnung und aktualisiere den prozentualen
    251 * Fortschritt.
    363 * Setze den 100 Prozent Wert für die Fortschrittsberechnung und
    364 * aktualisiere den prozentualen Fortschritt.
    252 365 *
    253 * @param value 100% Fortschritt entsprechen diesem Wert
    366 * @param value
    367 * 100% Fortschritt entsprechen diesem Wert
    254 368 */
    255 369 protected void setProgressMax(long value) {
    256 370 progressMax = value;
    … …  
    279 393 }
    280 394
    281 395 /**
    282 *
    396 *
    283 397 */
    284 398 private void pauseAction() {
    285 399 paused = true;
    … …  
    288 402 }
    289 403
    290 404 /**
    291 *
    405 *
    292 406 */
    293 407 private void continueAction() {
    294 408 paused = false;
    … …  
    297 411 }
    298 412
    299 413 /**
    300 * Brich den aktuallen Thread ab. Zunächst kann eine Aktion vor dem Canceln durchgeführt werden,
    301 * die den Abbruch noch verhindern kann, dann wird der Thread gecancelt und anschließend kann eine
    302 * Nachbereitung stattfinden.
    414 * Brich den aktuallen Thread ab. Zunächst kann eine Aktion vor dem Canceln
    415 * durchgeführt werden, die den Abbruch noch verhindern kann, dann wird der
    416 * Thread gecancelt und anschließend kann eine Nachbereitung stattfinden.
    303 417 */
    304 418 private void cancelAction() {
    305 419 if (preCancelAction()) {
    … …  
    309 423 }
    310 424
    311 425 /**
    312 * Die Aktion vor dem Abbrechen des Threads. Sollte von der abgeleiteten Klasse überschrieben
    313 * werden, um z.B. den Benutzer noch einmal um eine BEstätigung zu bitten.
    426 * Die Aktion vor dem Abbrechen des Threads. Sollte von der abgeleiteten
    427 * Klasse überschrieben werden, um z.B. den Benutzer noch einmal um eine
    428 * BEstätigung zu bitten.
    314 429 *
    315 430 * @return true, wenn der Thread wirklich abgebrochen werden soll.
    316 431 */
    … …  
    319 434 }
    320 435
    321 436 /**
    322 * Ermöglicht das Durchführen einer Aktion nach dem Abbruch des Threads. Zurzeit kann hier keine
    323 * sinnvolle Aktion durchgeführt werden, da der Thread-Abbruch durch das Setzen eines Flags
    324 * geschieht und somit der tatsächliche Abbruch erst nach Aufruf dieser Funktion stattfindet.
    437 * Ermöglicht das Durchführen einer Aktion nach dem Abbruch des Threads.
    438 * Zurzeit kann hier keine sinnvolle Aktion durchgeführt werden, da der
    439 * Thread-Abbruch durch das Setzen eines Flags geschieht und somit der
    440 * tatsächliche Abbruch erst nach Aufruf dieser Funktion stattfindet.
    325 441 */
    326 protected void postCancelAction() {}
    442 protected void postCancelAction() {
    443 }
    327 444
    328 445 /**
    329 * Setze das Abbruchflag für den Thread und setze eine entsprechende Nachricht.
    446 * Setze das Abbruchflag für den Thread und setze eine entsprechende
    447 * Nachricht.
    330 448 */
    331 449 protected void cancelThread() {
    332 450 cancelThread(true);

  • branches/Branch-To-Release-1_4-Neu/src/net/sourceforge/cridmanager/worker/IWorker.java

     
    10 10 * Erfolgsmeldung nach Aktionen anzeigen [#1114576] Bestätigungsmeldung nach Kopieren optional
    11 11 */
    12 12 static final String SUCCESSMESSAGE = "files.copy.success"; //$NON-NLS-1$
    13 static final String SHOWPROGRESSBYTE = "global.workers.byteprogress"; //$NON-NLS-1$
    14 static final String SHOWESTIMATEDTIME = "global.workers.estimatedtime"; //$NON-NLS-1$
    15 static final String ESTIMATIONSTRING = "global.workers.estimationmessage"; //$NON-NLS-1$
    16 static final String SHOWSPEED = "global.workers.speed"; //$NON-NLS-1$
    13 17
    14 18 /**
    15 19 * Flag, ob der Worker angezeigt wird.

  • branches/Branch-To-Release-1_4-Neu/src/net/sourceforge/cridmanager/worker/SingleCridWithSizeWorker.java

     
    1 /**
    2 *
    3 */
    4 package net.sourceforge.cridmanager.worker;
    5
    6 import net.sourceforge.cridmanager.CridController;
    7 import net.sourceforge.cridmanager.CridInfo;
    8 import net.sourceforge.cridmanager.Utils;
    9
    10 /**
    11 * @author Olaf
    12 *
    13 */
    14 public abstract class SingleCridWithSizeWorker extends SingleCridWorker {
    15
    16 private static final String PROGRESSBYTEMESSAGE = "global.workers.bytemessage"; //$NON-NLS-1$
    17
    18 private static final String SPEEDMESSAGE = "global.workers.speedmessage"; //$NON-NLS-1$
    19
    20 protected SingleCridWithSizeWorker(CridInfo info, CridController controller) {
    21 super(info, controller);
    22 }
    23
    24 /*
    25 * (non-Javadoc)
    26 *
    27 * @see net.sourceforge.cridmanager.worker.AbstractWorker#getFormattedProgressString(long,
    28 * long)
    29 */
    30 protected String getFormattedProgressString(long done, long max) {
    31 String doneSize = Utils.formatFilesize(done);
    32 String maxSize = Utils.formatFilesize(max);
    33 String sizeFormat = settings
    34 .read(PROGRESSBYTEMESSAGE, " (%0% von %1%)"); //$NON-NLS-1$
    35 String result = Utils.format(sizeFormat, new Object[] { doneSize,
    36 maxSize });
    37 return result;
    38 }
    39
    40 /*
    41 * (non-Javadoc)
    42 *
    43 * @see net.sourceforge.cridmanager.worker.AbstractWorker#getFormattedSpeed(long)
    44 */
    45 protected String getFormattedSpeed(long done, long seconds) {
    46 long avg = done / seconds;
    47 String speed = Utils.formatFilesize(avg);
    48 String speedFormat = settings.read(SPEEDMESSAGE, "%0%/s"); //$NON-NLS-1$
    49 String result = Utils.format(speedFormat, new Object[] { speed });
    50 return result;
    51 }
    52 }

  • branches/Branch-To-Release-1_4-Neu/src/net/sourceforge/cridmanager/worker/WorkerCopyFile.java

     
    35 35 /**
    36 36 * Ein Worker, der eine Aufnahme mit allen zugehörigen Dateien kopiert.
    37 37 */
    38 public class WorkerCopyFile extends SingleCridWorker {
    38 public class WorkerCopyFile extends SingleCridWithSizeWorker {
    39 39
    40 40 private static Logger logger = Logger.getLogger(WorkerCopyFile.class);
    41 41 private static final Logger tlog = Logger.getLogger(Start.THREAD);

  • branches/Branch-To-Release-1_4-Neu/src/net/sourceforge/cridmanager/worker/WorkerJoinRecording.java

     
    32 32 * Ein Worker, der die einzelnen MPG-Dateien einer Aufnahme zu einer Datei zusammensetzt (TS =
    33 33 * TransportStream).
    34 34 */
    35 public class WorkerJoinRecording extends SingleCridWorker {
    35 public class WorkerJoinRecording extends SingleCridWithSizeWorker {
    36 36
    37 37 private static Logger logger = Logger.getLogger(WorkerJoinRecording.class);
    38 38 private static final Logger tlog = Logger.getLogger(Start.THREAD);