Beispiel #1
0
    public void invoke(Object sender, mxEventObject evt) {

      if (DEBUG)
        System.out.println(
            "[TrackScheme] CellRemovalListener: cells removed - Source of event is "
                + sender.getClass()
                + ". Fire flag is "
                + doFireModelChangeEvent);

      if (!doFireModelChangeEvent) return;

      // Separate spots from edges
      Object[] objects = (Object[]) evt.getProperty("cells");
      HashSet<Spot> spotsToRemove = new HashSet<Spot>();
      ArrayList<DefaultWeightedEdge> edgesToRemove = new ArrayList<DefaultWeightedEdge>();
      for (Object obj : objects) {
        mxCell cell = (mxCell) obj;
        if (null != cell) {
          if (cell.isVertex()) {
            // Build list of removed spots
            Spot spot = graph.getSpotFor(cell);
            spotsToRemove.add(spot);
            // Clean maps
            graph.removeMapping(spot);
          } else if (cell.isEdge()) {
            // Build list of removed edges
            DefaultWeightedEdge edge = graph.getEdgeFor(cell);
            if (null == edge) continue;
            edgesToRemove.add(edge);
            // Clean maps
            graph.removeMapping(edge);
          }
        }
      }

      evt.consume();

      // Clean model
      doFireModelChangeEvent = false;
      model.beginUpdate();
      try {
        selectionModel.clearSelection();
        // We remove edges first so that we ensure we do not end having orphan edges.
        // Normally JGraphT handles that well, but we enforce things here. To be sure.
        for (DefaultWeightedEdge edge : edgesToRemove) {
          model.removeEdge(edge);
        }
        for (Spot spot : spotsToRemove) {
          model.removeSpot(spot);
        }

      } finally {
        model.endUpdate();
      }
      doFireModelChangeEvent = true;
    }
Beispiel #2
0
 public mxCell findVertex(String id) {
   Object[] cells = graph.getChildCells(graph.getDefaultParent());
   String logMessage = "\nLooking for vertex with ID: \"" + id + "\"\n";
   for (int i = 0; i < cells.length; i++) {
     mxCell cell = (mxCell) cells[i];
     if (cell.isVertex()) {
       String cellsId = ((VertexValue) cell.getValue()).getId();
       logMessage += "checking vertex ID: \"" + cellsId + "\"\n";
       if (cellsId.equals(id)) {
         logMessage += "vertex found!\n";
         log.log(Level.INFO, logMessage);
         return cell;
       }
     }
   }
   logMessage += "Can't find vertex for ID: \"" + id + "\"\n";
   log.log(Level.INFO, logMessage);
   return null;
 }
