    001package org.vishia.commander;
    002
    003import java.util.EventObject;
    004import java.util.LinkedList;
    005import java.util.List;
    006
    007import org.vishia.event.EventConsumer;
    008import org.vishia.event.EventSource;
    009import org.vishia.fileRemote.FileMark;
    010import org.vishia.fileRemote.FileRemote;
    011import org.vishia.fileRemote.FileRemoteCallback;
    012import org.vishia.fileRemote.FileRemoteProgressTimeOrder;
    013import org.vishia.gral.base.GralButton;
    014import org.vishia.gral.base.GralPos;
    015import org.vishia.gral.base.GralTextField;
    016import org.vishia.gral.base.GralValueBar;
    017import org.vishia.gral.base.GralWidget;
    018import org.vishia.gral.base.GralWindow;
    019import org.vishia.gral.ifc.GralColor;
    020import org.vishia.gral.ifc.GralTextField_ifc;
    021import org.vishia.gral.ifc.GralUserAction;
    022import org.vishia.gral.ifc.GralWidget_ifc;
    023import org.vishia.gral.ifc.GralWindow_ifc;
    024import org.vishia.util.Debugutil;
    025import org.vishia.util.FileSystem;
    026import org.vishia.util.KeyCode;
    027import org.vishia.util.SortedTreeWalkerCallback;
    028import org.vishia.util.StringFormatter;
    029import org.vishia.util.StringFunctions;
    030
    031
    032/**Base class for initializing some class variables before the variables with only code in the class body are executed. */
    033class FcmdFileActionBase {
    034
    035  /**The command which is given with that window. */
    036  final FcmdCopyCmprDel.Ecmd cmdWind;
    037
    038  final String helpPrefix;
    039
    040  FcmdFileActionBase(FcmdCopyCmprDel.Ecmd whatisit){
    041    cmdWind = whatisit;
    042    switch(whatisit){
    043      case compare: helpPrefix = "cmpr"; break;
    044      case copy: helpPrefix = "copy"; break;
    045      case delete: helpPrefix = "del"; break;
    046      default: throw new IllegalArgumentException("internal");
    047    }
    048  }
    049}
    050
    051
    052/**This class contains all functionality to execute copy, move, compare and delete for The.file.Commander.
    053 * The same class is used for three instances with a different view. See constructor-argument.
    054 *
    055 *
    056 * @author Hartmut Schorrig
    057 *
    058 */
    059public final class FcmdCopyCmprDel extends FcmdFileActionBase
    060{
    061  /**Version and History
    062   * <ul>
    063   * <li>2015-01-03 Hartmut refactory
    064   * <li>2013-02-03 Hartmut chg: set the destination only if it is not set on button setSrc
    065   * <li>2013-02-03 Hartmut chg: {@link #execMove()} with files
    066   * <li>2013-02-03 Hartmut new: Copy exception (on file open to write) cases a message, the key {@link #widgOverwrFile}
    067   *   works together with the Ask state.
    068   * <li>2012-11-16 Hartmut chg: Copy: The {@link #filesToCopy} will be filled after callback of check. The files which are used
    069   *   are read only from the input fields of the GUI. The user can change it.
    070   * <li>2012-02-26 Hartmut chg: Strategy for button texts and abort behavior improved. Problem was:
    071   *   The 'check' phase needs some calculation time for a slow network connection.
    072   * <li>2012-02-04 Hartmut new: If a file was copied and a comparison result exists, it is set to equal.
    073   *   That helps to handle with comparison.
    074   * </ul>
    075   */
    076  public static final int version = 0x20120204;
    077
    078
    079  String sTextExecuteForFile = (cmdWind == Ecmd.delete) ? "del file" : "overwr file";
    080
    081  protected final Fcmd main;
    082
    083  GralWindow windConfirmCopy;
    084
    085  GralPos posWindConfirmCopy;
    086
    087  //GralWidget widgdCopyFrom, widgdCopyTo;
    088
    089  GralTextField widgShowSrc, widgFromConditions;
    090
    091  GralButton widgButtonModeDst;
    092
    093  GralTextField widgInputDst, widgCopyState;
    094
    095  GralTextField widgCopyDirDst, widgCopyNameDst;  //TODO with progress
    096
    097  GralButton widgdChoiceCreateNew, widgdChoiceOverwrExists, widgdChoiceOverwrReadOnly;
    098
    099  GralButton widgOverwrFile, widgSkipFile, widgSkipDir, widgBtnPause;
    100
    101
    102  GralButton widgState, widgButtonSetSrc, widgButtonSetDst, widgButtonCheck, widgButtonMove, widgButtonOk;
    103
    104  GralButton widgButtonClearSel, widgButtonShowSrc, widgButtonShowDst, widgButtonShowResult;
    105
    106  GralValueBar widgProgressFile;
    107  GralValueBar widgProgressAll;
    108
    109  GralButton widgButtonEsc;
    110
    111  GralColor colorNoChangedText = GralColor.getColor("am");
    112
    113  GralColor colorChangedText = GralColor.getColor("wh");
    114
    115  GralColor colorGrayed = GralColor.getColor("gr");
    116
    117  /**Mode overwrite readonly. '?'-ask, y-overwrite n-skip, don't ask
    118   */
    119  int modeOverwrReadonly = FileRemote.modeCopyReadOnlyAks;
    120
    121  /**Mode overwrite with timestamp. 'w'-newer, o-older, n-never, ?-ask. */
    122  int modeOverwrDate = FileRemote.modeCopyExistAsk;
    123
    124  /**Mode create new file while copying. 'n'-no, y-yes, a-ask. */
    125  int modeCreateCopy = FileRemote.modeCopyCreateYes;
    126
    127  /**The file card where the directory content is shown where the files will be copied to, the destination. */
    128  FcmdFileCard fileCardSrc, fileCardDst;
    129
    130  /**The source file to copy. It is set in the {@link #actionConfirmCopy()}. Either dirSrc == fileSrc
    131   * and the {@link #sFilesSrc} contains some file names, or dirSrc is the directory of fileSrc, fileSrc is the only one
    132   * file to copy (maybe a directory) and sFilesSrc is empty.
    133   */
    134  FileRemote srcDir, srcFile;
    135
    136  boolean srcSomeFiles;
    137
    138  /**If more as one files are selected to copy, the names are contained here separated with ' : '.
    139   * Elsewhere it is "*". */
    140  String sFilesSrc;
    141
    142  /**The destination selected directory and file as destination for compare and move or second tree for comparison.
    143   * The fileDst is build with the name of the source file for copy and move and with the real dst file for compare
    144   */
    145  FileRemote fileDst, dirDst; //, dirDstCmpr;
    146
    147  /**Name of the file for dst. */
    148  CharSequence sFileDstCopy;
    149
    150  StringBuilder bufferDstChars = new StringBuilder(100);
    151
    152  StringFormatter formatShow = new StringFormatter(100);
    153
    154  /**If true then the {@link #widgInputDst} was changed for this session. Not automatically change the content. */
    155  boolean bDstChanged;
    156
    157  boolean bFirstSelect;
    158
    159  /**Content from the input fields while copy is pending. */
    160  //String sDstDir, sDstName;
    161
    162  long zBytes;
    163  int zFiles;
    164
    165  FileRemote fileProcessed, dirProcessed;
    166
    167
    168  //List<String> listFileSrc;
    169
    170  /**This list is filled with some callback Events for files which are checked before copying.
    171   * If the callback of the check process occurs, the events will be removed from this list.
    172   * Only events which are found in this list are considered to build the list of files to copy.
    173   * This list is definitive cleared if the "abort" button is pressing. A current running check process
    174   * cannot be aborted because it runs in another unknown thread. But the usage of the callback is prevented then.
    175   */
    176  final List<FileRemote.CallbackEvent> listEvCheck = new LinkedList<FileRemote.CallbackEvent>();
    177
    178  int nrofFilesCheck;
    179
    180
    181  /**State of the handling. */
    182  protected Estate state = Estate.inactive;
    183
    184
    185  /**Selected handling command. */
    186  protected Ecmd cmd = Ecmd.copy;
    187
    188  //protected boolean bLockSrc;
    189
    190  /**If true then not all files are selected below the shown source directory.
    191   * Then move and delete should work in fine steps.
    192   */
    193  protected boolean bFineSelect;
    194
    195  final List<FileRemote.CallbackEvent> listEvCopy = new LinkedList<FileRemote.CallbackEvent>();
    196
    197  /**Current files which are in copy process. Typical contains one file only.
    198   * This list will be filled in {@link #actionConfirmCopy}.
    199   * If the copy process is finished, this list will be empty.
    200   */
    201  final List<FileRemote> filesToCopy = new LinkedList<FileRemote>();
    202
    203  /**Last files which are in copy process. Typical contains one file only.
    204   * This list will be filled in {@link #actionButtonCopy} if the copy process will be started.
    205   * It is used in {@link #actionLastSrc} to fill the {@link #filesToCopy}.
    206   * This list remains after copy process to supply "last files".
    207   */
    208  //final List<FileRemote> filesToCopyLast = new LinkedList<FileRemote>();
    209
    210
    211
    212  EventSource evSrc = new EventSource("FcmdCopy-GUIaction");
    213
    214
    215
    216
    217  /**This reference is set with the callback of operation cmd.
    218   * The event can be used to affect the copying process.
    219   */
    220  FileRemote.CallbackEvent evCurrentFile;
    221
    222  Actions action;
    223
    224  FcmdCopyCmprDel(Fcmd main, Ecmd cmdArg)
    225  { super(cmdArg);
    226    this.main = main;
    227  }
    228
    229
    230  /**Last files which are in copy process. Typical contains one file only.
    231   * This list will be filled in {@link #actionButtonCopy} if the copy process will be started.
    232   * It is used in {@link #actionLastSrc} to fill the {@link #filesToCopy}.
    233   * This list remains after copy process to supply "last files".
    234   */
    235  //final List<FileRemote> filesToCopyLast = new LinkedList<FileRemote>();
    236
    237
    238
    239  /**Builds the content of the confirm-copy window. The window is created static. It is shown
    240   * whenever it is used.  */
    241  void buildWindowConfirmCopy(String sTitle)
    242  {
    243    action = new Actions();
    244    main._gralMng.selectPanel("primaryWindow"); //"output"); //position relative to the output panel
    245    //System.out.println("CopyWindow frame: " + main.gralMng.pos.panel.getPixelPositionSize().toString());
    246    //panelMng.setPosition(1, 30+GralGridPos.size, 1, 40+GralGridPos.size, 1, 'r');
    247    main._gralMng.setPosition(10, GralPos.size+37, 10, GralPos.size+70, 1, 'r'); //right buttom, about half less display width and hight.
    248
    249
    250    posWindConfirmCopy = main._gralMng.getPositionInPanel();
    251    int windprops = GralWindow.windConcurrently; // + GralWindow.windResizeable;
    252    windConfirmCopy = main._gralMng.createWindow("copyWindow", sTitle, windprops);
    253    //System.out.println(" window: " + main.gralMng.pos.panel.getPixelPositionSize().toString());
    254
    255    //source path and check:
    256    if(cmdWind != Ecmd.delete) {
    257      main._gralMng.setPosition(0.5f, GralPos.size +2, 1, 7.5f, 0, 'r', 0);
    258      widgButtonModeDst = main._gralMng.addSwitchButton(null, "dst/..", "dst/dst", GralColor.getColor("gn"), GralColor.getColor("ye") );
    259      widgButtonModeDst.setActionChange(actionChgModeDst);
    260    }
    261    main._gralMng.setPosition(0.5f, GralPos.size +2.5f, 15, GralPos.size+12, 0, 'r', 1);
    262    widgButtonSetSrc = main._gralMng.addButton(null, actionConfirmCopy, "setSrc", null, "set source" );
    263    widgButtonSetSrc.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".setSrc.");
    264    widgButtonClearSel = main._gralMng.addButton(null, null, "clrSel", null, "clear selection" );
    265    widgButtonClearSel.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".clearSel.");
    266    if(cmdWind != Ecmd.delete) {
    267      main._gralMng.setPosition(GralPos.same, GralPos.samesize, -17, -1, 0, 'r', 1);
    268      widgButtonSetDst = main._gralMng.addButton(null, actionSetDst, "setDst", null, "set destination" );
    269      widgButtonSetDst.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".setDst.");
    270    }
    271    main._gralMng.setPosition(2.5f, GralPos.size +3.2f, 1, -4, 0, 'd', 0);
    272    //main.gralMng.addText("source:", 0, GralColor.getColor("bk"), GralColor.getColor("lgr"));
    273    widgShowSrc = main._gralMng.addTextField("copyFrom", false, "source root path", "t");
    274    widgShowSrc.setBackColor(GralColor.getColor("am"),0);
    275    widgShowSrc.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".pathSrc.");
    276    main._gralMng.setPosition(GralPos.refer+0.9f, GralPos.size +2.5f, -4f, -1, 0, 'r', 1);
    277    widgButtonShowSrc = main._gralMng.addButton(null, null, "showSrc", null, "=>" );
    278    widgButtonShowSrc.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".show.");
    279
    280
    281    main._gralMng.setPosition(GralPos.refer + 2.3f, GralPos.size +3.2f, 1, -13, 0, 'r', 0.3f);
    282    widgFromConditions = main._gralMng.addTextField("copyCond",true, "select src files: mask* : *.ext ", "t");  /// 2012-08-05..06
    283    widgFromConditions.setActionChange(actionSelectMask);
    284    widgFromConditions.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".selcond.");
    285
    286    main._gralMng.setPosition(GralPos.refer+0.2f, GralPos.size+3.5f, -13, -1, 0, 'd', 0);
    287    widgButtonCheck = main._gralMng.addButton("buttonCheck", actionCheck, "check", null, "check" );
    288    widgButtonCheck.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".check.");
    289
    290    //dst path, set dst
    291    if(cmdWind != Ecmd.delete) {
    292      main._gralMng.setPosition(GralPos.refer+3.0f, GralPos.size -3.2f, 1, -4, 0, 'r', 0);
    293      widgInputDst = main._gralMng.addTextField("copyDirDst", true, "destination:", "t");
    294      widgInputDst.setActionChange(actionEnterTextInDst);
    295      widgInputDst.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".setDst.");
    296      main._gralMng.setPosition(GralPos.refer+0.9f, GralPos.size +2.5f, -4, -1, 0, 'r', 1);
    297      widgButtonShowDst = main._gralMng.addButton(null, null, "showDst", null, "=>" );
    298      widgButtonShowDst.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".show.");
    299    }
    300
    301    main._gralMng.setPosition(GralPos.refer+1.5f, GralPos.size -1.5f, 1, 18, 0, 'r', 1);
    302    if(cmdWind == Ecmd.delete) {
    303      main._gralMng.addText("Del read only ?");
    304    } else if(cmdWind == Ecmd.compare) {
    305      //nothing such
    306    } else {
    307      main._gralMng.addText("Overwr read only ?");
    308      main._gralMng.addText("Overwr exists ?");
    309      main._gralMng.addText("Create ?");
    310    }
    311    if(cmdWind != Ecmd.compare) {
    312      main._gralMng.setPosition(GralPos.refer+3.5f, GralPos.size -3, 1, GralPos.size +12, 0, 'r',1);
    313      widgdChoiceOverwrReadOnly = main._gralMng.addButton("overwritero", actionOverwrReadonly, "overwritero", null,"ask ?yes ?no");
    314      widgdChoiceOverwrReadOnly.setBackColor(GralColor.getColor("lam"), 0);
    315      widgdChoiceOverwrReadOnly.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".ctrl.overwrRo.");
    316    }
    317    if(cmdWind != Ecmd.delete && cmdWind != Ecmd.compare) {
    318      main._gralMng.setPosition(GralPos.same, GralPos.size -3, GralPos.next, GralPos.size +20, 0, 'r',1);
    319      widgdChoiceOverwrExists = main._gralMng.addButton("copyOverwriteReadonly", actionOverwrDate, "copyOverwriteReadonly", null, "ask ?newer?older?all ?no");
    320      widgdChoiceOverwrExists.setBackColor(GralColor.getColor("lam"), 0);
    321      widgdChoiceOverwrExists.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".ctrl.overwrExists.");
    322      main._gralMng.setPosition(GralPos.same, GralPos.size -3, GralPos.next, GralPos.size +12, 0, 'r',1);
    323      widgdChoiceCreateNew = main._gralMng.addButton("copyCreate", actionCreateCopy, "copyCreate", null, "yes ?no ?ask");
    324      widgdChoiceCreateNew.setBackColor(GralColor.getColor("lgn"), 0);
    325      widgdChoiceCreateNew.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".ctrl.createNew.");
    326    }
    327
    328    //field for showing the current action or state, not for input:
    329    //field for showing the current name, not for input:
    330    main._gralMng.setPosition(GralPos.refer + 3.5f, GralPos.size +3.2f, 1, -1, 0, 'd');
    331    widgCopyDirDst = main._gralMng.addTextField("copyDirDst", false, "current directory:", "t");
    332    widgCopyDirDst.setBackColor(GralColor.getColor("lam"),0);
    333    widgCopyDirDst.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".currfile.");
    334    widgCopyNameDst = main._gralMng.addTextField("copyNameDst", false, "current file:", "t");
    335    widgCopyNameDst.setBackColor(GralColor.getColor("lam"),0);
    336    widgCopyNameDst.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".currfile.");
    337
    338    main._gralMng.setPosition(GralPos.refer+3.5f, GralPos.size +3.2f, 1, -15, 0, 'd', 0.3f); //same line as del
    339    widgCopyState = main._gralMng.addTextField("copyStatus", false, "current state:", "t");
    340    widgCopyState.setBackColor(GralColor.getColor("lam"),0);
    341    widgCopyState.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".state.");
    342
    343    main._gralMng.setPosition(-4, GralPos.size +1, 10, -14, 0, 'd', 1);
    344    if(cmdWind != Ecmd.delete) {
    345      //widgProgressFile = main.gralMng.addValueBar("copyProgressFile", null);
    346    }
    347    //widgProgressAll = main.gralMng.addValueBar("copyProgressAll", null);
    348
    349    if(cmdWind == Ecmd.copy) {
    350      main._gralMng.setPosition(-8, GralPos.size+2.5f, -13f, -1, 0, 'd', 0.3f);
    351      widgButtonMove = main._gralMng.addSwitchButton("copyMove", "move ?", "Move/ ?copy", GralColor.getColor("wh"), GralColor.getColor("lgn"));
    352      widgButtonMove.setActionChange(actionButtonCmprDelMove);
    353      widgButtonMove.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".fn.");
    354    }
    355    main._gralMng.setPosition(-4, GralPos.size+3.2f, 1, 9, 0, 'r');
    356    widgButtonEsc = main._gralMng.addButton("copyEsc", actionButtonAbort, "esc", null, "close");
    357    widgButtonEsc.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".escape.");
    358    main._gralMng.setPosition(GralPos.same, GralPos.size +2.5f, GralPos.next, GralPos.size+3.0f, 0, 'r', 1);
    359    widgState = main._gralMng.addButton(null, actionShowState, "?", null, "?" );
    360    widgState.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".state.");
    361
    362    if(cmdWind != Ecmd.compare){
    363      //main.gralMng.setPosition(GralPos.refer+3.5f, GralPos.size -3, 1, 12, 0, 'r', 1);
    364      main._gralMng.setPosition(GralPos.same, GralPos.size +2.5f, GralPos.next, GralPos.size + 11, 0, 'r', 1);
    365      //main.gralMng.setPosition(GralPos.same, GralPos.size -3, 16, GralPos.size +14, 0, 'r', 1);
    366      widgSkipDir = main._gralMng.addButton("copySkipDir", actionButtonSkipDir, "copySkipDir", null, "skip dir");
    367      widgSkipDir.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".quest.skipDir.");
    368      widgSkipFile = main._gralMng.addButton("copyskip", actionButtonSkipFile, "copyskip", null, "skip file");
    369      widgSkipFile.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".quest.skipFile.");
    370      widgOverwrFile = main._gralMng.addButton(sTextExecuteForFile, actionOverwriteFile, "copyOverwrite", null, sTextExecuteForFile);
    371      widgOverwrFile.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".quest.wr.");
    372      //widgBtnPause = main.gralMng.addButton("pause", null, "pause", null, "pause");
    373      //widgBtnPause.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".pause.");
    374    }
    375    main._gralMng.setPosition(-4, GralPos.size+3.5f, -13f, -1, 0, 'd', 0.4f);
    376    widgButtonOk = main._gralMng.addButton("copyOk", actionButtonOk, "close", null, "close");
    377    widgButtonOk.setHtmlHelp(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".ok.");
    378
    379  }
    380
    381
    382  protected void closeWindow(){
    383    widgButtonOk.setText("close");
    384    //widgButtonOk.setCmd("close");
    385    filesToCopy.clear();
    386    listEvCheck.clear();
    387    listEvCopy.clear();
    388    state = Estate.inactive;
    389    windConfirmCopy.setVisible(false);
    390    //main.gralMng.setWindowsVisible(windConfirmCopy, null); //set it invisible.
    391  }
    392
    393
    394
    395
    396
    397  /**Last files which are in copy process. Typical contains one file only.
    398   * This list will be filled in {@link #actionButtonCopy} if the copy process will be started.
    399   * It is used in {@link #actionLastSrc} to fill the {@link #filesToCopy}.
    400   * This list remains after copy process to supply "last files".
    401   */
    402  //final List<FileRemote> filesToCopyLast = new LinkedList<FileRemote>();
    403
    404
    405
    406  /**All mode bits of the 3 variables.*/
    407  private int modeCopy(){
    408    int mode = modeCreateCopy | modeOverwrReadonly |modeOverwrDate;
    409    return mode;
    410  }
    411
    412
    413  /**Starts the execution of mark in another thread. Note that the mark works with the walk-file algorithm
    414   * and refreshes the files therewith. The #action.showFilesProcessing is used as callback.
    415   * See {@link FileRemote#refreshAndMark(int, boolean, String, int, int, FileRemoteCallback)}.
    416   */
    417  final void execMark(){
    418    setTexts(Estate.busyCheck);
    419    widgCopyState.setText("busy-check");
    420    widgButtonOk.setText("busy-check");
    421    widgButtonCheck.setState(GralButton.State.Disabled);
    422    widgButtonEsc.setText("abort");
    423    String sSrcMask= widgFromConditions.getText();
    424    //FileSystem: acts in other thread.
    425    //regards mark in first level ?
    426    int depths = srcSomeFiles ? -Integer.MAX_VALUE : Integer.MAX_VALUE;
    427    long bMarkSelect = srcSomeFiles ? 0x200000000L + FileMark.select : 0;
    428    //====>
    429    //srcFile.refreshAndMark(bFirstSelect, sSrcMask, bMarkSelect, depths, callbackFromFilesCheck, action.showFilesProcessing);
    430    srcFile.refreshAndMark(false, sSrcMask, bMarkSelect, depths, callbackFromFilesCheck, action.showFilesProcessing);
    431    widgCopyNameDst.setText(srcDir.getStateDevice());
    432    bFirstSelect = false;
    433  }
    434
    435
    436  final protected void execDel(){
    437    if(state == Estate.checked){
    438      srcFile.deleteMarkedInThread(FileMark.select, callbackFromFilesExec);
    439    } else if(state == Estate.start){
    440    }
    441  }
    442
    443
    444
    445  final protected void execMove() {
    446    String sDst = widgInputDst.getText();
    447    String sDstDir, sDstMask;
    448    int posWildcard = sDst.indexOf('*');
    449    if(posWildcard >0) {
    450      int posSep = sDst.lastIndexOf('/', posWildcard);
    451      sDstDir = sDst.substring(0, posSep+1);
    452      sDstMask = sDst.substring(posSep+1);
    453    } else {
    454      sDstDir = sDst;
    455      sDstMask = null;
    456    }
    457    FileRemote fileDst;
    458    if(FileSystem.isAbsolutePathOrDrive(sDstDir)) {
    459      fileDst = main.fileCluster.getDir(sDstDir);  //maybe a file or directory
    460    } else {
    461      fileDst = srcDir.child(sDstDir);  //relative to source
    462    }
    463    FileRemote.CallbackEvent callback = new FileRemote.CallbackEvent(evSrc, srcFile, null, evConsumerCallbackFromFileMachine, null, evSrc);
    464    //====>
    465    //srcFile.moveChecked(sFilesSrc, fileDst, callback);
    466    setTexts(Estate.busy);
    467    ///
    468  }
    469
    470
    471  /**Starts the execution of copy in another thread. Note that the compy works with a state machine which uses
    472   * the found files in the {@link FileRemote#children()} tree.
    473   * See {@link FileRemote#copyChecked(String, String, int, org.vishia.fileRemote.FileRemote.CallbackEvent)}.
    474   */
    475  final protected void execCopy(){
    476    widgCopyState.setText("busy-copy");
    477    widgButtonOk.setText("busy-copy");
    478    widgButtonEsc.setText("abort");
    479    String sDst = widgInputDst.getText();
    480    String sDstDir, sDstMask;
    481    int posWildcard = sDst.indexOf('*');
    482    if(posWildcard >0) {
    483      int posSep = sDst.lastIndexOf('/', posWildcard);
    484      sDstDir = sDst.substring(0, posSep+1);
    485      sDstMask = sDst.substring(posSep+1);
    486    } else {
    487      sDstDir = sDst;
    488      sDstMask = null;
    489    }
    490    if(!FileSystem.isAbsolutePathOrDrive(sDstDir)) {
    491      sDstDir = srcDir.getAbsolutePath() + "/" + sDstDir;
    492    }
    493    //====>
    494    srcFile.copyChecked(sDstDir, sDstMask, modeCopy(), null, action.showFilesProcessing);  //, evCallback);
    495    //String stateCopy = copyStates.getStateInfo();
    496    setTexts(Estate.busy);
    497    //widgCopyState.setText("State: " + stateCopy);
    498  }
    499
    500
    501  /**Starts the execution of compare in another thread. Note that the compare works with the walk-file algorithm
    502   * and refreshes the files therewith. See {@link FileRemote#refreshAndCompare(FileRemote, int, String, int, org.vishia.fileRemote.FileRemote.CallbackEvent)}.
    503   */
    504  final protected void execCompare(){
    505    String sDst = widgInputDst.getText();
    506    int posSep = sDst.lastIndexOf('/');
    507    int posSep2 = sDst.lastIndexOf('\\');
    508    if(posSep2 >=0 && posSep2 > posSep){ posSep = posSep2; }
    509    int posWildcard = sDst.indexOf('*');
    510    String sDstDir;
    511    if(posWildcard > posSep){
    512      sDstDir = sDst.substring(0, posSep);
    513    } else {
    514      //no asterisk, either it is one file or it is the destination dir:
    515      sDstDir = sDst;
    516    }
    517    FileRemote fileDst;
    518    if(FileSystem.isAbsolutePathOrDrive(sDstDir)) {
    519      fileDst = main.fileCluster.getDir(sDstDir);  //maybe a file or directory
    520    } else {
    521      fileDst = srcDir.child(sDstDir);  //relative to source
    522    }
    523    if(fileDst.isDirectory()){ dirDst = fileDst; }
    524    else { dirDst = fileDst.getParentFile(); }
    525    boolean bOk = true;
    526    //check whether the event is able to occupy, use it to check.
    527    if(evCallback.occupyRecall(100, evSrc, evConsumerCallbackFromFileMachine, null, true) == 0){
    528      if(evCallback.occupyRecall(1000, evSrc, evConsumerCallbackFromFileMachine, null, true) == 0){
    529        System.err.println("FcmdCopyCmd event occupy hangs");
    530        bOk = false;
    531      }
    532    }
    533    if(bOk) {
    534      String sSrcMask= widgFromConditions.getText();
    535      evCallback.sendEvent(FileRemote.CallbackCmd.start);  //sends to myself for showing the state,
    536      //it is a check of sendEvent and it should relinguish the event.
    537      //====>
    538      srcFile.refreshAndCompare(dirDst, 0, sSrcMask, 0, null, action.showFilesProcessing); //evCallback); //evCallback able to use from callback.
    539      //setTexts(Estate.busy);
    540    } else {
    541      widgCopyState.setText("evCallback hangs");
    542      setTexts(Estate.quest);
    543    }
    544    ///
    545  }
    546
    547
    548  final protected void abortCopy(){
    549    //if(fileSrc !=null ) {fileSrc.abortAction();}
    550    for(FileRemote.CallbackEvent ev: listEvCopy){
    551      //ev.copyAbortAll();
    552      //ev.sendEvent(FileRemote.cmdAbortAll);
    553    }
    554    if(action.showFilesProcessing.evAnswer.getDst() !=null) { //don't send if the destination is not set.
    555      action.showFilesProcessing.evAnswer.send(FileRemoteProgressTimeOrder.Answer.abortAll, modeCopy() ); //triggerStateMachine(evSrc, FileRemote.Cmd.abortAll);
    556    }
    557    String sDirSrc = widgShowSrc.getText();
    558    //FileRemote dirSrc = main.fileCluster.getFile(sDirSrc, null); //new FileRemote(sDirSrc);
    559    if(srcDir !=null) { srcDir.abortAction(); }  //to set stateMachine of copy in ready state
    560    else {
    561      System.err.println("FcmdCopyCmd: abort, dirSrc not given.");
    562    }
    563    listEvCheck.clear();
    564    listEvCopy.clear();
    565    filesToCopy.clear();
    566    FcmdCopyCmprDel.this.evCurrentFile = null;
    567    //bLockSrc = false;
    568    //widgButtonOk.setText("close");
    569    //widgButtonOk.setCmd("close");
    570    setTexts(Estate.finit);
    571  }
    572
    573
    574  /**Sets the source and destination depending on the cmd and given {@link #srcFile}, {@link #dirDst}
    575   * The {@link #widgInputDst} will be not changed if {@link #bDstChanged} is set.
    576   */
    577  final void setTextSrcDst(){
    578    //
    579    //show source files, it is only to show, no functionality.
    580    if(srcFile == null){
    581      widgShowSrc.setText("--no source--");
    582    } else {
    583      if(sFilesSrc == null) {
    584        if(srcFile.isDirectory()) { // && cmd == Ecmd.copy) {
    585          if(srcSomeFiles){
    586            widgShowSrc.setText(srcFile.getAbsolutePath() + "/?+");  //copy some files dir/?+ signals, there are more files but add mask into
    587          } else {
    588            widgShowSrc.setText(srcFile.getAbsolutePath() + "/*");  //copy a directory: show dir/* to signal, there are more files.
    589          }
    590        } else {
    591          widgShowSrc.setText(srcFile.getAbsolutePath());         //compare, move or copy only one file: show only srcfile or srcdir
    592        }
    593      } else {
    594        widgShowSrc.setText(srcFile.getAbsolutePath() + "/" + sFilesSrc);  //more as one
    595      }
    596    }
    597    //
    598    if(cmdWind != Ecmd.delete) {
    599      if(dirDst == null){
    600        bufferDstChars.setLength(0); bufferDstChars.append("??");
    601      } else if(!bDstChanged) {
    602        if(cmd == Ecmd.compare) {
    603          FileRemote dirDstCmpr = fileDst !=null && fileDst.isDirectory() ? fileDst : this.dirDst;
    604          bufferDstChars.setLength(0); bufferDstChars.append(dirDstCmpr.getPathChars()); //.append('/').append(sFileDstCopy);
    605        } else {
    606          bufferDstChars.setLength(0);
    607          final FileRemote dstSet;
    608          if(!widgButtonModeDst.isOn() || srcFile.isDirectory() && !fileDst.isDirectory()){
    609            dstSet = dirDst;
    610            bufferDstChars.append(dirDst.getPathChars()); //the directory of the file.
    611          } else {
    612            //select "dst/dst" in mode or
    613            dstSet = fileDst;
    614            bufferDstChars.append(fileDst.getPathChars()); //file or directory
    615          }
    616          //if(cmd == Ecmd.copy || cmd == Ecmd.move){
    617          //if(dirDst == fileDst || fileSrc.isDirectory() && !fileDst.isDirectory()) {  // .. is selected
    618          if(dstSet.isDirectory()) {  // .. is selected
    619            if(srcSomeFiles){
    620              bufferDstChars.append("/*");
    621            } else {
    622              String nameSrc = srcFile.getName();
    623              bufferDstChars.append('/').append(nameSrc);
    624            }
    625          }
    626          if(cmd == Ecmd.copy && srcFile != null && srcFile.isDirectory()) {
    627            bufferDstChars.append("/*");
    628          }
    629        }
    630      }
    631      widgInputDst.setText(bufferDstChars);
    632    }
    633
    634  }
    635
    636
    637  /**Set the texts to any widgets depending on the state of execution and the activated switch key.
    638   * @param newState
    639   */
    640  void setTexts( Estate newState) {  ////
    641    state = newState;
    642    //Texts depending from pressed command button:
    643    String[][] textOk =
    644    { { "check del"  , "move"        , "check copy", "compare" }
    645    , { "check del"  , "move"        , "check copy", "compare" }
    646    , { "busy check" , "busy check"  , "busy check", "compare" }
    647    , { "del checked", "move checked", "copy checked", "compare" }
    648    , { "pause del"  , "pause move"  , "pause copy", "pause cmpr" }
    649    , { "close del"  , "close move"  , "close copy", "close cmpr"  }
    650    };
    651    String[][] textSrc =
    652    { { "set src + dst", "set src + dst", "busy check", "set src + dst", "busy", "set src + dst" }
    653    , { "set dst", "set dst", "busy check", "set dst", "busy", "set dst" }
    654    };
    655    String[] textAbort = { "abort"         , "abort"       , "abort"        , "abort", "abort", "close" };
    656    String[] textDest =  { "---"           , "move to"     , "copy to"      , "compare with"  };
    657
    658    int ix1;
    659    if(cmdWind == Ecmd.delete){
    660      ix1=0;
    661      cmd = Ecmd.delete;
    662      if(cmdWind != Ecmd.delete) {
    663        widgButtonMove.setState(GralButton.State.Off);
    664        widgInputDst.setEditable(false);
    665        widgInputDst.setBackColor(colorGrayed, 0);
    666      }
    667    } else if(cmdWind == Ecmd.compare){
    668      ix1 = 3;
    669      cmd = Ecmd.compare;
    670      widgInputDst.setEditable(true);
    671      widgInputDst.setBackColor(bDstChanged ? colorChangedText : colorNoChangedText, 0);
    672    } else {
    673      //move or copy window:
    674      if(state == Estate.finit) {
    675        widgOverwrFile.setBackColor(GralColor.getColor("lgr"), 0);
    676        widgSkipFile.setBackColor(GralColor.getColor("lgr"), 0);
    677      }
    678      if(widgButtonMove.isOn()) {
    679      ix1 = 1;
    680        cmd = Ecmd.move;
    681        widgInputDst.setEditable(true);
    682        widgInputDst.setBackColor(bDstChanged ? colorChangedText : colorNoChangedText, 0);
    683      } else {
    684        ix1 = 2;
    685        cmd = Ecmd.copy;
    686        widgInputDst.setEditable(true);
    687        widgInputDst.setBackColor(bDstChanged ? colorChangedText : colorNoChangedText, 0);
    688      }
    689    }
    690    if(cmdWind != Ecmd.delete) {
    691      widgInputDst.setPrompt(textDest[ix1]);
    692    }
    693    if(!bDstChanged) {
    694      setTextSrcDst();
    695    }
    696    int ix2;
    697    GralButton.State checkDisable;
    698    boolean setSrcPossible;
    699    switch(state){
    700      case start: setSrcPossible = true; checkDisable = GralButton.State.On; ix2= bFineSelect? 1 : 0; break;
    701      case busyCheck: setSrcPossible = false; checkDisable = GralButton.State.Disabled; ix2=2; break;
    702      case checked: setSrcPossible = false; checkDisable = GralButton.State.On; ix2=3; break;
    703      case quest:
    704      case busy: setSrcPossible = false; checkDisable = GralButton.State.Disabled; ix2=4; break;
    705      case error:
    706      case inactive:
    707      case finit: setSrcPossible = true; checkDisable = GralButton.State.On; ix2=5; break;
    708      default: setSrcPossible = true; checkDisable = GralButton.State.On; ix2=0;
    709    }
    710    String sTextBtnOk = textOk[ix2][ix1];
    711    widgButtonOk.setText(sTextBtnOk);
    712    //String sTextSrc = textSrc[bLockSrc? 1: 0][ix2];
    713    //widgButtonCheck.setText(sTextSrc);
    714    widgButtonCheck.setState(checkDisable);
    715    widgButtonSetSrc.setState(setSrcPossible ? GralButton.State.On : GralButton.State.Disabled);
    716    String sTextAbort = textAbort[ix2];
    717    widgButtonEsc.setText(sTextAbort);
    718
    719  }
    720
    721
    722
    723  /**Invoked with a time order.
    724   *
    725   */
    726  void showCurrentProcessedFileAndDir(FileRemoteProgressTimeOrder order) //FileRemote fileProcessed, int zFiles, boolean bDone) {
    727  { StringBuilder u = new StringBuilder(100);
    728    if(order.currFile !=null) {
    729      widgCopyDirDst.setText(order.currFile.getParent());
    730      widgCopyNameDst.setText(order.currFile.getName());
    731    } else {
    732      widgCopyDirDst.setText("?");
    733      widgCopyNameDst.setText("?");
    734    }
    735    if(order.bDone) {
    736      widgCopyState.setText("ok: "); // + ev1.nrofBytesInFile/1000000 + " M / " + ev1.nrofBytesAll + "M / " + ev1.nrofFiles + " Files");
    737      setTexts(Estate.finit);
    738    }
    739    if(order.quest() !=null) {
    740      switch(order.quest()){
    741        case askDstOverwr:
    742          u.append("overwrite file? ");
    743          widgOverwrFile.setBackColor(GralColor.getColor("lng"), 0);
    744          widgSkipFile.setBackColor(GralColor.getColor("lgn"), 0);
    745          break;
    746        case askDstNotAbletoOverwr:
    747          u.append("cannot overwrite file? ");
    748          widgSkipFile.setBackColor(GralColor.getColor("lrd"), 0);
    749          break;
    750        case askErrorCopy:
    751          u.append("error copy? ");
    752          widgSkipFile.setBackColor(GralColor.getColor("lrd"), 0);
    753          break;
    754        case askErrorDstCreate:
    755          u.append("cannot create? ");
    756          widgSkipFile.setBackColor(GralColor.getColor("lrd"), 0);
    757          break;
    758        case askDstReadonly:
    759          u.append("overwrite readonly file? ");
    760          widgOverwrFile.setBackColor(GralColor.getColor("lng"), 0);
    761          widgSkipFile.setBackColor(GralColor.getColor("lgn"), 0);
    762          break;
    763        case askErrorSrcOpen:
    764          u.append("cannot open sourcefile ");
    765          widgSkipFile.setBackColor(GralColor.getColor("lrd"), 0);
    766          break;
    767        case done:
    768          u.append("ok: "); // + ev1.nrofBytesInFile/1000000 + " M / " + ev1.nrofBytesAll + "M / " + ev1.nrofFiles + " Files");
    769          setTexts(Estate.finit);
    770          break;
    771
    772      }
    773    }
    774    u.append("; Files:").append(Integer.toString(zFiles)).append(": ");
    775    widgCopyState.setText(u.toString());
    776  }
    777
    778
    779  void showFinishState(CharSequence start, SortedTreeWalkerCallback.Counters cnt)
    780  {
    781    FcmdCopyCmprDel.this.zFiles = cnt.nrofLeafss;
    782    FcmdCopyCmprDel.this.zBytes = cnt.nrofBytes;
    783    formatShow.reset();
    784    formatShow.add(start);
    785    formatShow.add(" Files:").addint(cnt.nrofLeafSelected, "3333333331");
    786    //StringBuilder u = new StringBuilder();
    787    //u.append("Files:").append(Integer.toString(cnt.nrofLeafSelected));
    788    if(cnt.nrofLeafSelected != cnt.nrofLeafss){  //u.append(" (").append(Integer.toString(cnt.nrofLeafSelected)).append(")"); }
    789      formatShow.add(" /").addint(cnt.nrofLeafss, "3333333331");
    790    }
    791    if(cnt.nrofBytes > 1000000){
    792      formatShow.addint(cnt.nrofBytes/1000, ", 33331.111 MByte");
    793    }
    794    else if(cnt.nrofBytes > 1000){
    795      formatShow.addint(cnt.nrofBytes, ", 331.111 kByte");
    796    } else {
    797      formatShow.addint(cnt.nrofBytes, ", 331 Byte");
    798    }
    799    widgCopyState.setText(formatShow.toString());
    800  }
    801
    802  void actionConfirmCopy(){
    803
    804  }
    805
    806
    807  /**Will be initialized if the main.gralMng is available.
    808   */
    809  private class Actions
    810  {
    811
    812    @SuppressWarnings("serial")
    813    FileRemoteProgressTimeOrder showFilesProcessing =
    814        new FileRemoteProgressTimeOrder("showFilesProcessing", evSrc, main._gralMng.gralDevice.orderList(), 100)
    815    {
    816      @Override public void executeOrder() {
    817        //System.out.println("showFilesProcessing");
    818        showCurrentProcessedFileAndDir(this); //this.currFile, this.nrFilesProcessed, this.bDone);
    819        //this.currFile = null;  //to invoke second time.
    820      }
    821    };
    822  }
    823
    824  /**Shows the state of FileRemote, especially for debug and problems. */
    825  GralUserAction actionShowState = new GralUserAction("actionConfirmCopy")
    826  {
    827    @Override public boolean exec(int key, GralWidget_ifc widgi, Object... params){
    828      if(KeyCode.isControlFunctionMouseUpOrMenu(key)){
    829        if(srcFile !=null) { widgCopyState.setText(srcFile.getStateDevice()); }
    830        else { widgCopyState.setText("no source file"); }
    831      }
    832      return true;
    833    }
    834  };
    835
    836  /**Opens the confirm-copy window, prepares the list of src files.
    837   */
    838  GralUserAction actionConfirmCopy = new GralUserAction("actionConfirmCopy")
    839  {
    840    /**Opens the confirm-copy window and fills its fields to ask the user whether confirm.
    841     */
    842    @Override public boolean exec(int key, GralWidget_ifc widgi, Object... params)
    843    { //String sSrc, sDstName, sDstDir;
    844      if(KeyCode.isControlFunctionMouseUpOrMenu(key)){
    845        //sCmd: This method was called from a button or with any function key.
    846        //sCmd describes from where it was called.
    847        String sCmd = widgi instanceof GralWidget ? ((GralWidget)widgi).getCmd() : "openCopy";
    848        //
    849        if(state == Estate.inactive){
    850          setTexts(Estate.finit);
    851        }
    852        //if(state.equals("close") || state.equals("check")) {
    853        //if(state == Estate.start || state == Estate.checked || state == Estate.finit || state == Estate.error) {
    854        if(!widgButtonSetSrc.isDisabled()) {
    855          //only if it is ready to check, get the files.
    856          bFirstSelect = true;
    857          filesToCopy.clear();
    858          listEvCheck.clear();
    859          listEvCopy.clear();
    860          FcmdFileCard[] lastFileCards = main.getLastSelectedFileCards();
    861          if(lastFileCards[0] !=null){ ///
    862            fileCardSrc = lastFileCards[0];
    863            fileCardDst = lastFileCards[1];
    864
    865            //widgButtonDst.setState(GralButton.kOff);  //maybe disabled, set off.
    866            List<FileRemote> listFileSrc = fileCardSrc.getSelectedFiles(true, 1);
    867            //String sDirSrc;
    868            if(listFileSrc == null){
    869              //widgShowSrc.setText("??? listFileSrc==null");
    870
    871            } else {
    872              if(listFileSrc.size() ==1){
    873                //only one file is selected:
    874                srcFile = listFileSrc.get(0);
    875                srcDir = srcFile.getParentFile();
    876                srcSomeFiles = false;
    877                sFilesSrc = null;  //only one file,
    878                //widgShowSrc.setText(fileSrc.getAbsolutePath());
    879                if(srcFile.isDirectory()) {
    880                  sFileDstCopy = "*";
    881                } else {
    882                  sFileDstCopy = srcFile.getName();  //name of source file as default for destination.
    883                }
    884              } else {
    885                //more as one file:
    886                sFileDstCopy = "*";
    887                //StringBuilder uFileSrc = new StringBuilder();
    888                //fileSrc = fileCardSrc.currentFile();
    889                srcFile = srcDir = fileCardSrc.currentDir();
    890                srcDir.setMarked(FileMark.selectSomeInDir);
    891                srcSomeFiles = true;
    892                //srcFile = null;
    893                sFilesSrc = null;  //only one file,
    894                //widgShowSrc.setText(dirSrc.getAbsolutePath() + "/?+");
    895                /*
    896                fileSrc = dirSrc
    897                String sSep = "";
    898                for(FileRemote srcFile : listFileSrc){
    899                  srcFile.resetMarked(1);
    900                  uFileSrc.append(sSep).append(srcFile.getName());
    901                  sSep = " : "; //For next one.
    902                  //FileRemote fileSrc = FileRemote.fromFile(srcFile);
    903                  //filesToCopy.add(fileSrc);
    904                }
    905                sFilesSrc = uFileSrc.toString();
    906                uFileSrc.insert(0, " : ").insert(0, fileSrc.getAbsolutePath());
    907                widgShowSrc.setText(uFileSrc);
    908                */
    909              }
    910            }
    911            //sDstName = listFileSrc.size() >1 ? "*"
    912            //           : listFileSrc.size() ==1 ? listFileSrc.get(0).getName() : "??";
    913            //sSrc = fileSrc.getAbsolutePath() + "/" + sDstName;
    914            if(fileCardDst !=null){
    915              dirDst = fileCardDst.currentDir();
    916              fileDst = fileCardDst.currentFile();  //it is ==dirDst if .. is selected.
    917              /*
    918              if(dirDst !=null) {
    919                if(!dirDst.isDirectory()) {
    920                  dirDst = dirDst.getParentFile();  //a file selected, use the directory of the panel.
    921                } else {
    922                  //dirDst.getPathChars(bufferDstChars);
    923                }
    924              }
    925              */
    926              //dirDstCmpr = fileCardDst.currentFile();  //should be a directory, check later before compare.
    927              //sDstDir = dirDst.getAbsolutePath();
    928            } else {
    929              dirDst = null;
    930              fileDst = null;
    931              //sDstDir = "??";
    932            }
    933            //bLockSrc = true;
    934            //widgFromConditions.setText("");
    935          } else { //FileCard not found:
    936            srcFile = null;
    937            dirDst = null;
    938            fileDst = null;
    939
    940            //listFileSrc = null;
    941            //sSrc = "???";
    942            //sDstName = "??";
    943            //sDstDir = "??";
    944            widgShowSrc.setText("??");
    945          }
    946          /*
    947          String sTextDst = widgCopyDirDst.getText().trim();
    948          if(!sCmd.equals("setSrc") || sTextDst.length() == 0){
    949            //set the destination only if it is not set on button setSrc
    950            widgCopyDirDst.setText(sDstDir);
    951            widgCopyDirDst.setBackColor(colorNoChangedText, 0);
    952            bDstChanged = false;
    953            widgCopyNameDst.setText(sDstName);
    954          }
    955          */
    956          boolean setVisible = true; //state == Estate.inactive;
    957          bDstChanged = false;
    958          if(widgInputDst !=null) {
    959            widgInputDst.setBackColor(colorNoChangedText, 0);
    960          }
    961          setTexts(Estate.start);
    962          //widgButtonOk.setText("check");
    963          //widgButtonOk.setCmd("check");
    964          widgCopyState.setText("check?", 0);
    965          if(setVisible){
    966            widgButtonOk.setPrimaryWidgetOfPanel();
    967            windConfirmCopy.setVisible(true);
    968            main.gui.setHelpUrl(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".");
    969          }
    970          //widgButtonMove.setValue(GralMng_ifc.cmdSet, 0, 0);
    971          zFiles = 0; zBytes = 0;
    972        }
    973        windConfirmCopy.setFocus();
    974        //main.gralMng.setWindowsVisible(windConfirmCopy, posWindConfirmCopy);
    975        main.gui.setHelpUrl(main.cargs.dirHtmlHelp + "/Fcmd.html#Topic.FcmdHelp." + helpPrefix + ".");
    976      }
    977      return true;
    978   }  };
    979
    980
    981
    982   /**Opens the confirm-copy window, prepares the list of src files.
    983    * It is Key F5 for copy command from the classic NortonCommander.
    984    * The OK-key is designated to "check". On button pressed the {@link #actionButtonCopy} is called,
    985    * with the "check" case.
    986    */
    987   GralUserAction actionCheck = new GralUserAction("actionCheck")
    988   {
    989     /**Opens the confirm-copy window and fills its fields to ask the user whether confirm.
    990      * @param dst The path which is selected as destination. It may be a directory or a file
    991      * @param src The path which is selected as source. It may be a directory or a file.
    992      */
    993     @Override public boolean exec(int key, GralWidget_ifc widgi, Object... params)
    994     { //String sSrc, sDstName, sDstDir;
    995       if(KeyCode.isControlFunctionMouseUpOrMenu(key)){
    996         if(!widgButtonCheck.isDisabled()){
    997         //if(state == Estate.start || state == Estate.checked) { //widgg.sCmd.equals("check")){
    998           execMark();
    999         }
    1000       }
    1001       return true;
    1002     }
    1003   };
    1004
    1005
    1006
    1007   protected GralUserAction actionSetDst = new GralUserAction("actionSetDst") ///
    1008   { @Override public boolean exec(int key, GralWidget_ifc widgP, Object... params)
    1009     { if(KeyCode.isControlFunctionMouseUpOrMenu(key)){
    1010         GralButton widgb = (GralButton)(widgP);
    1011         FcmdFileCard[] lastFileCards = main.getLastSelectedFileCards();
    1012         fileCardDst = lastFileCards[0];
    1013         dirDst = fileCardDst.currentDir();
    1014         CharSequence sText = dirDst.getAbsolutePath();
    1015         /*
    1016         if(sFilesSrc == null || sFilesSrc.isEmpty()){
    1017           StringBuilder u = new StringBuilder(sText);
    1018           sText = u.append("/").append( fileSrc.getName());
    1019         }
    1020         */
    1021         bDstChanged = false;
    1022         setTextSrcDst();
    1023       }
    1024       return true;
    1025     }
    1026   };
    1027
    1028
    1029   protected GralUserAction actionChgModeDst = new GralUserAction("actionChgModeDst") ///
    1030   { @Override public boolean exec(int key, GralWidget_ifc widgP, Object... params)
    1031     { if(KeyCode.isControlFunctionMouseUpOrMenu(key)){
    1032         setTextSrcDst();
    1033       }
    1034       return true;
    1035     }
    1036   };
    1037
    1038
    1039  protected GralUserAction actionEnterTextInDst = new GralUserAction("actionSelectMask")
    1040  { @Override public boolean exec(int key, GralWidget_ifc widgi, Object... params)
    1041    { if(key == KeyCode.valueChanged) {
    1042        String text = widgInputDst.getText();
    1043        if(StringFunctions.compare(text, bufferDstChars) ==0) {
    1044          //unchanged text or the original text again:
    1045          widgInputDst.setBackColor(colorNoChangedText, 0);
    1046          bDstChanged = false;
    1047        } else {
    1048          widgInputDst.setBackColor(colorChangedText, 0);
    1049          bDstChanged = true;
    1050        }
    1051      } else {
    1052        Debugutil.stop();
    1053      }
    1054      return true;
    1055    }
    1056  };
    1057
    1058  GralUserAction actionOverwrReadonly = new GralUserAction("actionOverwrReadonly")
    1059  {
    1060    @Override public boolean userActionGui(int key, GralWidget infos, Object... params){
    1061      if(KeyCode.isControlFunctionMouseUpOrMenu(key)){
    1062        switch(modeOverwrReadonly){
    1063        case FileRemote.modeCopyReadOnlyAks:
    1064          modeOverwrReadonly= FileRemote.modeCopyReadOnlyOverwrite;
    1065          widgdChoiceOverwrReadOnly.setText("yes ?no ?ask");
    1066          widgdChoiceOverwrReadOnly.setBackColor(GralColor.getColor("lgn"), 0);
    1067          break;
    1068        case FileRemote.modeCopyReadOnlyNever:
    1069          modeOverwrReadonly= FileRemote.modeCopyReadOnlyAks;
    1070          widgdChoiceOverwrReadOnly.setText("ask ?yes ?no");
    1071          widgdChoiceOverwrReadOnly.setBackColor(GralColor.getColor("lam"), 0);
    1072          break;
    1073        default:
    1074          modeOverwrReadonly= FileRemote.modeCopyReadOnlyNever;
    1075          widgdChoiceOverwrReadOnly.setText("no ?ask ?yes");
    1076          widgdChoiceOverwrReadOnly.setBackColor(GralColor.getColor("lrd"), 0);
    1077          break;
    1078        }
    1079      }
    1080      return true;
    1081  } };
    1082
    1083
    1084
    1085  GralUserAction actionOverwrDate = new GralUserAction("actionOverwrDate")
    1086  {
    1087    @Override public boolean userActionGui(int key, GralWidget infos, Object... params){
    1088      if(KeyCode.isControlFunctionMouseUpOrMenu(key)){
    1089        switch(modeOverwrDate){
    1090        case FileRemote.modeCopyExistAsk:
    1091          modeOverwrDate= FileRemote.modeCopyExistNewer;
    1092          widgdChoiceOverwrExists.setText("newer ?older?all ?no?ask");
    1093          widgdChoiceOverwrExists.setBackColor(GralColor.getColor("lpk"),0);
    1094          break;
    1095        case FileRemote.modeCopyExistNewer:
    1096          modeOverwrDate= FileRemote.modeCopyExistOlder;
    1097          widgdChoiceOverwrExists.setText("older ?all ?no?ask?newer");
    1098          widgdChoiceOverwrExists.setBackColor(GralColor.getColor("lbl"),0);
    1099          break;
    1100        case FileRemote.modeCopyExistOlder:
    1101          modeOverwrDate= FileRemote.modeCopyExistAll;
    1102          widgdChoiceOverwrExists.setText("all ? no?ask?newer?older");
    1103          widgdChoiceOverwrExists.setBackColor(GralColor.getColor("lgn"),0);
    1104          break;
    1105        case FileRemote.modeCopyExistAll:
    1106          modeOverwrDate= FileRemote.modeCopyExistSkip;
    1107          widgdChoiceOverwrExists.setText("no ?ask?newer?older?all");
    1108          widgdChoiceOverwrExists.setBackColor(GralColor.getColor("lrd"),0);
    1109          break;
    1110        default:
    1111          modeOverwrDate= FileRemote.modeCopyExistAsk;
    1112          widgdChoiceOverwrExists.setText("ask ?newer?older?all ?no");
    1113          widgdChoiceOverwrExists.setBackColor(GralColor.getColor("lam"),0);
    1114          break;
    1115        }
    1116      }
    1117      return true;
    1118  } };
    1119
    1120
    1121
    1122  GralUserAction actionCreateCopy = new GralUserAction("actionButtonCreateCopy")
    1123  {
    1124    @Override public boolean userActionGui(int key, GralWidget infos, Object... params){
    1125      if(KeyCode.isControlFunctionMouseUpOrMenu(key)){
    1126        switch(modeCreateCopy){
    1127        case FileRemote.modeCopyCreateAsk:
    1128          modeCreateCopy = FileRemote.modeCopyCreateYes;
    1129          widgdChoiceCreateNew.setText("yes ?no ?ask");
    1130          widgdChoiceCreateNew.setBackColor(GralColor.getColor("lgn"), 0);
    1131          break;
    1132        case FileRemote.modeCopyCreateYes:
    1133          modeCreateCopy = FileRemote.modeCopyCreateNever;
    1134          widgdChoiceCreateNew.setText("no ?ask ?yes");
    1135          widgdChoiceCreateNew.setBackColor(GralColor.getColor("lrd"), 0);
    1136          break;
    1137        default:
    1138          modeCreateCopy = FileRemote.modeCopyCreateAsk;
    1139          widgdChoiceCreateNew.setText("ask ?yes ?no");
    1140          widgdChoiceCreateNew.setBackColor(GralColor.getColor("lam"), 0);
    1141          break;
    1142        }
    1143      }
    1144      return true;
    1145  } };
    1146
    1147
    1148   /**Opens the confirm-copy window, prepares the list of src files.
    1149    * It is Key F5 for copy command from the classic NortonCommander.
    1150    * The OK-key is designated to "check". On button pressed the {@link #actionButtonCopy} is called,
    1151    * with the "check" case.
    1152    */
    1153   GralUserAction actionButtonCmprDelMove = new GralUserAction("actionButtonDel")
    1154   {
    1155     /**Opens the confirm-copy window and fills its fields to ask the user whether confirm.
    1156      * @param dst The path which is selected as destination. It may be a directory or a file
    1157      * @param src The path which is selected as source. It may be a directory or a file.
    1158      */
    1159     @Override public boolean exec(int key, GralWidget_ifc widgi, Object... params)
    1160     { //String sSrc, sDstName, sDstDir;
    1161       if(KeyCode.isControlFunctionMouseUpOrMenu(key)){
    1162         setTexts(state);
    1163       }
    1164       return true;
    1165     }
    1166   };
    1167
    1168
    1169
    1170  /**Action for any button of the confirm-copy window.
    1171   * in a loop FileRemote.copyTo(dst) is called for any selected file. It may be one file,
    1172   * or more files in more selected lines.
    1173   * The copy process itself is executed in an own thread in management of the FileRemote implementation,
    1174   * see {@link org.vishia.fileLocalAccessor.FileRemoteAccessorLocalFile#addCommission(org.vishia.util.FileRemoteAccessor.Commission)}
    1175   * for local files. The copy process can be executed in an remote device without copying of data
    1176   * between this device (PC) and the remote device, if the commission is organized in the remote device itself.
    1177   * <br><br>
    1178   * To notify for success or progression of the copy process some events are used.
    1179   * See the {@link #success} {@link EventConsumer} in this class. The event instance is given to the
    1180   * {@link FileRemote#copyTo(FileRemote, EventCmdPingPongType)} invocation. It is used to callback either from the thread
    1181   * which copies local or from the thread which receives the copy response telegrams for remote communication.
    1182   * <br><br>
    1183   * All Events which are created are stored in the {@link #listEvCopy}. If the callback occurs, the event
    1184   * will be removed from the list. The list is only used to check whether the copy action is succeeded
    1185   * respectively to check whether all copy actions are succeeded. If a copy success callback is not received,
    1186   * for example because a remote device hangs or the communication fails, the copy process hasn't no
    1187   * progression. The operator on this machine sees this situation because the progression bar stands.
    1188   * The operator can abort the copy process to preset to a default empty state.
    1189   */
    1190  protected GralUserAction actionButtonOk = new GralUserAction("actionButtonCopy")
    1191  { @Override public boolean exec(int key, GralWidget_ifc widgg, Object... params)
    1192    { if(KeyCode.isControlFunctionMouseUpOrMenu(key)){
    1193        if(state == Estate.start) { //widgg.sCmd.equals("check")){
    1194          if(cmd == Ecmd.delete){
    1195            execMark();
    1196          } else if(cmd == Ecmd.copy || bFineSelect){
    1197            execMark();
    1198          } else if(cmd == Ecmd.move){
    1199            execMark();
    1200          } else if(cmd == Ecmd.compare){
    1201            execCompare();
    1202          }
    1203        } else if(state == Estate.checked) { //widgg.sCmd.equals("copy")) {
    1204          switch(cmd){
    1205            case copy: execCopy(); break;
    1206            case move: execMove(); break;
    1207            case delete: execDel(); break;
    1208            case compare: execCompare(); break;
    1209          }//switch
    1210        } else if(state == Estate.finit) { //widgg.sCmd.equals("close")){
    1211          closeWindow();
    1212        } else {
    1213          //should be state pause
    1214          action.showFilesProcessing.evAnswer.send(FileRemoteProgressTimeOrder.Answer.cont, modeCopy()); //triggerStateMachine(evSrc, FileRemote.Cmd.docontinue);
    1215        }
    1216      }
    1217      return true;
    1218    }
    1219  };
    1220
    1221
    1222
    1223
    1224  protected GralUserAction actionButtonAbort = new GralUserAction("actionButtonAbort")
    1225  { @Override public boolean exec(int key, GralWidget_ifc widgg, Object... params)
    1226    { if(KeyCode.isControlFunctionMouseUpOrMenu(key)){
    1227        switch(state){ //inactive, start, checked, busyCheck, busy, quest, error, finit
    1228          case start: {
    1229            setTexts(Estate.finit);
    1230          } break;
    1231          case inactive:
    1232          case error:
    1233          case finit: closeWindow(); break;
    1234          case quest:
    1235          case busy: abortCopy(); break;
    1236          case checked: abortCopy(); break;
    1237          case busyCheck: abortCopy(); break;
    1238        }
    1239        //trigger a copy statemachine, only effected if in such a state.
    1240        abortCopy();
    1241      }
    1242      return true;
    1243    }
    1244  };
    1245
    1246
    1247
    1248
    1249
    1250  /**This action is used to skip over the current showed file while copying. Copying of the selected file
    1251   * should be aborted and that file should be deleted.
    1252   *
    1253   */
    1254  protected GralUserAction actionOverwriteFile = new GralUserAction(sTextExecuteForFile)
    1255  { @Override public boolean userActionGui(int key, GralWidget widgg, Object... params)
    1256    { if(KeyCode.isControlFunctionMouseUpOrMenu(key)){
    1257        if(action.showFilesProcessing.quest() == FileRemote.CallbackCmd.askDstOverwr
    1258             || action.showFilesProcessing.quest() == FileRemote.CallbackCmd.askDstReadonly) {
    1259          action.showFilesProcessing.modeCopyOper = modeCopy();
    1260          action.showFilesProcessing.evAnswer.send(FileRemoteProgressTimeOrder.Answer.overwrite, modeCopy() );
    1261          widgSkipFile.setBackColor(GralColor.getColor("wh"), 0);
    1262          widgOverwrFile.setBackColor(GralColor.getColor("wh"), 0);
    1263        } else {
    1264          action.showFilesProcessing.evAnswer.send(FileRemoteProgressTimeOrder.Answer.cont, modeCopy() ); //triggerStateMachine(evSrc, FileRemote.Cmd.docontinue);
    1265        }
    1266        //widgCopyNameDst.setText("");
    1267        widgCopyState.setText("skipped");
    1268      }
    1269      return true;
    1270    }
    1271  };
    1272
    1273
    1274
    1275
    1276  /**This action is used to skip over the current showed file while copying. Copying of the selected file
    1277   * should be aborted and that file should be deleted.
    1278   *
    1279   */
    1280  protected GralUserAction actionButtonSkipFile = new GralUserAction("actionButtonSkipFile")
    1281  { @Override public boolean userActionGui(int key, GralWidget widgg, Object... params)
    1282    { if(KeyCode.isControlFunctionMouseUpOrMenu(key)){
    1283        if(evCurrentFile !=null){
    1284          int modeCopyOper = modeCopy();
    1285          //action.showFilesProcessing.answer(FileRemoteProgressTimeOrder.Answer.abortFile);
    1286          action.showFilesProcessing.evAnswer.send(FileRemoteProgressTimeOrder.Answer.abortFile, modeCopy() );
    1287        }
    1288        else if(action.showFilesProcessing !=null) {
    1289          action.showFilesProcessing.modeCopyOper = modeCopy();
    1290          action.showFilesProcessing.evAnswer.send(FileRemoteProgressTimeOrder.Answer.abortFile, modeCopy() ); //;
    1291
    1292        }
    1293        widgCopyNameDst.setText("");
    1294        widgCopyState.setText("skipped");
    1295        widgSkipFile.setBackColor(GralColor.getColor("wh"), 0);
    1296        widgOverwrFile.setBackColor(GralColor.getColor("wh"), 0);
    1297      }
    1298      return true;
    1299    }
    1300  };
    1301
    1302
    1303  /**This action is used to skip over the current showed file while copying. Copying of the selected file
    1304   * should be aborted and that file should be deleted.
    1305   *
    1306   */
    1307  protected GralUserAction actionButtonSkipDir = new GralUserAction("actionButtonSkipDir")
    1308  { @Override public boolean userActionGui(int key, GralWidget widgg, Object... params)
    1309    { if(KeyCode.isControlFunctionMouseUpOrMenu(key)){
    1310        if(evCurrentFile !=null){
    1311          int modeCopyOper = modeCopy();
    1312          //evCurrentFile.copySkipDir(modeCopyOper);
    1313        }
    1314        action.showFilesProcessing.evAnswer.send(FileRemoteProgressTimeOrder.Answer.abortDir, modeCopy() ); //triggerStateMachine(evSrc, FileRemote.Cmd.abortAll);
    1315        widgSkipFile.setBackColor(GralColor.getColor("wh"), 0);
    1316        widgOverwrFile.setBackColor(GralColor.getColor("wh"), 0);
    1317      }
    1318      return true;
    1319    }
    1320  };
    1321
    1322
    1323
    1324  protected GralUserAction actionSelectMask = new GralUserAction("actionSelectMask")
    1325  { @Override public boolean exec(int key, GralWidget_ifc widgi, Object... params)
    1326    { String sContent = ((GralTextField_ifc)widgi).getText();
    1327      boolean empty = sContent.isEmpty();
    1328      System.out.println("actionSelectMask");
    1329      if(empty == bFineSelect){
    1330        bFineSelect = !empty;
    1331        setTexts(state);
    1332      }
    1333      return false;
    1334    }
    1335  };
    1336
    1337
    1338
    1339
    1340
    1341  private void eventConsumed(EventObject evp, boolean ok){
    1342    FileRemote.CallbackEvent ev = (FileRemote.CallbackEvent)evp;
    1343    listEvCopy.remove(ev);
    1344    int nrofPendingFiles = listEvCopy.size();
    1345
    1346    /*
    1347    //int percent = (int)(nrofPendingFiles * 100 / zFiles);  //- filesToCopy.size();
    1348    widgProgressAll.setValue(100);
    1349    if(ok){
    1350      File file = ev.getFileSrc();
    1351      FileCompare.Result cmprResult = fileCardSrc.searchCompareResult(file);
    1352      if(cmprResult !=null){
    1353        cmprResult.setToEqual();
    1354      }
    1355      fileCardSrc.fillInCurrentDir();  //maybe changed if dst = src or if moved.
    1356      if(fileCardDst !=null){
    1357        fileCardDst.fillInCurrentDir();
    1358      }
    1359    }
    1360    */
    1361    if(nrofPendingFiles == 0){
    1362      if(!ok){
    1363        widgCopyState.setText("error");
    1364        widgButtonOk.setText("quit");
    1365        //widgButtonOk.setCmd("quit");
    1366      } else {
    1367        widgButtonOk.setText("close");
    1368        //widgButtonOk.setCmd("close");
    1369      }
    1370      widgButtonEsc.setText("close");
    1371      //widgButtonEsc.setCmd("close");
    1372      //windConfirmCopy.setVisible(false);
    1373    }
    1374  }
    1375
    1376
    1377
    1378
    1379  /**Instance of an event consumer which is used for all callback actions from the FileRemote machine.
    1380   * The given event contains a command which depends on the action which is done by the file state machine or the file process.
    1381   * Especially
    1382   * <ul>
    1383   * <li>{@link FileRemote.CallbackCmd#nrofFilesAndBytes}: shows the progress of the action.
    1384   * </ul>
    1385   */
    1386  EventConsumer evConsumerCallbackFromFileMachine = new EventConsumer(){
    1387    @Override public int processEvent(EventObject ev)
    1388    {
    1389      FileRemote.CallbackEvent ev1 = (FileRemote.CallbackEvent)ev;
    1390      FileRemote.CallbackCmd cmd = ev1.getCmd();
    1391      String sCmd = cmd.name();
    1392      System.out.println("FcmdCopy - callbackCopy;" + sCmd);
    1393      switch(ev1.getCmd()){
    1394        case start: {
    1395          setTexts(Estate.busy);
    1396        } break;
    1397        case doneCheck:{ ///
    1398          //if(listEvCheck.remove(ev)){  ///
    1399            FcmdCopyCmprDel.this.evCurrentFile = ev1;
    1400            zFiles = ev1.nrofFiles;
    1401            zBytes = ev1.nrofBytesAll;
    1402            //int nrofPendingFiles = listEvCheck.size();
    1403            //if(nrofPendingFiles == 0){
    1404              //TODO check dst space
    1405              widgCopyState.setText("files:" + zFiles + ", size:" + zBytes);
    1406              //widgButtonOk.setText("copy");
    1407              //widgButtonOk.setCmd("copy");
    1408              //widgButtonSrc.setText("set src");
    1409              //widgButtonSrc.setCmd("setSrc");
    1410            //}
    1411
    1412          //} else {
    1413            //unexpected doneCheck:
    1414          //}
    1415          setTexts(Estate.checked);
    1416        } break;
    1417        case copyDir:{
    1418          FcmdCopyCmprDel.this.evCurrentFile = ev1;
    1419          String sPath = StringFunctions.z_StringJc(ev1.fileName);
    1420          widgCopyNameDst.setText(sPath);
    1421        } break;
    1422        case nrofFilesAndBytes:{
    1423          FcmdCopyCmprDel.this.evCurrentFile = ev1;
    1424          int percent = ev1.promilleCopiedBytes / 10;
    1425          widgProgressFile.setValue(percent);
    1426          widgProgressAll.setValue(ev1.promilleCopiedFiles / 10);
    1427          widgCopyNameDst.setText(StringFunctions.z_StringJc(ev1.fileName));
    1428          widgCopyState.setText("... " + ev1.nrofBytesInFile/1000000 + " M / " + ev1.nrofBytesAll + "M / " + ev1.nrofFiles + " Files");
    1429        }break;
    1430        case askDstOverwr: {
    1431          FcmdCopyCmprDel.this.evCurrentFile = ev1;
    1432          widgCopyNameDst.setText("exists: " + StringFunctions.z_StringJc(ev1.fileName));
    1433          widgSkipFile.setBackColor(GralColor.getColor("am"), 0);
    1434          widgOverwrFile.setBackColor(GralColor.getColor("lrd"), 0);
    1435        } break;
    1436        case askDstReadonly: {
    1437            FcmdCopyCmprDel.this.evCurrentFile = ev1;
    1438            widgCopyNameDst.setText("read only: " + StringFunctions.z_StringJc(ev1.fileName));
    1439            widgSkipFile.setBackColor(GralColor.getColor("am"), 0);
    1440            widgOverwrFile.setBackColor(GralColor.getColor("lrd"), 0);
    1441        } break;
    1442        case askDstNotAbletoOverwr: {
    1443          FcmdCopyCmprDel.this.evCurrentFile = ev1;
    1444          widgCopyNameDst.setText("can't overwrite: " + StringFunctions.z_StringJc(ev1.fileName));
    1445          widgSkipFile.setBackColor(GralColor.getColor("lrd"), 0);
    1446          widgOverwrFile.setBackColor(GralColor.getColor("am"), 0);
    1447        } break;
    1448        case askErrorDstCreate: {
    1449          FcmdCopyCmprDel.this.evCurrentFile = ev1;
    1450          widgCopyNameDst.setText("can't create: " + StringFunctions.z_StringJc(ev1.fileName));
    1451          widgOverwrFile.setBackColor(GralColor.getColor("lrd"), 0);
    1452        } break;
    1453        case askErrorCopy: {
    1454          FcmdCopyCmprDel.this.evCurrentFile = ev1;
    1455          widgCopyNameDst.setText("copy error: " + StringFunctions.z_StringJc(ev1.fileName));
    1456          widgSkipFile.setBackColor(GralColor.getColor("lrd"), 0);
    1457          widgOverwrFile.setBackColor(GralColor.getColor("am"), 0);
    1458        } break;
    1459        case error: {
    1460          FcmdCopyCmprDel.this.evCurrentFile = null;
    1461          widgCopyState.setText("error");
    1462          setTexts(Estate.error);
    1463          eventConsumed(ev, false);
    1464        }break;
    1465        case nok: {
    1466          FcmdCopyCmprDel.this.evCurrentFile = null;
    1467          widgCopyState.setText("nok");
    1468          setTexts(Estate.error);
    1469          eventConsumed(ev, false);
    1470        }break;
    1471        case done: {
    1472          FcmdCopyCmprDel.this.evCurrentFile = null;
    1473          widgCopyState.setText("ok: " + ev1.nrofBytesInFile/1000000 + " M / " + ev1.nrofBytesAll + "M / " + ev1.nrofFiles + " Files");
    1474          eventConsumed(ev, true);
    1475          setTexts(Estate.finit);
    1476        }break;
    1477        default:
    1478          FcmdCopyCmprDel.this.evCurrentFile = ev1;
    1479
    1480      }
    1481      //windConfirmCopy.setWindowVisible(false);
    1482      return 1;
    1483    }
    1484    @Override public String toString(){ return "FcmdCopy-success"; }
    1485
    1486
    1487  };
    1488
    1489
    1490
    1491
    1492  /**This event instance with back event and a possible command event as opponent is generally used for invoke and callback to routines
    1493   * for file handling. That methods should be execute in another thread. Only one process can be run for one of this window for
    1494   * mark, move, copy, compare and delete. Therefore only one event instance is necessary which is reused.
    1495   * For hanging processes there is an "abort" button which sends the abort event at last. Usual the hanging is forced by an
    1496   * Exception while handling files or while communication with an device. In that cases the exception had terminate the other process already,
    1497   * so the abort command for this event is not used and not necessary. But if the process does not hang and it should be aborted
    1498   * that event is essential.
    1499   * <br><br>
    1500   * If the event will be reused the "abort" was send for a longer time (at least 1 second for manual handling, pressing buttons).
    1501   * Therefore it can be occupied usual without waiting, at least with thread switch to finish execution of the event.
    1502   * See {@link EventCmdPingPongType#occupyRecall(int, EventSource, EventConsumer, org.vishia.event.EventThread, boolean)}
    1503   */
    1504  FileRemote.CallbackEvent evCallback = new FileRemote.CallbackEvent(evConsumerCallbackFromFileMachine, null, evSrc);
    1505
    1506
    1507
    1508
    1509  FileRemoteCallback callbackFromFilesCheck = new FileRemoteCallback() {
    1510    @Override public void start(FileRemote startDir) {
    1511      fileProcessed = null;
    1512    }
    1513
    1514    @Override public Result offerParentNode(FileRemote file) {
    1515      dirProcessed = file;
    1516      return Result.cont;
    1517    }
    1518
    1519    /**Finish a directory, check whether a file panel should be refreshed.
    1520     * @see org.vishia.util.SortedTreeWalkerCallback#finishedParentNode(java.lang.Object, org.vishia.util.SortedTreeWalkerCallback.Counters)
    1521     */
    1522    @Override public Result finishedParentNode(FileRemote dir, FileRemoteCallback.Counters cnt) {
    1523      main.refreshFilePanel(dir);
    1524      return Result.cont;
    1525    }
    1526
    1527
    1528
    1529    @Override public Result offerLeafNode(FileRemote file, Object info) {
    1530      boolean bShow = (fileProcessed == null);
    1531      //actionShowFilesCmp.fileProcessed = file;
    1532      //actionShowFilesCmp.zFiles +=1;
    1533      if(bShow){
    1534        //actionShowFilesCmp.addToList(widgButtonShowSrc.gralMng().gralDevice.orderList(), 300);
    1535      }
    1536      return Result.cont;
    1537    }
    1538
    1539
    1540    @Override public boolean shouldAborted(){
    1541      return false;
    1542    }
    1543
    1544    @Override public void finished(FileRemote startFile, SortedTreeWalkerCallback.Counters cnt) {
    1545      showFinishState("checked ", cnt);
    1546      main.refreshFilePanel(startFile.getParentFile());  //The start file is any file or directory in parent. A directory is refreshed by finishParentNode already.
    1547      setTexts(Estate.checked);
    1548    }
    1549
    1550
    1551  };
    1552
    1553
    1554
    1555  FileRemoteCallback callbackFromFilesExec = new FileRemoteCallback() {
    1556    @Override public void start(FileRemote startDir) {  }
    1557
    1558    @Override public Result offerParentNode(FileRemote file) {
    1559      return Result.cont;
    1560    }
    1561
    1562    @Override public Result finishedParentNode(FileRemote dir, FileRemoteCallback.Counters cnt) {
    1563      String path = dir.getAbsolutePath();
    1564      showFinishState(path, cnt);
    1565      main.refreshFilePanel(dir);
    1566      return Result.cont;
    1567    }
    1568
    1569
    1570
    1571    @Override public Result offerLeafNode(FileRemote file, Object info) {
    1572      return Result.cont;
    1573    }
    1574
    1575
    1576    @Override public boolean shouldAborted(){
    1577      return false;
    1578    }
    1579
    1580    @Override public void finished(FileRemote startFile, SortedTreeWalkerCallback.Counters cnt) {
    1581      showFinishState("done", cnt);
    1582      setTexts(Estate.finit);
    1583      main.refreshFilePanel(startFile.getParentFile());  //The start file is any file or directory in parent. A directory is refreshed by finishParentNode already.
    1584    }
    1585
    1586
    1587    @Override public String toString(){ return "callbackFromFilesExec"; }
    1588
    1589  };
    1590
    1591
    1592  enum Estate{ inactive, start, checked, busyCheck, busy, quest, error, finit};
    1593
    1594  enum Ecmd{ copy, move, delete, compare};
    1595
    1596  void stop(){}
    1597
    1598}