Distorted Android

///////////////////////////////////////////////////////////////////////////////////////////////////

// Copyright 2016 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Distorted is free software: you can redistribute it and/or modify                             //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Distorted is distributed in the hope that it will be useful,                                  //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.examples.effects3d;

import android.view.View;

import android.widget.SeekBar;

import android.widget.TextView;

import org.distorted.examples.R;

import org.distorted.library.effect.Effect;

import org.distorted.library.effect.EffectName;

import org.distorted.library.effect.EffectType;

import org.distorted.library.effect.FragmentEffectAlpha;

import org.distorted.library.effect.FragmentEffectBrightness;

import org.distorted.library.effect.FragmentEffectChroma;

import org.distorted.library.effect.FragmentEffectContrast;

import org.distorted.library.effect.FragmentEffectSaturation;

import org.distorted.library.effect.MatrixEffectMove;

import org.distorted.library.effect.MatrixEffectQuaternion;

import org.distorted.library.effect.MatrixEffectRotate;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.effect.MatrixEffectShear;

import org.distorted.library.effect.VertexEffectDeform;

import org.distorted.library.effect.VertexEffectDistort;

import org.distorted.library.effect.VertexEffectPinch;

import org.distorted.library.effect.VertexEffectSink;

import org.distorted.library.effect.VertexEffectSwirl;

import org.distorted.library.effect.VertexEffectWave;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.type.Dynamic1D;

import org.distorted.library.type.Dynamic2D;

import org.distorted.library.type.Dynamic3D;

import org.distorted.library.type.Dynamic4D;

import org.distorted.library.type.Dynamic5D;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static2D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.library.type.Static5D;

import java.lang.ref.WeakReference;

///////////////////////////////////////////////////////////////////////////////////////////////////

