Function bodies 149 total

  Algorithm(int i,int b) {
    native_integer = i;
    bailout = b;
  }

  int getInt() {
    return native_integer;
  }

  int getBailout() {
    return bailout;
  }

  ComplexEquation(int i, int p) {
    native_integer = i;
    power = p;
  }

  int getInt() {
    return native_integer;
  }

  int getPower() {
    return power;
  }

class Eula {
    private static final String PREFERENCE_EULA_ACCEPTED = "eula.accepted";
    private static final String PREFERENCES_EULA = "eula";

    /**
     * Displays the EULA if necessary. This method should be called from the onCreate()
     * method of your main Activity.
     *
     * @param activity The Activity to finish if the user rejects the EULA.
     */
    static void showEula(final Activity activity) {
        final SharedPreferences preferences = activity.getSharedPreferences(PREFERENCES_EULA,
                Activity.MODE_PRIVATE);
        if (!preferences.getBoolean(PREFERENCE_EULA_ACCEPTED, false)) {
            final AlertDialog.Builder builder = new AlertDialog.Builder(activity);
            builder.setTitle(R.string.eula_title);
            builder.setCancelable(true);
            builder.setPositiveButton(R.string.eula_accept, new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int which) {
                    a

    static void showEula(final Activity activity) {
        final SharedPreferences preferences = activity.getSharedPreferences(PREFERENCES_EULA,
                Activity.MODE_PRIVATE);
        if (!preferences.getBoolean(PREFERENCE_EULA_ACCEPTED, false)) {
            final AlertDialog.Builder builder = new AlertDialog.Builder(activity);
            builder.setTitle(R.string.eula_title);
            builder.setCancelable(true);
            builder.setPositiveButton(R.string.eula_accept, new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int which) {
                    accept(preferences);
                }
            });
            builder.setNegativeButton(R.string.eula_refuse, new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int which) {
                    refuse(activity);
                }
            });
            builder.setOnCancelListener(new DialogInterface.OnCancelListen

                public void onClick(DialogInterface dialog, int which) {
                    accept(preferences);
                }

                public void onClick(DialogInterface dialog, int which) {
                    refuse(activity);
                }

                public void onCancel(DialogInterface dialog) {
                    refuse(activity);
                }

    private static void accept(SharedPreferences preferences) {
        preferences.edit().putBoolean(PREFERENCE_EULA_ACCEPTED, true).commit();
    }

    private static void refuse(Activity activity) {
        activity.finish();
    }

    private static CharSequence readFile(Activity activity, int id) {
        BufferedReader in = null;
        try {
            in = new BufferedReader(new InputStreamReader(
                    activity.getResources().openRawResource(id)));
            String line;
            StringBuilder buffer = new StringBuilder();
            while ((line = in.readLine()) != null) buffer.append(line).append('\n');
            return buffer;
        } catch (IOException e) {
            return "";
        } finally {
            closeStream(in);
        }
    }

    private static void closeStream(Closeable stream) {
        if (stream != null) {
            try {
                stream.close();
            } catch (IOException e) {
                // Ignore
            }
        }
    }

  FractalType(int i) {
    native_integer = i;
  }

  public int getInt() {
    return native_integer;
  }

  public FractalView(Context context, AttributeSet attrs) {
        super(context, attrs);
        res = context.getResources();
        multiTouchController = new MultiTouchController<FractalView.Img>(this);
        this.setEquation(ComplexEquation.SECOND_ORDER);
  }

  public void setFractoid(Fractoid f) {
    mFractoid = f;
  }

  private void quadColorScheme(int numberOfColors,int[] color1,int[] color2,int[] color3,int[] color4) {
    
    for (int x = 0; x < numberOfColors; x++) {
      int value = (x%1020);
      int color;
      if (value <= 255) {
        colorIntegers[x] = Color.rgb((int)((double)((color2[0]-color1[0])/255.0)*value + color1[0]),
                                     (int)((double)((color2[1]-color1[1])/255.0)*value + color1[1]),
                                     (int)((double)((color2[2]-color1[2])/255.0)*value + color1[2])
                                    );
      } else if (value <= 510) {
        colorIntegers[x] = Color.rgb((int)((double)((color3[0]-color2[0])/255.0)*(value-255) + color2[0]),
                                     (int)((double)((color3[1]-color2[1])/255.0)*(value-255) + color2[1]),
                                     (int)((double)((color3[2]-color2[2])/255.0)*(value-255) + color2[2])
                                    );
      } else if (value <= 765) {
      

  private void calculateColors(int numberOfColors) {
    
    int[] color1,color2,color3,color4;
    double red, green, blue;
    colorIntegers = new int[numberOfColors];
    
    switch (colorSet) {
      case RAINBOW:
        for (int x = 0; x < numberOfColors; x++) {
          double data = x;
          data = 2*Math.PI*(data/1020);
          red = Math.sin(data + Math.PI*shiftFactor);
          green = Math.cos(data + Math.PI*shiftFactor);
          blue = -((red + green)*.707);
          red = (red*127.0) + 127.0;
          green = (green*127.0) + 127.0;
          blue = (blue*127.0) + 127.0;
          colorIntegers[x] = Color.rgb((int)red, (int)green, (int)blue);
        }    
        break;
      
      case WINTER:
        for (int x = 0; x < numberOfColors; x++) {
          int value = (x%1020)/2;
          int color;
          if (value <= 255)
            color = value;
          else
            color = 255-(value-255);
          colorIntegers[x] = Color.rgb(255-color,255-c

  public void setColorSet(ColorSet cs) {
    colorSet = cs;
    calculateColors(1021);
    startFractalTask(false);
  }

  public void setAlgorithm(Algorithm alg) {
    mNativeLib.setAlgorithm(alg.getInt(),alg.getBailout());
    startFractalTask(true);
  }

  public void setTrapFactor(int tf) {
    mNativeLib.setTrapFactor(tf);
    trapFactor = tf;
    startFractalTask(true);
  }

  public int getTrapFactor() {
    return trapFactor;
  }

  public int[] getColorSet() {
    return colorIntegers;
  }

  public ComplexEquation getEquation() {
    return equation;
  }

  public void setEquation(ComplexEquation e) {
    equation = e;
    mNativeLib.setEquation(e.getInt(),e.getPower());
  }

  public void setZoom(boolean z) {
    zoom = z;
  }

  public int getMaxIterations() {
    return maxIterations;
  }

  public void setMaxIterations(int i) {
    mNativeLib.setMaxIterations(i);
    maxIterations = i;
    startFractalTask(true);
  }

  public void recalculate() {

    double imagmin = mNativeLib.getImagMin();
    double imagmax = mNativeLib.getImagMax();
    double realmin = mNativeLib.getRealMin();
    double realmax = mNativeLib.getRealMax();
    double realRange = Math.abs(realmax-realmin);
    double imagRange = Math.abs(imagmax-imagmin);
    double half_irange = imagRange/2;
    double half_rrange = realRange/2;
    
    double centerX = (double)fractalBitmap.getCenterX();
    double centerY = (double)fractalBitmap.getCenterY();
    double scale = (double)fractalBitmap.getScale();
    
    double xres = (double)mNativeLib.getXRes();
    double yres = (double)mNativeLib.getYRes();

    double offsetX = realmin + half_rrange;
    double offsetY = imagmin + half_irange;
    
    realmin = realmin - offsetX;
    realmax = realmax - offsetX;
    imagmin = imagmin - offsetY;
    imagmax = imagmax - offsetY;
    
    double image_y_center = (imagmin + (centerY/yres)*imagRange)/scale;
    double image_x_center = (real

  public FractalType getType() {
    return fractalType;
  }

  public void setProgress(float p) {
    progress = p;
  }

  public Bitmap getFractal() {
    return fractalBitmap.getDrawable().getBitmap();
  }

  public void turnCalibrateButtonOn() {
    mFractoid.setCalibrateButtonEnabled(true,relative);
  }

  public void stopFractalTask() {
    if (mGenerateFractalTask != null && mGenerateFractalTask.getStatus() == Status.RUNNING) {
      mGenerateFractalTask.cancel(true);
    }
    
  }

  public void startFractalTask(boolean reset) {
    setFull = true;
    progress = 0;
    calculationTime = null;
    stopFractalTask();
    
    if (reset) {
      mNativeLib.resetValues();
      relative = false;
    }
    mNativeLib.resetCurrentRow();
    
    mFractoid.setCalibrateButtonEnabled(false,relative);
    
    calculateColors(1021);

    mGenerateFractalTask = new GenerateFractalTask(this,relative);
    System.out.println("Starting new fractal");
    mGenerateFractalTask.execute();
  }

  public void setRelative(boolean r) {
    relative = r;
  }

  public void setFractal(Bitmap fa) {
    BitmapDrawable bd = new BitmapDrawable(res, fa);
    if (setFull) {    
      fractalBitmap = new Img(bd, res);
      fractalBitmap.setFullScreen();
      setFull = false;
    } else {
      fractalBitmap.setDrawable(bd);
    }
  }

  public void setTime(long t) {
    long time = t / 1000;  
    String seconds = Integer.toString((int)(time % 60));  
    String minutes = Integer.toString((int)(time / 60));  
    for (int i = 0; i < 2; i++) {  
      if (seconds.length() < 2) {  
        seconds = "0" + seconds;  
      }  
      if (minutes.length() < 2) {  
        minutes = "0" + minutes;  
      }
    }
    calculationTime = "Time: "+minutes+":"+seconds;
  }

  protected void resetCoords() {
    double imagmax, imagmin;
    
    if (equation == ComplexEquation.BURNING_SHIP) {
      //This equation needs a special range to be centered
      imagmax = 2.1;
      imagmin = -0.7;
    } else {
      imagmax = 1.4;
      imagmin = -1.4;    
    }
    
    double r_y = Math.abs(imagmax - imagmin);
    double realmax = ((double)mNativeLib.getXRes()/mNativeLib.getYRes())*r_y/2;
    double realmin = ((double)mNativeLib.getXRes()/mNativeLib.getYRes())*r_y/2*-1;
    
    shiftFactor = Math.random()*2;
    mNativeLib.setCoords(realmin,realmax,imagmin,imagmax);
    
    if (equation == ComplexEquation.PHOENIX) {
      /*
      The mandelbrot fractal for this equation is ugly so
      we only allow the user to explore the Julia version
      */
      mNativeLib.setFractalType(FractalType.JULIA.getInt());
      fractalType = FractalType.JULIA;
      mNativeLib.setCValue(0.56666667,-0.5); //magic number for the best julia set
      mNativeLib.setMaxIteratio

  public void clearBackground() {
    backgroundBitmap = null;
  }

  public void mergeBitmaps() {
    Bitmap composite = Bitmap.createBitmap(mNativeLib.getXRes(), mNativeLib.getYRes(), Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(composite);
    
    if (backgroundBitmap != null) {
      backgroundBitmap.draw(canvas);
      clearBackground();
    }
    
    fractalBitmap.draw(canvas);
    BitmapDrawable bd = new BitmapDrawable(res, composite);
    fractalBitmap.setDrawable(bd);
    fractalBitmap.setFullScreen();
  }

  public Img getDraggableObjectAtPoint(PointInfo pt) {
    
    if (mGenerateFractalTask != null && mGenerateFractalTask.getStatus() == Status.RUNNING) {
      mGenerateFractalTask.cancel(true);
    }
    
    mergeBitmaps();
    
    return fractalBitmap;
  }

  public void selectObject(Img img, PointInfo touchPoint) {
    if (img == null) {
      System.out.println("fractalBitmap="+fractalBitmap.toString());
      backgroundBitmap = fractalBitmap;
      recalculate();
    }
    invalidate();
  }

  public void getPositionAndScale(Img img, PositionAndScale objPosAndScaleOut) {
    objPosAndScaleOut.set(img.getCenterX(), img.getCenterY(),true, img.getScale(),
                          false, 0.0f, 0.0f, false, 0.0f);
  }

  public boolean setPositionAndScale(Img img, PositionAndScale newImgPosAndScale, PointInfo touchPoint) {
    float x = newImgPosAndScale.getXOff();
    float y = newImgPosAndScale.getYOff();
    float scale = newImgPosAndScale.getScale();
    boolean ok = img.setPos(x, y, scale);
    if (ok)
      invalidate();
    return ok;
  }

  class Img {

    private BitmapDrawable drawable;
    private int width, height, displayWidth, displayHeight;
    private float centerX, centerY, scale;
    private float minX, maxX, minY, maxY;
    private static final float SCREEN_MARGIN = 100;
   
    public Img(BitmapDrawable bd, Resources res) {
      this.drawable = bd;
    }

    public void setFullScreen() {
      width = mNativeLib.getXRes();
      height = mNativeLib.getYRes();
      displayHeight = mNativeLib.getYRes();
      displayWidth = mNativeLib.getXRes();
      setPos(mNativeLib.getXRes()/2.0f, mNativeLib.getYRes()/2.0f, 1.0f);
    }

    /** Set the position and scale of an image in screen coordinates */
    private boolean setPos(float centerX, float centerY, float scale) {
      
      float ws = (width / 2) * scale, hs = (height / 2) * scale;
      float newMinX = centerX - ws, newMinY = centerY - hs, newMaxX = centerX + ws, newMaxY = centerY + hs;
      if (newMinX > displayWidth - SCREEN_MARGIN || newMaxX < SC

    public Img(BitmapDrawable bd, Resources res) {
      this.drawable = bd;
    }