Esempio n. 1
0
  /**
   * Pinta una linea entre los valores dados u con el grosor dado
   *
   * @param poValor1X valor x 1
   * @param poValor1Y valor y 1
   * @param poValor2X valor x 2
   * @param poValor2Y valor y 2
   * @param plGrosor grosor de la línea
   */
  public void drawLineLinea(
      Object poValor1X, Object poValor1Y, Object poValor2X, Object poValor2Y, int plGrosor) {
    Point loValor1 =
        getPunto(convertidorDouble.mddouble(poValor1X), convertidorDouble.mddouble(poValor1Y));
    Point loValor2 =
        getPunto(convertidorDouble.mddouble(poValor2X), convertidorDouble.mddouble(poValor2Y));

    for (int i = 0; i < plGrosor; i++) {
      moGraphics.drawLine(loValor1.x + i, loValor1.y + i, loValor2.x + i, loValor2.y + i);
    }
  }
Esempio n. 2
0
 /**
  * Establece el color del Graphics
  *
  * @param poColor color
  */
 public void setColor(Color poColor) {
   moGraphics.setColor(poColor);
 }
Esempio n. 3
0
 /**
  * Pinta una rectangulo relleno en el valor dado desde origen x hasta el valor dado
  *
  * @param poValor1X valor x 1
  * @param poValor1Y valor y 1
  * @param plAncho ancho
  * @param plDesplazamiento desplazamiento con respecto al eje X
  */
 public void fillRectBarra(Object poValor1X, Object poValor1Y, int plDesplazamiento, int plAncho) {
   Point loP =
       getPunto(convertidorDouble.mddouble(poValor1X), convertidorDouble.mddouble(poValor1Y));
   moGraphics.fillRect(
       loP.x + plDesplazamiento, loP.y, plAncho, (moAreaDatos.y + moAreaDatos.height + 1) - loP.y);
 }
Esempio n. 4
0
 /**
  * Pinta una rectangulo hueco en el valor dado
  *
  * @param poValor1X valor x 1
  * @param poValor1Y valor y 1
  * @param plAncho ancho
  * @param plAlto alto
  */
 public void drawRectPunto(Object poValor1X, Object poValor1Y, int plAncho, int plAlto) {
   Point loValor1 =
       getPunto(convertidorDouble.mddouble(poValor1X), convertidorDouble.mddouble(poValor1Y));
   moGraphics.drawRect(loValor1.x - (plAncho / 2), loValor1.y - (plAlto / 2), plAncho, plAlto);
 }
Esempio n. 5
0
  /**
   * Pinta ejeY
   *
   * @param pbEsY si es eje Y sino eje X
   * @param pdValorSeparaEje valor de sepración de los valores del eje
   * @param pdValorMin Valor mínimo de los valores del eje
   * @param pdValorMax valor máximo de los valores del eje
   * @param poEstilo estilo del Eje
   * @param poTipo tipo de los datos del eje
   * @param g objeto gráfico en donde pintar
   */
  public void pintarEje(
      Graphics g,
      boolean pbEsY,
      double pdValorSeparaEje,
      Object pdValorMin,
      Object pdValorMax,
      JEstiloEje poEstilo,
      Class poTipo) {
    //        Rectangle r = moAreaDatos;

    // si hay series
    int lxMinima;
    int lxMaxima;
    int lRayaIzq;
    int lRayaDer;
    int lRayaArr;
    int lRayaAba;
    int lyMinima;
    int lyMaxima;
    int lxCorreccionTexto;
    int lyCorreccionTexto;

    //
    // inicializacion de variables segun eje 1 o 2
    //

    if (pbEsY) {
      lyMinima = moAreaDatos.height + moAreaDatos.y;
      lyMaxima = moAreaDatos.y;
      if (mbesY1) {
        lxMinima = moAreaDatos.x;
        lxMaxima = moAreaDatos.x;
        lRayaArr = 0;
        lRayaAba = 0;
        lRayaIzq = 5;
        if (moEstiloY.mbLineasDivision) {
          lRayaDer = moAreaDatos.width;
        } else {
          lRayaDer = 0;
        }
        lxCorreccionTexto = -lxMinima;
        lyCorreccionTexto = 0;
      } else {
        lxMinima = moAreaDatos.x + moAreaDatos.width;
        lxMaxima = moAreaDatos.x + moAreaDatos.width;
        lRayaArr = 0;
        lRayaAba = 0;
        lRayaDer = 5;
        lRayaIzq = 0;
        if (moEstiloY.mbLineasDivision) {
          lRayaIzq = moAreaDatos.width;
        } else {
          lRayaIzq = 0;
        }
        lxCorreccionTexto = 5;
        lyCorreccionTexto = 0;
      }
    } else {
      if (moEstiloX.mbLineasDivision) {
        lRayaArr = moAreaDatos.height;
      } else {
        lRayaArr = 0;
      }
      lRayaAba = 5;
      lRayaIzq = 0;
      lRayaDer = 0;
      lxMinima = moAreaDatos.x;
      lxMaxima = moAreaDatos.x + moAreaDatos.width;
      lyMinima = moAreaDatos.height + moAreaDatos.y;
      lyMaxima = lyMinima;
      lxCorreccionTexto = -5;
      lyCorreccionTexto = 15;
    }

    //
    // pintamos el eje
    //

    g.setColor(poEstilo.moColorEje);
    g.drawLine(lxMinima, lyMinima, lxMaxima, lyMaxima);

    //
    // calculamos la y minima y las unidades graficas para la y
    // pintamos las rayas de los ejes
    //
    double ldMin = convertidorDouble.mddouble(pdValorMin);
    double ldMax = convertidorDouble.mddouble(pdValorMax);

    // siempre pintamos la y minima, la y-1 de los valores normales se pinta
    // si hay una diferencia de mas de 20 px con la y max.
    double ldValorActual = ldMin;
    int lValorMax = (new Double((ldMax - ldMin) / pdValorSeparaEje)).intValue() + 2;

    int ly = 0;
    int lx = 0;
    for (int i = 1;
        ((((lyMinima - ly) >= lyMaxima) && (pbEsY)) || (((lxMinima + lx) <= lxMaxima) && (!pbEsY)))
            && (i <= lValorMax);
        i++) {

      // dibujamos la rayita
      g.drawLine(
          lxMinima - lRayaIzq + lx,
          lyMinima - ly + lRayaAba,
          lxMinima + lRayaDer + lx,
          lyMinima - ly - lRayaArr);

      // dibujamos el texto
      poEstilo.moEstiloTexto.pintar(
          g,
          convertidorDouble.toString(new Double(ldValorActual), poTipo),
          lxMinima + lxCorreccionTexto + lx,
          lyMinima + lyCorreccionTexto - ly);

      // incrementamos el valor actual
      ldValorActual += pdValorSeparaEje;

      // incrementamos las coordenadas segun el eje
      if (pbEsY) {
        ly = (new Double(pdValorSeparaEje * i * mdUnidadY).intValue());
      } else {
        lx = (new Double(pdValorSeparaEje * i * mdUnidadX).intValue());
      }
    }
  }