    001package org.vishia.guiInspc;
    002
    003import java.io.File;
    004import java.io.IOException;
    005import java.util.LinkedList;
    006import java.util.List;
    007import java.util.Map;
    008import java.util.TreeMap;
    009
    010import org.vishia.byteData.VariableAccess_ifc;
    011import org.vishia.communication.InterProcessCommFactorySocket;
    012import org.vishia.fileRemote.FileCluster;
    013import org.vishia.fileRemote.FileRemote;
    014import org.vishia.gral.area9.GuiCallingArgs;
    015import org.vishia.gral.area9.GuiCfg;
    016import org.vishia.gral.area9.GralArea9MainCmd;
    017import org.vishia.gral.base.GralButton;
    018import org.vishia.gral.base.GralMenu;
    019import org.vishia.gral.base.GralMng;
    020import org.vishia.gral.base.GralPanelActivated_ifc;
    021import org.vishia.gral.base.GralPanelContent;
    022import org.vishia.gral.base.GralPos;
    023import org.vishia.gral.base.GralShowMethods;
    024import org.vishia.gral.base.GralWidget;
    025import org.vishia.gral.ifc.GralColor;
    026import org.vishia.gral.ifc.GralPlugUser2Gral_ifc;
    027import org.vishia.gral.ifc.GralPlugUser_ifc;
    028import org.vishia.gral.ifc.GralUserAction;
    029import org.vishia.gral.ifc.GralWidget_ifc;
    030import org.vishia.gral.widget.GralColorSelector;
    031import org.vishia.inspcPC.InspcAccess_ifc;
    032import org.vishia.inspcPC.InspcPlugUser_ifc;
    033import org.vishia.inspcPC.InspcTargetAccessData;
    034import org.vishia.inspcPC.UserInspcPlug_ifc;
    035import org.vishia.inspcPC.accTarget.InspcTargetAccessor;
    036import org.vishia.inspcPC.mng.InspcMng;
    037import org.vishia.inspectorTarget.Inspector;
    038import org.vishia.msgDispatch.LogMessage;
    039import org.vishia.msgDispatch.LogMessageFile;
    040import org.vishia.util.Assert;
    041import org.vishia.util.CompleteConstructionAndStart;
    042import org.vishia.util.FileSystem;
    043import org.vishia.util.KeyCode;
    044
    045public class InspcGui implements CompleteConstructionAndStart //extends GuiCfg
    046{
    047
    048  /**Version, history and license
    049   * <ul>
    050   * <li>2016-12-30 Hartmut chg: The buttons for log, retry, get by handle are not part of {@link InspcViewTargetComm}
    051   * <li>2016-01-24 Hartmut new: cmd line argument -cycle= for cycletime
    052   * <li>2015-01-27 Hartmut new: Test {@link #actionGetValueByHandleIntern}
    053   * <li>2015-01-27 Hartmut new: Now initialized the {@link GralShowMethods} for usage on edit fields. An edit field
    054   *   can use the {@link GralShowMethods#syncVariableOnFocus} if the text was changed.
    055   *   It invokes {@link VariableAccess_ifc#setString(String)} which changed the content of the variable on their target.
    056   * <li>2012-08-10 Hartmut A default directory for curve config files given with argument "-dirCurves=".
    057   * <li>2012-04-17 Hartmut new: Parameter {@link CallingArguments#bUseGetValueByIndex} for downward compatibility
    058   *
    059   * <li>2011-04-20 Don't derive this class from {@link GuiCfg}, instead uses the inner class {@link InspcGuiCfg}.
    060   *   It is a problem of order of instantiation.
    061   * <li>2011-04-00 Hartmut creation.
    062   * </ul>
    063   *
    064   * <b>Copyright/Copyleft</b>:
    065   * For this source the LGPL Lesser General Public License,
    066   * published by the Free Software Foundation is valid.
    067   * It means:
    068   * <ol>
    069   * <li> You can use this source without any restriction for any desired purpose.
    070   * <li> You can redistribute copies of this source to everybody.
    071   * <li> Every user of this source, also the user of redistribute copies
    072   *    with or without payment, must accept this license for further using.
    073   * <li> But the LPGL is not appropriate for a whole software product,
    074   *    if this source is only a part of them. It means, the user
    075   *    must publish this part of source,
    076   *    but don't need to publish the whole source of the own product.
    077   * <li> You can study and modify (improve) this source
    078   *    for own using or for redistribution, but you have to license the
    079   *    modified sources likewise under this LGPL Lesser General Public License.
    080   *    You mustn't delete this Copyright/Copyleft inscription in this source file.
    081   * </ol>
    082   * If you are intent to use this sources without publishing its usage, you can get
    083   * a second license subscribing a special contract with the author.
    084   *
    085   * @author Hartmut Schorrig = hartmut.schorrig@vishia.de
    086   */
    087  //@SuppressWarnings("hiding")
    088  public final static String version = "2016-06-26";
    089
    090  private final List<CompleteConstructionAndStart> composites = new LinkedList<CompleteConstructionAndStart>();
    091
    092
    093  /**Action for button log. It switches on or off the logging functionality to log the telegram traffic
    094   * for debugging. */
    095  GralUserAction actionSetRetryDisabledVariable = new GralUserAction("InspcGui - setRetryDisabledVariable"){
    096    @Override public boolean userActionGui(int actionCode, GralWidget widgd, Object... params) {
    097      if(KeyCode.isControlFunctionMouseUpOrMenu(actionCode)){
    098        GralButton widgButton = (GralButton)widgd;
    099        inspcMng.setmodeRetryDisabledVariables(widgButton.isOn());
    100      }
    101      return true;
    102    }
    103  };
    104
    105
    106  /**Action for button log. It switches on or off the logging functionality to log the telegram traffic
    107   * for debugging. */
    108  GralUserAction actionUseGetValueByHandle = new GralUserAction("InspcGui - UseGetValueByIndex"){
    109    @Override public boolean userActionGui(int actionCode, GralWidget widgd, Object... params) {
    110      if(KeyCode.isControlFunctionMouseUpOrMenu(actionCode)){
    111        GralButton widgButton = (GralButton)widgd;
    112        inspcMng.setmodeGetValueByIndex(widgButton.isOn());
    113      }
    114      return true;
    115    }
    116  };
    117
    118
    119
    120
    121  /**The communication manager. */
    122  //final InspcGuiComm XXXinspcComm;
    123
    124  private final CallingArguments cargs;
    125
    126  GralPanelActivated_ifc panelActivated = new GralPanelActivated_ifc(){
    127
    128    public void panelActivatedGui(List widgets)
    129    { panelActivated(widgets);
    130    }
    131    /*
    132    @Override public void panelActivatedGui(Queue<GralWidget> widgets)
    133    { panelActivated(widgets);
    134    }
    135    */
    136  };
    137
    138  final GuiCfg guiCfg;
    139
    140  final InspcMng inspcMng;
    141
    142  final private Runnable callbackOnReceivedData = new Runnable(){ @Override public void run(){ callbackOnReceivedData(); } };
    143
    144
    145  static final GralColor colorRefreshed = GralColor.getColor("wh");
    146  static final GralColor colorOldValue = GralColor.getColor("lgr");
    147
    148  InspcCurveView curveA, curveB, curveC;
    149
    150  InspcFieldTable fieldsA, fieldsB;
    151
    152  InspcViewTargetComm viewTargetComm;
    153
    154  /**This plugged application for the inspector manager. */
    155  InspcPlugUser inspcMngUser;
    156
    157  public GralColorSelector colorSelector;
    158
    159  private final FileCluster fileCluster = FileRemote.clusterOfApplication;
    160
    161  InspcGui(CallingArguments cargs, GralArea9MainCmd cmdgui)
    162  {
    163    ButtonInspcCmd.registerUserAction();
    164    viewTargetComm = new InspcViewTargetComm(this);
    165    guiCfg = new InspcGuiCfg(cargs, cmdgui, userInspcPlug);
    166    GralMng.get().registerUserAction("<name>", actionGetValueByHandleIntern);
    167    for(Map.Entry<String, String> entry: cargs.indexTargetIpcAddr.entrySet()){
    168      viewTargetComm.addTarget(entry.getKey(), entry.getValue(), 0.2f, 5);
    169    }
    170
    171
    172    LogMessage log = cmdgui.getLogMessageOutputConsole();
    173    this.cargs = cargs;  //args in the correct derived type.
    174    /**
    175    assert(user instanceof InspcPlugUser_ifc);
    176    if(user !=null){
    177      user.init(userInspcPlug, log);
    178    }
    179    */
    180    GralPlugUser_ifc user = guiCfg.getPluggedUser();
    181    assert(user == null || user instanceof InspcPlugUser_ifc);
    182    inspcMngUser = new InspcPlugUser((InspcPlugUser_ifc)user);
    183    if(cargs.sOwnIpcAddr ==null){
    184      System.err.println("arg ownIpc missing");
    185      System.exit(255);
    186    }
    187    InspcMng variableMng = new InspcMng(cargs.sOwnIpcAddr, cargs.indexTargetIpcAddr, cargs.cycletime, cargs.bUseGetValueByIndex, inspcMngUser);
    188    composites.add(variableMng);
    189    this.inspcMng = variableMng;
    190    (new GralShowMethods(variableMng)).registerShowMethods(cmdgui.gralMng);
    191    variableMng.setCallbackOnReceivedData(callbackOnReceivedData);
    192    //variableMng.setCallbackShowingState(callbackShowTargetCommState);
    193
    194    //this.XXXinspcComm = new InspcGuiComm(this, guiCfg.gralMng, cargs.indexTargetIpcAddr, (InspcPlugUser_ifc)user);
    195    //composites.add(XXXinspcComm);
    196
    197    if(cargs.sDefaultDirCfgForCurves !=null) {
    198      CharSequence sDefaultDirCfgForCurves = FileSystem.normalizePath(new File(cargs.sDefaultDirCfgForCurves).getAbsolutePath());
    199      FileRemote defaultDirCfg = fileCluster.getFile(sDefaultDirCfgForCurves, null);
    200      FileRemote defaultDirSave;
    201      if(cargs.sDefaultDirSaveForCurves !=null) {
    202        CharSequence sDefaultDirSaveForCurves = FileSystem.normalizePath(new File(cargs.sDefaultDirSaveForCurves).getAbsolutePath());
    203        defaultDirSave = fileCluster.getFile(sDefaultDirSaveForCurves, null);
    204      } else {
    205        defaultDirSave = null;
    206      }
    207      curveA = new InspcCurveView("curve_A", variableMng, cmdgui.gralMng, defaultDirCfg, defaultDirSave, cargs.curveExporterClasses);
    208      curveB = new InspcCurveView("curve_B", variableMng, cmdgui.gralMng, defaultDirCfg, defaultDirSave, cargs.curveExporterClasses);
    209      curveC = new InspcCurveView("curve_C", variableMng, cmdgui.gralMng, defaultDirCfg, defaultDirSave, cargs.curveExporterClasses);
    210    }
    211    fieldsA = new InspcFieldTable(variableMng);
    212    fieldsB = new InspcFieldTable(variableMng);
    213
    214  }
    215
    216  @Override public void completeConstruction(){
    217    this.inspcMng.complete_ReplaceAlias_ifc(guiCfg._gralMng.getReplacerAlias());
    218
    219    for(CompleteConstructionAndStart composite: composites){
    220      composite.completeConstruction();
    221    }
    222  }
    223
    224  @Override public void startupThreads(){
    225    for(CompleteConstructionAndStart composite: composites){
    226      composite.startupThreads();
    227    }
    228  }
    229
    230
    231
    232  void panelActivated(List<GralWidget> widgets){
    233    for(GralWidget widget: widgets){
    234
    235    }
    236  }
    237
    238
    239
    240
    241  /**This method is invoked by callback if a receive cycle is finished.
    242   * Shows values.
    243   */
    244  private void callbackOnReceivedData(){
    245    long time = System.currentTimeMillis();
    246    GralMng gralMng = GralMng.get();
    247    GralPanelContent primaryWindow = gralMng.getPrimaryWindow();
    248    long timeAtleast = System.currentTimeMillis() - 5000;
    249    checkWidgetsToRefresh(primaryWindow, time, timeAtleast, 0);
    250
    251    //ConcurrentLinkedQueue<GralVisibleWidgets_ifc> listPanels = guiCfg._gralMng.getVisiblePanels();
    252    //GralWidget widgdRemove = null;
    253    try{
    254      /*
    255      for(GralVisibleWidgets_ifc panel: listPanels){
    256        List<GralWidget> widgetsVisible = panel.getWidgetsVisible();
    257        if(widgetsVisible !=null) for(GralWidget widget: widgetsVisible){
    258          try{
    259            String sShowMethod;
    260            if((sShowMethod = widget.getShowMethod()) ==null || !sShowMethod.equals("stc_cmd")){
    261              widget.refreshFromVariable(inspcMng, timeAtleast, colorRefreshed, colorOldValue);
    262              widget.requestNewValueForVariable(time);
    263            }
    264          }catch(Exception exc){
    265            System.err.println("InspcGui-receivedData-widget; " + exc.getMessage());
    266            exc.printStackTrace(System.err);
    267          }
    268        }
    269      }
    270      */
    271      //referesh the curve view any time if it is enabled:
    272      curveA.refreshCurve();
    273      curveB.refreshCurve();
    274      curveC.refreshCurve();
    275    } catch(Exception exc){
    276      System.err.println("InspcGui-receivedData; " + exc.getMessage());
    277      exc.printStackTrace(System.out);
    278    }
    279
    280  }
    281
    282
    283
    284  void checkWidgetsToRefresh(GralPanelContent panel, long time, long timeAtleast, int recursiveCnt)
    285  { if(recursiveCnt > 10) { System.err.println("InspcGui: to many recursions"); assert(false); return; }
    286    for(GralWidget widget: panel.getWidgetList()){
    287      if(widget.isVisible()){
    288        if(widget instanceof GralPanelContent) {
    289          checkWidgetsToRefresh((GralPanelContent) widget, time, timeAtleast, recursiveCnt +1);
    290        } else {
    291          try{
    292            if(widget.getDataPath() !=null) {
    293              String sShowMethod;
    294              if((sShowMethod = widget.getShowMethod()) ==null || !sShowMethod.equals("stc_cmd")){
    295                widget.refreshFromVariable(inspcMng, timeAtleast, colorRefreshed, colorOldValue);
    296                widget.requestNewValueForVariable(time);
    297              }
    298            }
    299          }catch(Exception exc){
    300            System.err.println("InspcGui-receivedData-widget; " + exc.getMessage());
    301            exc.printStackTrace(System.err);
    302          }
    303        }
    304      }
    305    }
    306
    307  }
    308
    309
    310
    311
    312
    313  static class CallingArguments extends GuiCallingArgs
    314  {
    315    /**The target ipc-address for Interprocess-Communication with the target.
    316     * It is a string, which determines the kind of communication.
    317     * For example "UDP:0.0.0.0:60099" to create a socket port for UDP-communication.
    318     */
    319    Map<String, String> indexTargetIpcAddr = new TreeMap<String, String>();
    320
    321    /**Cohesion between file extension and exporter java class path for curve output.*/
    322    Map<String, String> curveExporterClasses = new TreeMap<String, String>();
    323
    324    /**File with the values from the S7 to show. */
    325    //protected String sFileOamValues;
    326
    327    boolean bUseGetValueByIndex;
    328
    329    public int cycletime = 100;
    330
    331    String sDefaultDirCfgForCurves = "C:/";
    332
    333    String sDefaultDirSaveForCurves = "C:/";
    334
    335  }
    336
    337  /**Organisation class for the GUI.
    338   */
    339  private static class CmdLineAndGui extends GralArea9MainCmd
    340  {
    341
    342    /**Aggregation to given instance for the command-line-argument. The instance can be arranged anywhere else.
    343     * It is given as ctor-parameter.
    344     */
    345    final protected CallingArguments cargs;
    346
    347
    348    public CmdLineAndGui(CallingArguments cargs, String[] args)
    349    {
    350      super(cargs, args);
    351      this.cargs = cargs;
    352      super.addAboutInfo("Inspc-GUI-cfg");
    353      super.addAboutInfo("made by HSchorrig, 2011-05-18, 2012-01-17");
    354    }
    355
    356    @Override protected boolean testArgument(String arg, int nArg)
    357    {
    358      boolean bOk = true;  //set to false if the argc is not passed
    359      try{
    360        if(arg.startsWith("-targetIpc="))
    361        { String sArg = getArgument(11);
    362          int posSep = sArg.indexOf('@');
    363          if(posSep < 0){
    364            writeError("argument -targetIpc=KEY@ADDR: The '@' is missed.");
    365            bOk = false;
    366          } else {
    367            String sKey = sArg.substring(0, posSep);
    368            String sValue = sArg.substring(posSep+1);
    369            cargs.indexTargetIpcAddr.put(sKey, sValue);
    370          }
    371        }
    372        else if(arg.startsWith("-pluginCfg="))
    373        { cargs.sPluginCfg = getArgument(11);
    374        }
    375        else if(arg.startsWith("-curve-export="))
    376        { String sArg = getArgument(14);
    377          int posSep = sArg.indexOf('=');
    378          if(posSep < 0){
    379            writeError("argument -curve-export=EXT=java.class.path");
    380            bOk = false;
    381          } else {
    382            String sKey = sArg.substring(0, posSep);
    383            String sValue = sArg.substring(posSep+1);
    384            cargs.curveExporterClasses.put(sKey, sValue);
    385          }
    386        }
    387        else if(arg.startsWith("-cycle="))
    388        { String sTime = getArgument(7);
    389          try{ cargs.cycletime = Integer.parseInt(sTime); }
    390          catch(NumberFormatException exc){ bOk = false; writeError("argument \"-cycle=\" should be an integer, read: " + sTime); }
    391        }
    392        else if(arg.startsWith("-targetbyIndex"))
    393        { cargs.bUseGetValueByIndex = true;   //an example for default output
    394        }
    395        else if(arg.startsWith("-ownIpc="))
    396        { cargs.sOwnIpcAddr = getArgument(8);   //an example for default output
    397        }
    398        else if(arg.startsWith("-dirCurves="))
    399        { cargs.sDefaultDirCfgForCurves = getArgument(11);   //an example for default output
    400        }
    401        else if(arg.startsWith("-dirCurveCfg="))
    402        { cargs.sDefaultDirCfgForCurves = getArgument(13);   //an example for default output
    403        }
    404        else if(arg.startsWith("-dirCurveSave="))
    405        { cargs.sDefaultDirSaveForCurves = getArgument(14);   //an example for default output
    406        }
    407        else { bOk = super.testArgument(arg, nArg); }
    408      } catch(Exception exc){ bOk = false; }
    409      return bOk;
    410    }
    411
    412
    413  } //class CmdLineAndGui
    414
    415
    416/**Overrides the GuiCfg with special initialization and methods.
    417 * @author Hartmut Schorrig
    418 *
    419 */
    420private class InspcGuiCfg extends GuiCfg
    421{
    422
    423  InspcGuiCfg(CallingArguments cargs, GralArea9MainCmd cmdgui, GralPlugUser2Gral_ifc plugUser2Gui)
    424  { super(cargs, cmdgui, null, plugUser2Gui, null);
    425  }
    426
    427
    428  /**Initializes the areas for the panels and configure the panels.
    429   * This routine overrides {@link GuiCfg#initGuiAreas()} and calls its super.
    430   * Additional some user initialization is done.
    431   */
    432  @Override protected void initGuiAreas(String sAreaMainPanel)
    433  {
    434    super.initGuiAreas("A1C2");
    435    super._gralMng.selectPanel("test");
    436    super._gralMng.setPosition(5, GralPos.size -3, 0, GralPos.size +18 , 0, 'd',1);
    437    //btnSwitchOnLog = super._gralMng.addSwitchButton("log", "log telg ?", "log telg", GralColor.getColor("wh"), GralColor.getColor("am") );
    438    //btnSwitchOnLog.setActionChange(actionEnableLog);
    439    colorSelector = new GralColorSelector("colorSelector", super._gralMng);
    440    curveA.buildGraphic(gui.mainWindow(), colorSelector, null);
    441    curveB.buildGraphic(gui.mainWindow(), colorSelector, curveA.widgCurve.getCommonData());
    442    curveC.buildGraphic(gui.mainWindow(), colorSelector, curveA.widgCurve.getCommonData());
    443    //
    444    _gralMng.selectPanel("primaryWindow");
    445    _gralMng.setPosition(14, 84, 4, 64, 0, '.');
    446    fieldsA.setToPanel(_gralMng);
    447    _gralMng.selectPanel("primaryWindow");
    448    _gralMng.setPosition(24, 94, 14, 74, 0, '.');
    449    fieldsB.setToPanel(_gralMng);
    450    _gralMng.selectPanel("primaryWindow");
    451    _gralMng.setPosition(10, 30, 50, 74, 0, '.');
    452    viewTargetComm.setToPanel();
    453    GralMenu menu = super.guiW.getMenuBar();
    454    menu.addMenuItem("menuBarFieldsA", "&Window/open Fields &A", fieldsA.actionOpenWindow);
    455    menu.addMenuItem("menuBarFieldsB", "&Window/open Fields &B", fieldsB.actionOpenWindow);
    456    menu.addMenuItem("menuBarViewTargetComm", "&Window/view &TargetComm", viewTargetComm.setVisible);
    457    //
    458    if(user !=null){
    459      user.initGui(_gralMng);
    460      user.addGuiMenu(gui.mainWindow());
    461    }
    462    menu.addMenuItem("menuHelp", "&Help/&Help", gui.getActionHelp());
    463    menu.addMenuItem("menuAbout", "&Help/&About", gui.getActionAbout());
    464    gui.addMenuBarArea9ItemGThread("menuAbout", "&Help/e&Xit", gui.getActionAbout());
    465
    466  }
    467
    468
    469
    470  @Override protected void initMain()
    471  {
    472    //inspcComm.openComm(cargs.sOwnIpcAddr);
    473    //msgReceiver.start();
    474    //oamRcvUdpValue.start();
    475    super.initMain();  //starts initializing of graphic. Do it after reading some configurations.
    476
    477  }
    478
    479  @Override protected void stepMain()
    480  {
    481    try{
    482      synchronized(this){ wait(100); }
    483      curveA.stepSaveCurve();
    484      curveB.stepSaveCurve();
    485      curveC.stepSaveCurve();
    486      //inspcComm.procComm();
    487      //oamRcvUdpValue.sendRequest();
    488    } catch(Exception exc){
    489      System.out.println(Assert.exceptionInfo("InspcGui - unexpected Exception; ", exc, 0, 7));
    490      exc.printStackTrace();
    491    }
    492
    493  }
    494
    495  @Override protected void finishMain()
    496  {
    497    super.finishMain();
    498    try{ inspcMng.close(); } catch(IOException exc){}
    499  }
    500
    501} //class InspcGuiCfg
    502
    503
    504  private final UserInspcPlug userInspcPlug = new UserInspcPlug();
    505
    506
    507
    508  /**The command-line-invocation (primary command-line-call.
    509   * @param args Some calling arguments are taken. This is the GUI-configuration especially.
    510   */
    511  public static void main(String[] args)
    512  { boolean bOk = true;
    513    //
    514    //String ipcFactory = "org.vishia.communication.InterProcessComm_Socket";
    515    //try{ ClassLoader.getSystemClassLoader().loadClass(ipcFactory, true);
    516    //}catch(ClassNotFoundException exc){
    517    //  System.out.println("class not found: " + "org.vishia.communication.InterProcessComm_Socket");
    518    //}
    519    //Loads the named class, and its base class InterProcessCommFactory.
    520    //In that kind the calling of factory methods are regarded to socket.
    521    new InterProcessCommFactorySocket();
    522    //
    523    CallingArguments cargs = new CallingArguments();
    524    //Initializes the GUI till a output window to show informations:
    525    CmdLineAndGui cmdgui = new CmdLineAndGui(cargs, args);  //implements MainCmd, parses calling arguments
    526    bOk = cmdgui.parseArgumentsAndInitGraphic(null, "3A3C");
    527    System.err.println("InspcGui - Test; test");
    528    LogMessage log = cmdgui.getLogMessageOutputConsole();
    529
    530
    531    InspcGui main = new InspcGui(cargs, cmdgui);
    532
    533    main.completeConstruction();
    534    main.startupThreads();
    535
    536    main.guiCfg.execute();
    537
    538    cmdgui.exit();
    539  }
    540
    541
    542
    543
    544  private class UserInspcPlug implements UserInspcPlug_ifc, GralPlugUser2Gral_ifc
    545  {
    546
    547    UserInspcPlug(){}
    548
    549
    550    @Override public InspcTargetAccessData getTargetFromPath(String sDataPath){
    551      return InspcGui.this.inspcMng.getTargetAccessFromPath(sDataPath, true);
    552    }
    553
    554
    555
    556  } //class UserInspcPlug
    557
    558
    559
    560
    561  private class InspcPlugUser implements InspcPlugUser_ifc
    562  {
    563
    564    /**Cascaded user. */
    565    final InspcPlugUser_ifc user1;
    566
    567    InspcPlugUser(InspcPlugUser_ifc user){
    568      user1 = user;
    569    }
    570
    571    @Override public void showStateInfo(String key, TargetState state, int count, int accLevels, float[] cycle_timeout){
    572      InspcGui.this.viewTargetComm.setStateInfo(key,state, count, accLevels, cycle_timeout);
    573    }
    574
    575
    576    @Override public void setInspcComm(InspcAccess_ifc inspcMng)
    577    { if(user1 !=null) { user1.setInspcComm(inspcMng); }
    578    }
    579
    580    @Override public void requData(int ident)
    581    { if(user1 !=null) { user1.requData(ident); }
    582    }
    583
    584    @Override public void isSent(int seqnr)
    585    { if(user1 !=null) { user1.isSent(seqnr); }
    586    }
    587
    588    @Override
    589    public void registerTarget(String name, String sAddr, InspcTargetAccessor targetAcc)
    590    {
    591      viewTargetComm.registerTarget(name, sAddr, targetAcc);
    592
    593    }
    594
    595  }
    596
    597
    598
    599  GralUserAction actionGetValueByHandleIntern = new GralUserAction("getValueByHandleIntern"){
    600    int handle = 0;
    601    public boolean exec(int actionCode, GralWidget_ifc widgd, Object... params){
    602      System.out.println("hello");
    603      Inspector inspector = Inspector.get();
    604      if(handle == 0){
    605        handle = inspector.classContent.registerHandle("this$0.inspcMng.threadEvent.timeSleep", null);
    606      }
    607      if(handle !=-1){
    608        int value = inspector.classContent.getIntValueByHandle(handle);
    609        System.out.println("value =" + value);
    610      }
    611      return true;
    612    }
    613  };
    614
    615
    616}