class Effects3DEffect implements SeekBar.OnSeekBarChangeListener

  {

  private WeakReference<Effects3DActivity> mAct;

  private EffectName mName;

  private int[] mInter;

  private int[] mInterRegion;

  private int[] mInterCenter;

  private int[] mSeekID;

  private int[] mSeekRegionID;

  private int[] mSeekCenterID;

  private int mDimension;

  private TextView mText,mTextRegion,mTextCenter;

  private Dynamic1D mDyn1;

  private Dynamic2D mDyn2;

  private Dynamic3D mDyn3;

  private Dynamic4D mDyn4;

  private Dynamic5D mDyn5;

  private Static1D  mSta1;

  private Static2D  mSta2;

  private Static3D  mSta3;

  private Static4D  mSta4;

  private Static5D  mSta5;

  private Dynamic4D mRegionDyn;

  private Static4D  mRegionSta;

  private Dynamic3D mCenterDyn;

  private Static3D  mCenterSta;

  private View mButton, mEffect, mCenter, mRegion;

  private long mId;

///////////////////////////////////////////////////////////////////////////////////////////////////

// requires knowledge about effect nature

  void apply(DistortedEffects effects)

    {

    Effect effect=null;

    switch(mName)

      {

      case ROTATE           : effect = new MatrixEffectRotate(mDyn4, mCenterDyn); break;

      case QUATERNION       : effect = new MatrixEffectQuaternion(mDyn4, mCenterDyn); break;

      case MOVE             : effect = new MatrixEffectMove(mDyn3)            ; break;

      case SCALE            : effect = new MatrixEffectScale(mDyn3)            ; break;

      case SHEAR            : effect = new MatrixEffectShear(mDyn3, mCenterDyn); break;

      case DISTORT          : effect = new VertexEffectDistort(mDyn3, mCenterDyn, mRegionDyn); break;

      case DEFORM           : effect = new VertexEffectDeform(mDyn3, mCenterDyn, mRegionDyn); break;

      case SINK             : effect = new VertexEffectSink(mDyn1, mCenterDyn, mRegionDyn); break;

      case PINCH            : effect = new VertexEffectPinch(mDyn2, mCenterDyn, mRegionDyn); break;

      case SWIRL            : effect = new VertexEffectSwirl(mDyn1, mCenterDyn, mRegionDyn); break;

      case WAVE             : effect = new VertexEffectWave(mDyn5, mCenterDyn, mRegionDyn); break;

      case ALPHA            : effect = new FragmentEffectAlpha(mDyn1,        mRegionDyn, false); break;

      case SMOOTH_ALPHA     : effect = new FragmentEffectAlpha     (mDyn1,        mRegionDyn, true ); break;

      case CHROMA           : effect = new FragmentEffectChroma(mDyn1, mDyn3, mRegionDyn, false); break;

      case SMOOTH_CHROMA    : effect = new FragmentEffectChroma    (mDyn1, mDyn3, mRegionDyn, true ); break;

      case BRIGHTNESS       : effect = new FragmentEffectBrightness(mDyn1,        mRegionDyn, false); break;

      case SMOOTH_BRIGHTNESS: effect = new FragmentEffectBrightness(mDyn1,        mRegionDyn, true ); break;

      case SATURATION       : effect = new FragmentEffectSaturation(mDyn1,        mRegionDyn, false); break;

      case SMOOTH_SATURATION: effect = new FragmentEffectSaturation(mDyn1,        mRegionDyn, true ); break;

      case CONTRAST         : effect = new FragmentEffectContrast(mDyn1,        mRegionDyn, false); break;

      case SMOOTH_CONTRAST  : effect = new FragmentEffectContrast  (mDyn1,        mRegionDyn, true ); break;

      }

    if( effect!=null )

      {

      effects.apply(effect);

      mId = effect.getID();

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

// requires knowledge about effect nature

  private void fillStatics()

    {

    switch(mName)

      {

      case ROTATE           : float an = (mInter[0]-50)*180/50;

                              float rx = (mInter[1]-50)/ 50.0f;

                              float ry = (mInter[2]-50)/ 50.0f;

                              float rz = (mInter[3]-50)/ 50.0f;

                              mSta4.set(an,rx,ry,rz);

                              break;

      case QUATERNION       : float qx = (mInter[0]-50)/ 50.0f;

                              float qy = (mInter[1]-50)/ 50.0f;

                              float qz = (mInter[2]-50)/ 50.0f;

                              float qa = (mInter[3]-50)*3.1415f/50;

                              float cosA = (float)Math.cos(qa/2);

                              float len = (float)Math.sqrt(qx*qx+qy*qy+qz*qz);

                              float sinAnorm = (float)Math.sin(qa/2)/len;

                              mSta4.set(sinAnorm*qx,sinAnorm*qy,sinAnorm*qz, cosA);

                              break;

      case MOVE             : float sw = mAct.get().getScreenWidth()/50.0f;

                              float sh = mAct.get().getScreenWidth()/50.0f;

                              float xm = (mInter[0]-50)*sw;

                              float ym = (mInter[1]-50)*sh;

                              float zm = (mInter[2]-50)*(sw+sh)/2;

                              mSta3.set(xm,ym,zm);

                              break;

      case SCALE            : float xs = (mInter[0]>50 ? 0.18f : 0.018f)*(mInter[0]-50) + 1;

                              float ys = (mInter[1]>50 ? 0.18f : 0.018f)*(mInter[1]-50) + 1;

                              float zs = (mInter[2]>50 ? 0.18f : 0.018f)*(mInter[2]-50) + 1;

                              mSta3.set(xs,ys,zs);

                              break;

      case SHEAR            : float xsh = (mInter[0]-50)/25.0f;

                              float ysh = (mInter[1]-50)/25.0f;

                              float zsh = (mInter[2]-50)/25.0f;

                              mSta3.set(xsh,ysh,zsh);

                              break;

      case DISTORT          :

      case DEFORM           : float ld = mAct.get().getWidth()/50.0f;

                              float xd = (mInter[0]-50)*ld;

                              float yd = (mInter[1]-50)*ld;

                              float zd = (mInter[2]-50)*ld;

                              mSta3.set(xd,yd,zd);

                              break;

      case WAVE             : float l2 = mAct.get().getWidth()/50.0f;

                              float x2 = (mInter[0]-50)*l2;

                              float y2 = (mInter[1]-50)*l2;

                              float z2 = (mInter[2]-50)*180 / 50;

                              float w2 = (mInter[3]-50)*180 / 50;

                              float v2 = (mInter[4]-50)*180 / 50;

                              mSta5.set(x2,y2,z2,w2,v2);

                              break;

      case SWIRL            : mSta1.set( 3.6f*(mInter[0]-50) );

                              break;

      case SINK             : mSta1.set(mInter[0] > 50 ? 50.0f/(100.01f-mInter[0]) : mInter[0] / 50.0f);

                              break;

      case PINCH            : float dp = mInter[0] > 50 ? 50.0f/(100.01f-mInter[0]) : mInter[0] / 50.0f;

                              float ap = (mInter[1]-50)*180 / 50;

                              mSta2.set(dp,ap);

                              break;

      case ALPHA            :

      case SMOOTH_ALPHA     : mSta1.set(mInter[0]/100.0f);

                              break;

      case SATURATION       :

      case SMOOTH_SATURATION:

      case CONTRAST         :

      case SMOOTH_CONTRAST  :

      case BRIGHTNESS       :

      case SMOOTH_BRIGHTNESS: mSta1.set(mInter[0] > 50 ? 50.0f/(100.01f-mInter[0]) : mInter[0] / 50.0f);

                              break;

      case CHROMA           :

      case SMOOTH_CHROMA    : mSta1.set(mInter[0]/100.0f);

                              mSta3.set(mInter[1]/100.0f,

                                        mInter[2]/100.0f,

                                        mInter[3]/100.0f);

                              break;

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private void setDefaultInter()

    {

    switch(mDimension)

      {

      case 5: mInter[4] = 50;

      case 4: mInter[3] = 50;

      case 3: mInter[2] = 50;

      case 2: mInter[1] = 50;

      case 1: mInter[0] = 50;

      }

    if( mName==EffectName.ROTATE || mName==EffectName.QUATERNION ) mInter[1]= 100;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private void setText()

    {

    String text = mName.name();

    if( mSta1 !=null )

      {

      float f1 = ((int)(mSta1.getX()*100))/100.0f;

      text += " "+f1;

      }

    if( mSta2 !=null )

      {

      float f1 = ((int)(mSta2.getX()*100))/100.0f;

      float f2 = ((int)(mSta2.getY()*100))/100.0f;

      text += " ("+f1+","+f2+")";

      }

    if( mSta3 !=null )

      {

      float f1 = ((int)(mSta3.getX()*100))/100.0f;

      float f2 = ((int)(mSta3.getY()*100))/100.0f;

      float f3 = ((int)(mSta3.getZ()*100))/100.0f;

      text += " ("+f1+","+f2+","+f3+")";

      }

    if( mSta4 !=null )

      {

      float f1 = ((int)(mSta4.getX()*100))/100.0f;

      float f2 = ((int)(mSta4.getY()*100))/100.0f;

      float f3 = ((int)(mSta4.getZ()*100))/100.0f;

      float f4 = ((int)(mSta4.getW()*100))/100.0f;

      text += " ("+f1+","+f2+","+f3+","+f4+")";

      }

    if( mSta5 !=null )

      {

      float f1 = ((int)(mSta5.getX()*100))/100.0f;

      float f2 = ((int)(mSta5.getY()*100))/100.0f;

      float f3 = ((int)(mSta5.getZ()*100))/100.0f;

      float f4 = ((int)(mSta5.getW()*100))/100.0f;

      float f5 = ((int)(mSta5.getV()*100))/100.0f;

      text += " ("+f1+","+f2+","+f3+","+f4+","+f5+")";

      }

    mText.setText(text);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private void fillCenterStatics()

    {

    Effects3DActivity act = mAct.get();

    float x = (mInterCenter[0]*0.012f - 0.1f)*act.getWidth();

    float y = (mInterCenter[1]*0.012f - 0.1f)*act.getHeight();

    float z = (mInterCenter[2]*0.012f - 0.1f)*act.getDepth();

    mCenterSta.set(x,y,z);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private void setDefaultCenterInter()

    {

    mInterCenter[0] = 50;

    mInterCenter[1] = 50;

    mInterCenter[2] = 50;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private void setCenterText()

    {

    int f0 = (int)mCenterSta.getX();

    int f1 = (int)mCenterSta.getY();

    int f2 = (int)mCenterSta.getZ();

    mTextCenter.setText("center ("+f0+","+f1+","+f2+")");

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private void fillRegionStatics()

    {

    Effects3DActivity act = mAct.get();

    float factorX = act.getWidth() / 100.0f;

    float factorY = act.getHeight()/ 100.0f;

    int deduct = (mName.getType() == EffectType.VERTEX ? 50:0);

    float  x = (mInterRegion[0]-deduct)*factorX;

    float  y = (mInterRegion[1]-deduct)*factorY;

    float rx =  mInterRegion[2]        *factorX;

    float ry =  mInterRegion[3]        *factorY;

    mRegionSta.set(x,y,rx,ry);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private void setDefaultRegionInter()

    {

    mInterRegion[0] = 50;

    mInterRegion[1] = 50;

    mInterRegion[2] = 50;

    mInterRegion[3] = 50;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private void setRegionText()

    {

    int f0 = (int)mRegionSta.getX();

    int f1 = (int)mRegionSta.getY();

    int f2 = (int)mRegionSta.getZ();

    int f3 = (int)mRegionSta.getW();

    mTextRegion.setText("region ("+f0+","+f1+","+f2+","+f3+")");

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  Effects3DEffect(EffectName name, Effects3DActivity act)

    {

    mAct = new WeakReference<>(act);

    mName = name;

    mDyn1 = null;

    mDyn2 = null;

    mDyn3 = null;

    mDyn4 = null;

    mDyn5 = null;

    mSta1 = null;

    mSta2 = null;

    mSta3 = null;

    mSta4 = null;

    mSta5 = null;

    mDimension = mName.getDimension();

    switch(mDimension)

      {

      case 1 : mDyn1 = new Dynamic1D();

               mSta1 = new Static1D(0);

               mDyn1.add(mSta1);

               break;

      case 2 : mDyn2 = new Dynamic2D();

               mSta2 = new Static2D(0,0);

               mDyn2.add(mSta2);

               break;

      case 3 : mDyn3 = new Dynamic3D();

               mSta3 = new Static3D(0,0,0);

               mDyn3.add(mSta3);

               break;

      case 4 : if( mName == EffectName.ROTATE || mName == EffectName.QUATERNION )

                 {

                 mDyn4 = new Dynamic4D();

                 mSta4 = new Static4D(0,0,0,0);

                 mDyn4.add(mSta4);

                 }

               else

                 {

                 mDyn3 = new Dynamic3D();

                 mSta3 = new Static3D(0,0,0);

                 mDyn3.add(mSta3);

                 mDyn1 = new Dynamic1D();

                 mSta1 = new Static1D(0);

                 mDyn1.add(mSta1);

                 }

               break;

      case 5 : mDyn5 = new Dynamic5D();

               mSta5 = new Static5D(0,0,0,0,0);

               mDyn5.add(mSta5);

               break;

      default: throw new RuntimeException("unsupported effect");

      }

    mInter = new int[mDimension];

    mSeekID= new int[mDimension];

    mInterRegion = new int[4];

    mSeekRegionID= new int[4];

    mRegionDyn   = new Dynamic4D();

    mRegionSta   = new Static4D(0,0,0,0);

    mRegionDyn.add(mRegionSta);

    mInterCenter = new int[3];

    mSeekCenterID= new int[3];

    mCenterDyn   = new Dynamic3D();

    mCenterSta   = new Static3D(0,0,0);

    mCenterDyn.add(mCenterSta);

    mButton = null;

    mEffect = null;

    mCenter = null;

    mRegion = null;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  View createView()

    {

    SeekBar[] seek = new SeekBar[mDimension];

    Effects3DActivity act = mAct.get();

    switch(mDimension)

      {

      case 1 : mEffect    = act.getLayoutInflater().inflate(R.layout.effect1d, null);

               mText      = (TextView)mEffect.findViewById(R.id.effect1dText);

               seek[0]    = (SeekBar)mEffect.findViewById(R.id.effect1dbar1);

               mSeekID[0] = seek[0].getId();

               mButton    = mEffect.findViewById(R.id.button1dRemove);

               break;

      case 2 : mEffect    = act.getLayoutInflater().inflate(R.layout.effect2d, null);

               mText      = (TextView)mEffect.findViewById(R.id.effect2dText);

               seek[0]    = (SeekBar)mEffect.findViewById(R.id.effect2dbar1);

               seek[1]    = (SeekBar)mEffect.findViewById(R.id.effect2dbar2);

               mSeekID[0] = seek[0].getId();

               mSeekID[1] = seek[1].getId();

               mButton    = mEffect.findViewById(R.id.button2dRemove);

               break;

      case 3 : mEffect    = act.getLayoutInflater().inflate(R.layout.effect3d, null);

               mText      = (TextView)mEffect.findViewById(R.id.effect3dText);

               seek[0]    = (SeekBar)mEffect.findViewById(R.id.effect3dbar1);

               seek[1]    = (SeekBar)mEffect.findViewById(R.id.effect3dbar2);

               seek[2]    = (SeekBar)mEffect.findViewById(R.id.effect3dbar3);

               mSeekID[0] = seek[0].getId();

               mSeekID[1] = seek[1].getId();

               mSeekID[2] = seek[2].getId();

               mButton    = mEffect.findViewById(R.id.button3dRemove);

               break;

      case 4 : mEffect    = act.getLayoutInflater().inflate(R.layout.effect4d, null);

               mText      = (TextView)mEffect.findViewById(R.id.effect4dText);

               seek[0]    = (SeekBar)mEffect.findViewById(R.id.effect4dbar1);

               seek[1]    = (SeekBar)mEffect.findViewById(R.id.effect4dbar2);

               seek[2]    = (SeekBar)mEffect.findViewById(R.id.effect4dbar3);

               seek[3]    = (SeekBar)mEffect.findViewById(R.id.effect4dbar4);

               mSeekID[0] = seek[0].getId();

               mSeekID[1] = seek[1].getId();

               mSeekID[2] = seek[2].getId();

               mSeekID[3] = seek[3].getId();

               mButton    = mEffect.findViewById(R.id.button4dRemove);

               break;

      case 5 : mEffect    = act.getLayoutInflater().inflate(R.layout.effect5d, null);

               mText      = (TextView)mEffect.findViewById(R.id.effect5dText);

               seek[0]    = (SeekBar)mEffect.findViewById(R.id.effect5dbar1);

               seek[1]    = (SeekBar)mEffect.findViewById(R.id.effect5dbar2);

               seek[2]    = (SeekBar)mEffect.findViewById(R.id.effect5dbar3);

               seek[3]    = (SeekBar)mEffect.findViewById(R.id.effect5dbar4);

               seek[4]    = (SeekBar)mEffect.findViewById(R.id.effect5dbar5);

               mSeekID[0] = seek[0].getId();

               mSeekID[1] = seek[1].getId();

               mSeekID[2] = seek[2].getId();

               mSeekID[3] = seek[3].getId();

               mSeekID[4] = seek[4].getId();

               mButton    = mEffect.findViewById(R.id.button5dRemove);

               break;

      default: android.util.Log.e("Matrix3DEffect", "dimension "+mDimension+" not supported!");

               return null;

      }

    setDefaultInter();

    for(int i=0; i<mDimension; i++)

      {

      seek[i].setOnSeekBarChangeListener(this);

      seek[i].setProgress( mInter[i] );

      }

    act.setSupportsCenter(mName.supportsCenter());

    act.setSupportsRegion(mName.supportsRegion());

    return mEffect;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  View createRegion()

    {

    Effects3DActivity act = mAct.get();

    mRegion = act.getLayoutInflater().inflate(R.layout.effectregion, null);

    SeekBar[] seek = new SeekBar[4];

    seek[0] = (SeekBar)mRegion.findViewById(R.id.effectRegionBarX );

    seek[1] = (SeekBar)mRegion.findViewById(R.id.effectRegionBarY );

    seek[2] = (SeekBar)mRegion.findViewById(R.id.effectRegionBarRX);

    seek[3] = (SeekBar)mRegion.findViewById(R.id.effectRegionBarRY);

    mSeekRegionID[0] = seek[0].getId();

    mSeekRegionID[1] = seek[1].getId();

    mSeekRegionID[2] = seek[2].getId();

    mSeekRegionID[3] = seek[3].getId();

    mTextRegion = (TextView)mRegion.findViewById(R.id.effectRegionText);

    setDefaultRegionInter();

    for(int i=0; i<4; i++)

      {

      seek[i].setOnSeekBarChangeListener(this);

      seek[i].setProgress( mInterRegion[i] );

      }

    act.setRegion(mRegionSta.getX(),mRegionSta.getY(),mRegionSta.getZ());

    return mRegion;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  View createCenter()

    {

    Effects3DActivity act = mAct.get();

    mCenter = act.getLayoutInflater().inflate(R.layout.effectcenter, null);

    SeekBar[] seek = new SeekBar[3];

    seek[0] = (SeekBar)mCenter.findViewById(R.id.effectCenterBarX );

    seek[1] = (SeekBar)mCenter.findViewById(R.id.effectCenterBarY );

    seek[2] = (SeekBar)mCenter.findViewById(R.id.effectCenterBarZ );

    mSeekCenterID[0] = seek[0].getId();

    mSeekCenterID[1] = seek[1].getId();

    mSeekCenterID[2] = seek[2].getId();

    mTextCenter = (TextView)mCenter.findViewById(R.id.effectCenterText);

    setDefaultCenterInter();

    for(int i=0; i<3; i++)

      {

      seek[i].setOnSeekBarChangeListener(this);

      seek[i].setProgress( mInterCenter[i] );

      }

    act.setCenter(mCenterSta.getX(),mCenterSta.getY(),mCenterSta.getZ());

    return mCenter;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public void onProgressChanged(SeekBar bar, int progress, boolean fromUser)

    {

    if ( mDimension>=1 && bar.getId()==mSeekID[0] )

      {

      mInter[0] = progress;

      fillStatics();

      setText();

      }

    if ( mDimension>=2 && bar.getId()==mSeekID[1] )

      {

      mInter[1] = progress;

      fillStatics();

      setText();

      }

    if ( mDimension>=3 && bar.getId()==mSeekID[2] )

      {

      mInter[2] = progress;

      fillStatics();

      setText();

      }

    if ( mDimension>=4 && bar.getId()==mSeekID[3] )

      {

      mInter[3] = progress;

      fillStatics();

      setText();

      }

    if ( mDimension>=5 && bar.getId()==mSeekID[4] )

      {

      mInter[4] = progress;

      fillStatics();

      setText();

      }

    if( bar.getId() == mSeekRegionID[0] )

      {

      mInterRegion[0] = progress;

      fillRegionStatics();

      setRegionText();

      }

    if( bar.getId() == mSeekRegionID[1] )

      {

      mInterRegion[1] = progress;

      fillRegionStatics();

      setRegionText();

      }

    if( bar.getId() == mSeekRegionID[2] )

      {

      mInterRegion[2] = progress;

      fillRegionStatics();

      setRegionText();

      }

    if( bar.getId() == mSeekRegionID[3] )

      {

      mInterRegion[3] = progress;

      fillRegionStatics();

      setRegionText();

      }

    if( bar.getId() == mSeekCenterID[0] )

      {

      mInterCenter[0] = progress;

      fillCenterStatics();

      setCenterText();

      }

    if( bar.getId() == mSeekCenterID[1] )

      {

      mInterCenter[1] = progress;

      fillCenterStatics();

      setCenterText();

      }

    if( bar.getId() == mSeekCenterID[2] )

      {

      mInterCenter[2] = progress;

      fillCenterStatics();

      setCenterText();

      }

    if( fromUser )

      {

      Effects3DActivity act = mAct.get();

      boolean show = (mName.getType()==EffectType.VERTEX);

      boolean showR= (show && act.getShowRegion());

      boolean showC= (show && act.getShowCenter());

      Effects3DSurfaceView view = (Effects3DSurfaceView)act.findViewById(R.id.effects3dSurfaceView);

      view.getRenderer().showRegionAndCenter( showR,showC );

      act.setSupportsCenter(mName.supportsCenter());

      act.setSupportsRegion(mName.supportsRegion());

      act.setCenter(mCenterSta.getX(),mCenterSta.getY(),mCenterSta.getZ());

      act.setRegion(mRegionSta.getX(),mRegionSta.getY(),mRegionSta.getZ());

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  boolean thisView(View v)

    {

    return v==mButton;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public long getId()

    {

    return mId;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public View getEffect()

    {

    return mEffect;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public View getRegion()

    {

    return mRegion;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public View getCenter()

    {

    return mCenter;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public void onStartTrackingTouch(SeekBar bar) { }

///////////////////////////////////////////////////////////////////////////////////////////////////