Beispiel #3
0
  /**
   * Called when the user makes a selection change in the graph. Used to forward this event to the
   * {@link InfoPane} and to other {@link SelectionChangeListener}s.
   *
   * @param model the selection model
   * @param added the cells <b>removed</b> from selection (careful, inverted)
   * @param removed the cells <b>added</b> to selection (careful, inverted)
   */
  private void userChangedSelection(
      mxGraphSelectionModel mxGSmodel,
      Collection<Object> added,
      Collection<Object> removed) { // Seems to be inverted
    if (!doFireSelectionChangeEvent) return;
    Collection<Spot> spotsToAdd = new ArrayList<Spot>();
    Collection<Spot> spotsToRemove = new ArrayList<Spot>();
    Collection<DefaultWeightedEdge> edgesToAdd = new ArrayList<DefaultWeightedEdge>();
    Collection<DefaultWeightedEdge> edgesToRemove = new ArrayList<DefaultWeightedEdge>();

    if (null != added) {
      for (Object obj : added) {
        mxCell cell = (mxCell) obj;

        if (cell.getChildCount() > 0) {

          for (int i = 0; i < cell.getChildCount(); i++) {
            mxICell child = cell.getChildAt(i);
            if (child.isVertex()) {
              Spot spot = graph.getSpotFor(child);
              spotsToRemove.add(spot);
            } else {
              DefaultWeightedEdge edge = graph.getEdgeFor(child);
              edgesToRemove.add(edge);
            }
          }

        } else {

          if (cell.isVertex()) {
            Spot spot = graph.getSpotFor(cell);
            spotsToRemove.add(spot);
          } else {
            DefaultWeightedEdge edge = graph.getEdgeFor(cell);
            edgesToRemove.add(edge);
          }
        }
      }
    }

    if (null != removed) {
      for (Object obj : removed) {
        mxCell cell = (mxCell) obj;

        if (cell.getChildCount() > 0) {

          for (int i = 0; i < cell.getChildCount(); i++) {
            mxICell child = cell.getChildAt(i);
            if (child.isVertex()) {
              Spot spot = graph.getSpotFor(child);
              spotsToAdd.add(spot);
            } else {
              DefaultWeightedEdge edge = graph.getEdgeFor(child);
              edgesToAdd.add(edge);
            }
          }

        } else {

          if (cell.isVertex()) {
            Spot spot = graph.getSpotFor(cell);
            spotsToAdd.add(spot);
          } else {
            DefaultWeightedEdge edge = graph.getEdgeFor(cell);
            edgesToAdd.add(edge);
          }
        }
      }
    }
    if (DEBUG_SELECTION)
      System.out.println("[TrackScheme] userChangeSelection: sending selection change to model.");
    doFireSelectionChangeEvent = false;
    if (!edgesToAdd.isEmpty()) selectionModel.addEdgeToSelection(edgesToAdd);
    if (!spotsToAdd.isEmpty()) selectionModel.addSpotToSelection(spotsToAdd);
    if (!edgesToRemove.isEmpty()) selectionModel.removeEdgeFromSelection(edgesToRemove);
    if (!spotsToRemove.isEmpty()) selectionModel.removeSpotFromSelection(spotsToRemove);
    doFireSelectionChangeEvent = true;
  }
  @Override
  public AbstractMeta decode(String graphXml) throws Exception {
    mxGraph graph = new mxGraph();
    mxCodec codec = new mxCodec();
    Document doc = mxUtils.parseXml(graphXml);
    codec.decode(doc.getDocumentElement(), graph.getModel());
    mxCell root = (mxCell) graph.getDefaultParent();

    TransMeta transMeta = new TransMeta();
    decodeCommRootAttr(root, transMeta);
    transMeta.setTransstatus(Const.toInt(root.getAttribute("trans_status"), -1));
    transMeta.setTransversion(root.getAttribute("trans_version"));

    if (transMeta.getRepository() != null)
      transMeta.setSharedObjects(transMeta.getRepository().readTransSharedObjects(transMeta));
    else transMeta.setSharedObjects(transMeta.readSharedObjects());

    transMeta.importFromMetaStore();

    decodeDatabases(root, transMeta);
    decodeNote(graph, transMeta);

    int count = graph.getModel().getChildCount(root);
    for (int i = 0; i < count; i++) {
      mxCell cell = (mxCell) graph.getModel().getChildAt(root, i);
      if (cell.isVertex()) {
        Element e = (Element) cell.getValue();
        if (PropsUI.TRANS_STEP_NAME.equals(e.getTagName())) {
          StepDecoder stepDecoder = (StepDecoder) PluginFactory.getBean(cell.getAttribute("ctype"));
          StepMeta stepMeta =
              stepDecoder.decodeStep(cell, transMeta.getDatabases(), transMeta.getMetaStore());
          stepMeta.setParentTransMeta(transMeta);
          if (stepMeta.isMissing()) {
            transMeta.addMissingTrans((MissingTrans) stepMeta.getStepMetaInterface());
          }

          StepMeta check = transMeta.findStep(stepMeta.getName());
          if (check != null) {
            if (!check.isShared()) {
              // Don't overwrite shared objects
              transMeta.addOrReplaceStep(stepMeta);
            } else {
              check.setDraw(stepMeta.isDrawn()); // Just keep the  drawn flag  and location
              check.setLocation(stepMeta.getLocation());
            }
          } else {
            transMeta.addStep(stepMeta); // simply add it.
          }
        }
      }
    }

    // Have all StreamValueLookups, etc. reference the correct source steps...
    //
    for (int i = 0; i < transMeta.nrSteps(); i++) {
      StepMeta stepMeta = transMeta.getStep(i);
      StepMetaInterface sii = stepMeta.getStepMetaInterface();
      if (sii != null) {
        sii.searchInfoAndTargetSteps(transMeta.getSteps());
      }
    }

    count = graph.getModel().getChildCount(root);
    for (int i = 0; i < count; i++) {
      mxCell cell = (mxCell) graph.getModel().getChildAt(root, i);
      if (cell.isEdge()) {
        mxCell source = (mxCell) cell.getSource();
        mxCell target = (mxCell) cell.getTarget();

        TransHopMeta hopinf = new TransHopMeta(null, null, true);
        String[] stepNames = transMeta.getStepNames();
        for (int j = 0; j < stepNames.length; j++) {
          if (stepNames[j].equalsIgnoreCase(source.getAttribute("label")))
            hopinf.setFromStep(transMeta.getStep(j));
          if (stepNames[j].equalsIgnoreCase(target.getAttribute("label")))
            hopinf.setToStep(transMeta.getStep(j));
        }
        transMeta.addTransHop(hopinf);
      }
    }

    JSONObject jsonObject = JSONObject.fromObject(root.getAttribute("transLogTable"));
    TransLogTable transLogTable = transMeta.getTransLogTable();
    transLogTable.setConnectionName(jsonObject.optString("connection"));
    transLogTable.setSchemaName(jsonObject.optString("schema"));
    transLogTable.setTableName(jsonObject.optString("table"));
    transLogTable.setLogSizeLimit(jsonObject.optString("size_limit_lines"));
    transLogTable.setLogInterval(jsonObject.optString("interval"));
    transLogTable.setTimeoutInDays(jsonObject.optString("timeout_days"));
    JSONArray jsonArray = jsonObject.optJSONArray("fields");
    if (jsonArray != null) {
      for (int i = 0; i < jsonArray.size(); i++) {
        JSONObject fieldJson = jsonArray.getJSONObject(i);
        String id = fieldJson.optString("id");
        LogTableField field = transLogTable.findField(id);
        if (field == null) {
          field = transLogTable.getFields().get(i);
        }
        if (field != null) {
          field.setFieldName(fieldJson.optString("name"));
          field.setEnabled(fieldJson.optBoolean("enabled"));
          field.setSubject(StepMeta.findStep(transMeta.getSteps(), fieldJson.optString("subject")));
        }
      }
    }

    jsonObject = JSONObject.fromObject(root.getAttribute("stepLogTable"));
    StepLogTable stepLogTable = transMeta.getStepLogTable();
    stepLogTable.setConnectionName(jsonObject.optString("connection"));
    stepLogTable.setSchemaName(jsonObject.optString("schema"));
    stepLogTable.setTableName(jsonObject.optString("table"));
    stepLogTable.setTimeoutInDays(jsonObject.optString("timeout_days"));
    jsonArray = jsonObject.optJSONArray("fields");
    if (jsonArray != null) {
      for (int i = 0; i < jsonArray.size(); i++) {
        JSONObject fieldJson = jsonArray.getJSONObject(i);
        String id = fieldJson.optString("id");
        LogTableField field = stepLogTable.findField(id);
        if (field == null && i < stepLogTable.getFields().size()) {
          field = stepLogTable.getFields().get(i);
        }
        if (field != null) {
          field.setFieldName(fieldJson.optString("name"));
          field.setEnabled(fieldJson.optBoolean("enabled"));
        }
      }
    }

    jsonObject = JSONObject.fromObject(root.getAttribute("performanceLogTable"));
    PerformanceLogTable performanceLogTable = transMeta.getPerformanceLogTable();
    performanceLogTable.setConnectionName(jsonObject.optString("connection"));
    performanceLogTable.setSchemaName(jsonObject.optString("schema"));
    performanceLogTable.setTableName(jsonObject.optString("table"));
    performanceLogTable.setLogInterval(jsonObject.optString("interval"));
    performanceLogTable.setTimeoutInDays(jsonObject.optString("timeout_days"));
    jsonArray = jsonObject.optJSONArray("fields");
    if (jsonArray != null) {
      for (int i = 0; i < jsonArray.size(); i++) {
        JSONObject fieldJson = jsonArray.getJSONObject(i);
        String id = fieldJson.optString("id");
        LogTableField field = performanceLogTable.findField(id);
        if (field == null && i < performanceLogTable.getFields().size()) {
          field = performanceLogTable.getFields().get(i);
        }
        if (field != null) {
          field.setFieldName(fieldJson.optString("name"));
          field.setEnabled(fieldJson.optBoolean("enabled"));
        }
      }
    }

    jsonObject = JSONObject.fromObject(root.getAttribute("metricsLogTable"));
    MetricsLogTable metricsLogTable = transMeta.getMetricsLogTable();
    metricsLogTable.setConnectionName(jsonObject.optString("connection"));
    metricsLogTable.setSchemaName(jsonObject.optString("schema"));
    metricsLogTable.setTableName(jsonObject.optString("table"));
    metricsLogTable.setTimeoutInDays(jsonObject.optString("timeout_days"));
    jsonArray = jsonObject.optJSONArray("fields");
    if (jsonArray != null) {
      for (int i = 0; i < jsonArray.size(); i++) {
        JSONObject fieldJson = jsonArray.getJSONObject(i);
        String id = fieldJson.optString("id");
        LogTableField field = metricsLogTable.findField(id);
        if (field == null && i < metricsLogTable.getFields().size()) {
          field = metricsLogTable.getFields().get(i);
        }
        if (field != null) {
          field.setFieldName(fieldJson.optString("name"));
          field.setEnabled(fieldJson.optBoolean("enabled"));
        }
      }
    }

    jsonArray = JSONArray.fromObject(root.getAttribute("partitionschemas"));
    for (int i = 0; i < jsonArray.size(); i++) {
      jsonObject = jsonArray.getJSONObject(i);
      PartitionSchema partitionSchema = decodePartitionSchema(jsonObject);
      PartitionSchema check = transMeta.findPartitionSchema(partitionSchema.getName());
      if (check != null) {
        if (!check.isShared()) {
          transMeta.addOrReplacePartitionSchema(partitionSchema);
        }
      } else {
        transMeta.getPartitionSchemas().add(partitionSchema);
      }
    }

    decodeSlaveServers(root, transMeta);

    jsonArray = JSONArray.fromObject(root.getAttribute("clusterSchemas"));
    for (int i = 0; i < jsonArray.size(); i++) {
      jsonObject = jsonArray.getJSONObject(i);
      ClusterSchema clusterSchema = decodeClusterSchema(jsonObject, transMeta.getSlaveServers());
      clusterSchema.shareVariablesWith(transMeta);

      ClusterSchema check = transMeta.findClusterSchema(clusterSchema.getName());
      if (check != null) {
        if (!check.isShared()) {
          transMeta.addOrReplaceClusterSchema(clusterSchema);
        }
      } else {
        transMeta.getClusterSchemas().add(clusterSchema);
      }
    }

    for (int i = 0; i < transMeta.nrSteps(); i++) {
      transMeta.getStep(i).setClusterSchemaAfterLoading(transMeta.getClusterSchemas());
    }

    transMeta.setSizeRowset(Const.toInt(root.getAttribute("size_rowset"), Const.ROWS_IN_ROWSET));
    transMeta.setSleepTimeEmpty(
        Const.toInt(root.getAttribute("sleep_time_empty"), Const.TIMEOUT_GET_MILLIS));
    transMeta.setSleepTimeFull(
        Const.toInt(root.getAttribute("sleep_time_full"), Const.TIMEOUT_PUT_MILLIS));
    transMeta.setUsingUniqueConnections(
        "Y".equalsIgnoreCase(root.getAttribute("unique_connections")));

    transMeta.setFeedbackShown(!"N".equalsIgnoreCase(root.getAttribute("feedback_shown")));
    transMeta.setFeedbackSize(Const.toInt(root.getAttribute("feedback_size"), Const.ROWS_UPDATE));
    transMeta.setUsingThreadPriorityManagment(
        !"N".equalsIgnoreCase(root.getAttribute("using_thread_priorities")));

    transMeta.setCapturingStepPerformanceSnapShots(
        "Y".equalsIgnoreCase(root.getAttribute("capture_step_performance")));
    transMeta.setStepPerformanceCapturingDelay(
        Const.toLong(root.getAttribute("step_performance_capturing_delay"), 1000));
    transMeta.setStepPerformanceCapturingSizeLimit(
        root.getAttribute("step_performance_capturing_size_limit"));

    transMeta.setKey(XMLHandler.stringToBinary(root.getAttribute("key_for_session_key")));
    transMeta.setPrivateKey("Y".equals(root.getAttribute("is_key_private")));

    return transMeta;
  }