public class ImageViewer extends View
{
       private Bitmap image = null;
          
       public ImageViewer(Context context)
       {
           super(context);
       }
          
       @Override
       public void onDraw(Canvas canvas)
       {
           if (image != null) canvas.drawBitmap(image, 0, 0, null);
       }

       public void loadImage(String fileName)
       {
           image = BitmapFactory.decodeFile(fileName);
       }
}

public class ImageViewer extends View
{
       private Bitmap image = null;
          
       private final GestureDetector gestureDetector;
          
       public ImageViewer(Context context)
       {
           super(context);
           gestureDetector = new GestureDetector(context, new MyGestureListener());
       }
          
       @Override
       public boolean onTouchEvent(MotionEvent event)
       {
           if (gestureDetector.onTouchEvent(event)) return true;
           return true;
       }

       private class MyGestureListener extends SimpleOnGestureListener
       {
           @Override
           public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY)
           {
               scrollBy((int)distanceX, (int)distanceY);
               return true;
           }
       }
}

<?xml version="1.0" encoding="utf-8"?>
<resources>
       <declare-styleable name="View">
           <attr name="android:background"/>
           <attr name="android:clickable"/>
           <attr name="android:contentDescription"/>
           <attr name="android:drawingCacheQuality"/>
           <attr name="android:duplicateParentState"/>
           <attr name="android:fadeScrollbars"/>
           <attr name="android:fadingEdge"/>
           <attr name="android:fadingEdgeLength"/>
           <attr name="android:fitsSystemWindows"/>
           <attr name="android:focusable"/>
           <attr name="android:focusableInTouchMode"/>
           <attr name="android:hapticFeedbackEnabled"/>
           <attr name="android:id"/>
           <attr name="android:isScrollContainer"/>
           <attr name="android:keepScreenOn"/>
           <attr name="android:longClickable"/>
           <attr name="android:minHeight"/>
           <attr name="android:minWidth"/>
           <attr name="android:nextFocusDown"/>
           <attr name="android:nextFocusLeft"/>
           <attr name="android:nextFocusRight"/>
           <attr name="android:nextFocusUp"/>
           <attr name="android:onClick"/>
           <attr name="android:padding"/>
           <attr name="android:paddingBottom"/>
           <attr name="android:paddingLeft"/>
           <attr name="android:paddingRight"/>
           <attr name="android:paddingTop"/>
           <attr name="android:saveEnabled"/>
           <attr name="android:scrollX"/>
           <attr name="android:scrollY"/>
           <attr name="android:scrollbarAlwaysDrawHorizontalTrack"/>
           <attr name="android:scrollbarAlwaysDrawVerticalTrack"/>
           <attr name="android:scrollbarDefaultDelayBeforeFade"/>
           <attr name="android:scrollbarFadeDuration"/>
           <attr name="android:scrollbarSize"/>
           <attr name="android:scrollbarStyle"/>
           <attr name="android:scrollbarThumbHorizontal"/>
           <attr name="android:scrollbarThumbVertical"/>
           <attr name="android:scrollbarTrackHorizontal"/>
           <attr name="android:scrollbarTrackVertical"/>
           <attr name="android:scrollbars"/>
           <attr name="android:soundEffectsEnabled"/>
           <attr name="android:tag"/>
           <attr name="android:visibility"/>
       </declare-styleable>
</resources>

public class ImageViewer extends View
{
       private Bitmap image = null;
          
       private final GestureDetector gestureDetector;
          
       public ImageViewer(Context context)
       {
           super(context);
              
           gestureDetector = new GestureDetector(context, new MyGestureListener());
              
           // init scrollbars
           setHorizontalScrollBarEnabled(true);
           setVerticalScrollBarEnabled(true);

           TypedArray a = context.obtainStyledAttributes(R.styleable.View);
           initializeScrollbars(a);
           a.recycle();
       }
          
       @Override
       protected int computeHorizontalScrollRange()
       {
           return image.getWidth();
       }

       @Override
       protected int computeVerticalScrollRange()
       {
           return image.getHeight();
       }
}

public class ImageViewer extends View
{
       private Bitmap image = null;
          
       private final GestureDetector gestureDetector;
       private final Scroller scroller;
          
       public ImageViewer(Context context)
       {
           super(context);
              
           gestureDetector = new GestureDetector(context, new MyGestureListener());
           scroller = new Scroller(context);
              
           // init scrollbars
           setHorizontalScrollBarEnabled(true);
           setVerticalScrollBarEnabled(true);

           TypedArray a = context.obtainStyledAttributes(R.styleable.View);
           initializeScrollbars(a);
           a.recycle();
       }

       @Override
       public void computeScroll()
       {
           if (scroller.computeScrollOffset())
           {
               int oldX = getScrollX();
               int oldY = getScrollY();
               int x = scroller.getCurrX();
               int y = scroller.getCurrY();
               scrollTo(x, y);
               if (oldX != getScrollX() || oldY != getScrollY())
               {
                   onScrollChanged(getScrollX(), getScrollY(), oldX, oldY);
               }

               postInvalidate();
           }
       }

       private class MyGestureListener extends SimpleOnGestureListener
       {
           @Override
           public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY)
           {
               scroller.fling(getScrollX(), getScrollY(), -(int)velocityX, -(int)velocityY, 0, image.getWidth() - getWidth(), 0, image.getHeight() - getHeight());
               awakenScrollBars(scroller.getDuration());
                  
               return true;
           }
       }
}

@Override
public boolean onTouchEvent(MotionEvent event)
{
       // check for tap and cancel fling
       if ((event.getAction() & MotionEvent.ACTION_MASK) == MotionEvent.ACTION_DOWN)
       {
           if (!scroller.isFinished()) scroller.abortAnimation();
       }

       if (gestureDetector.onTouchEvent(event)) return true;
       return true;
}

@Override
public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY)
{
       boolean scrollBeyondImage = ((getScrollX() < 0) || (getScrollX() > image.getWidth()) || (getScrollY() < 0) || (getScrollY() > image.getHeight()));
       if (scrollBeyondImage) return false;

       scroller.fling(getScrollX(), getScrollY(), -(int)velocityX, -(int)velocityY, 0, image.getWidth() - getWidth(), 0, image.getHeight() - getHeight());
       awakenScrollBars(scroller.getDuration());

       return true;
}

@Override
public boolean onTouchEvent(MotionEvent event)
{
       // check for tap and cancel fling
       if ((event.getAction() & MotionEvent.ACTION_MASK) == MotionEvent.ACTION_DOWN)
       {
           if (!scroller.isFinished()) scroller.abortAnimation();
       }

       if (gestureDetector.onTouchEvent(event)) return true;

       // check for pointer release    
       if ((event.getPointerCount() == 1) && ((event.getAction() & MotionEvent.ACTION_MASK) == MotionEvent.ACTION_UP))
       {
           int newScrollX = getScrollX();
           if (getScrollX() < 0) newScrollX = 0;
           else if (getScrollX() > image.getWidth() - getWidth()) newScrollX = image.getWidth() - getWidth();

           int newScrollY = getScrollY();
           if (getScrollY() < 0) newScrollY = 0;
           else if (getScrollY() > image.getHeight() - getHeight()) newScrollY = image.getHeight() - getHeight();

           if ((newScrollX != getScrollX()) || (newScrollY != getScrollY()))
           {
               scroller.startScroll(getScrollX(), getScrollY(), newScrollX - getScrollX(), newScrollY - getScrollY());
               awakenScrollBars(scroller.getDuration());
           }
       }

       return true;
}

public class GameView extends View {

       private Bitmap mBitmap;
       private Canvas mCanvas;
       private Paint paint, mBitmapPaint;
       private float canvasSize;
       private final int horizontalCountOfCells, verticalCountOfCells;

       public GameView(Context context, AttributeSet attrs) {
           super(context, attrs);
           //размер игрового поля
           horizontalCountOfCells =10;
           verticalCountOfCells =10;
           //в xml разметке позднее пропишем размер вьюхи равный 300dp
           canvasSize=(int)convertDpToPixel(300, context);

           mBitmap = Bitmap.createBitmap((int) canvasSize, (int) canvasSize, Bitmap.Config.ARGB_8888);
           mCanvas = new Canvas(mBitmap);
           mBitmapPaint = new Paint(Paint.DITHER_FLAG);

           //определяем параметры кисти, которой будем рисовать сетку и атомы
           paint =new Paint();
           paint.setAntiAlias(true);
           paint.setDither(true);
           paint.setColor(0xffff0505);
           paint.setStrokeWidth(5f);
           paint.setStyle(Paint.Style.STROKE);
           paint.setStrokeJoin(Paint.Join.ROUND);
           paint.setStrokeCap(Paint.Cap.ROUND);

           //рисуем сетку
           for(int x=0;x< horizontalCountOfCells +1;x++)
               mCanvas.drawLine((float)x* canvasSize / horizontalCountOfCells, 0, (float)x* canvasSize / horizontalCountOfCells, canvasSize, paint);
           for(int y=0;y< verticalCountOfCells +1;y++)
               mCanvas.drawLine(0, (float)y* canvasSize / verticalCountOfCells, canvasSize, (float)y* canvasSize / verticalCountOfCells, paint);
       }

       @Override
       protected void onDraw(Canvas canvas) {
           canvas.drawBitmap(mBitmap, 0, 0, mBitmapPaint);
       }

       //переводим dp в пиксели
       public float convertDpToPixel(float dp,Context context){
           Resources resources = context.getResources();
           DisplayMetrics metrics = resources.getDisplayMetrics();
           return dp * (metrics.densityDpi/160f);
       }
}

public class GameActivity extends Activity {
       
       Override
       public void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           setContentView(R.layout.main);
       }
}

<LinearLayout xmlns:android=«schemas.android.com/apk/res/android»
           android:orientation=«vertical»
           android:layout_width=«fill_parent»
           android:layout_height=«fill_parent»
           android:background="#aaa"
           android:gravity=«center_horizontal»>
<com.devindi.chain.GameView
           android:layout_width=«300dp»
           android:layout_height=«300dp»
           android:id="@+id/game_view"
           android:layout_gravity=«center»
           android:background="#000"/>
</LinearLayout>

private final ScaleGestureDetector scaleGestureDetector;
       private final int viewSize;
       private float mScaleFactor;
       
       public GameView(Context context, AttributeSet attrs) {
          //в xml разметке позднее пропишем размер вьюхи равный 300dp
           viewSize=(int)convertDpToPixel(300, context);
           mScaleFactor=1f;//значение зума по умолчанию
           canvasSize=(int)(viewSize*mScaleFactor);//определяем размер канваса           
           …
           scaleGestureDetector=new ScaleGestureDetector(context, new MyScaleGestureListener());
}
       
       @Override
       protected void onDraw(Canvas canvas) {
           canvas.save();
           canvas.scale(mScaleFactor, mScaleFactor);//зумируем канвас
           canvas.drawBitmap(mBitmap, 0, 0, mBitmapPaint);
           canvas.restore();
       }

       //в случае касания пальем передаем управление MyScaleGestureListener
       @Override
       public boolean onTouchEvent(MotionEvent event) {
           scaleGestureDetector.onTouchEvent(event);
           return true;
       }

       //унаследовались от ScaleGestureDetector.SimpleOnScaleGestureListener, чтобы не писать пустую реализацию ненужных
       //методов интерфейса OnScaleGestureListener
       private class MyScaleGestureListener extends ScaleGestureDetector.SimpleOnScaleGestureListener {
           //обрабатываем "щипок" пальцами
           @Override
           public boolean onScale(ScaleGestureDetector scaleGestureDetector) {
               float scaleFactor=scaleGestureDetector.getScaleFactor();//получаем значение зума относительно предыдущего состояния
               //получаем координаты фокальной точки - точки между пальцами
               float focusX=scaleGestureDetector.getFocusX();
               float focusY=scaleGestureDetector.getFocusY();
               //следим чтобы канвас не уменьшили меньше исходного размера и не допускаем увеличения больше чем в 2 раза
               if(mScaleFactor*scaleFactor>1 && mScaleFactor*scaleFactor<2){
                   mScaleFactor *= scaleGestureDetector.getScaleFactor();
                   canvasSize =viewSize*mScaleFactor;//изменяем хранимое в памяти значение размера канваса
                   //используется при расчетах
                   //по умолчанию после зума канвас отскролит в левый верхний угол.
                   //Скролим канвас так, чтобы на экране оставалась
                   //область канваса, над которой был жест зума
                   //Для получения данной формулы достаточно школьных знаний математики (декартовы координаты).
                   int scrollX=(int)((getScrollX()+focusX)*scaleFactor-focusX);
                   scrollX=Math.min( Math.max(scrollX, 0), (int) canvasSize -viewSize);
                   int scrollY=(int)((getScrollY()+focusY)*scaleFactor-focusY);
                   scrollY=Math.min( Math.max(scrollY, 0), (int) canvasSize -viewSize);
                   scrollTo(scrollX, scrollY);
               }
               //вызываем перерисовку принудительно
               invalidate();
               return true;
           }
       }

private final GestureDetector detector;
       public GameView(Context context, AttributeSet attrs) {
       ...
       detector=new GestureDetector(context, new MyGestureListener());
       }

       //в случае касания пальем передаем обработку Motion Event'а MyGestureListener'у и MyScaleGestureListener'у
       @Override
       public boolean onTouchEvent(MotionEvent event) {
           detector.onTouchEvent(event);
           scaleGestureDetector.onTouchEvent(event);
           return true;
       }

       //унаследовались от GestureDetector.SimpleOnGestureListener, чтобы не писать пустую
       //реализацию ненужных методов интерфейса OnGestureListener
       private class MyGestureListener extends GestureDetector.SimpleOnGestureListener
       {
           //обрабатываем скролл (перемещение пальца по экрану)
           @Override
           public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY)
           {
               //не даем канвасу показать края по горизонтали
               if(getScrollX()+distanceX< canvasSize -viewSize && getScrollX()+distanceX>0){
                   scrollBy((int)distanceX, 0);
               }
               //не даем канвасу показать края по вертикали
               if(getScrollY()+distanceY< canvasSize -viewSize && getScrollY()+distanceY>0){
                   scrollBy(0, (int)distanceY);
               }
               return true;
           }

           //обрабатываем одиночный тап
           @Override
           public boolean onSingleTapConfirmed(MotionEvent event){
               //получаем координаты ячейки, по которой тапнули
               int cellX=(int)((event.getX()+getScrollX())/mScaleFactor);
               int cellY=(int)((event.getY()+getScrollY())/mScaleFactor);
               return true;
           }

           //обрабатываем двойной тап
           @Override
           public boolean onDoubleTapEvent(MotionEvent event){
               //зумируем канвас к первоначальному виду
               mScaleFactor=1f;
               canvasSize =viewSize;
               scrollTo(0, 0);//скролим, чтобы не было видно краев канваса.
               invalidate();//перерисовываем канвас
               return true;
           }
       }    

void drawAtoms(int cellX, int cellY, int color, int count){
           //считаем координаты центра ячейки
           float x0=((1f/(2* horizontalCountOfCells))*viewSize+(1f/ horizontalCountOfCells)*cellX*viewSize);
           float y0=((1f/(2* verticalCountOfCells))*viewSize+(1f/ verticalCountOfCells)*cellY*viewSize);
           paint.setColor(color);
           switch (count){
               //todo non-absolute values
               case 1:
                   drawAtoms(cellX, cellY, color, 0);//стираем существующие атомы
                   mCanvas.drawCircle(x0, y0, 3, paint);//рисуем один атом в центре ячейки
                   break;
               case 2:
                   drawAtoms(cellX, cellY, color, 0);
                   //рисуем пару атомов на удалении от центра ячейки
                   mCanvas.drawCircle(x0-7, y0, 3, paint);
                   mCanvas.drawCircle(x0+7, y0, 3, paint);
                   break;
               case 3:
                   drawAtoms(cellX, cellY, color, 0);
                   //рисуем три атома в вершинах правильного треугольника с центром в центре ячейки
                   mCanvas.drawCircle(x0 - 7, y0 + 4, 3, paint);
                   mCanvas.drawCircle(x0 + 7, y0 + 4, 3, paint);
                   mCanvas.drawCircle(x0, y0-8, 3, paint);
                   break;
               case 4:
                   drawAtoms(cellX, cellY, color, 0);
                   //рисуем 4 атом в вершинах квадрата с центром в центре ячейки
                   mCanvas.drawCircle(x0-7, y0-7, 3, paint);
                   mCanvas.drawCircle(x0-7, y0+7, 3, paint);
                   mCanvas.drawCircle(x0+7, y0+7, 3, paint);
                   mCanvas.drawCircle(x0+7, y0-7, 3, paint);
                   break;
               case 0:
                   //устанавливаем кисти режим стирания
                   paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
                   //заполнение обойденного участка
                   paint.setStyle(Paint.Style.FILL);
                   //рисуем большой круг, на месте которого ничего не останется
                   mCanvas.drawCircle(x0, y0, 17, paint);
                   //возвращаем исходные параметры
                   paint.setStyle(Paint.Style.STROKE);
                   paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC));
                   break;
           }
           invalidate();//перерисовываем канвас
       }

public class GameLogic {
       private class Cell{
            int player=0, countOfAtoms=0;//хозяин ячейки, количество атомов в ячейке
            final int maxCountOfAtoms;//емкость ячейки
           
            Cell(int maxCountOfAtoms){
                this.maxCountOfAtoms=maxCountOfAtoms;
            }
           
            public int getCountOfAtoms() {
                return countOfAtoms;
            }
           
            public int getPlayer() {
                return player;
            }
           
            public void setPlayer(int player) {
                this.player = player;
            }
           
            public void resetCount() {
                this.countOfAtoms = 0;
            }
           
            public void addAtom(){
                this.countOfAtoms++;
            }
           
            boolean isFilled(){
                return this.countOfAtoms == this.maxCountOfAtoms;
            }
        }
       }

private final GameView view;
       private final GameActivity activity;
       private int moveNumber=0, currentPlayer=0;
       private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
       private final Cell[][] cells;

       private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
       private final Handler mHandler;

       public GameLogic(GameView view, GameActivity activity) {
           this.view = view;
           this.activity=activity;
           mHandler=new Handler();
           //инициализируем игровые параметры (количество игроков, размер доски)
           this.COUNT_OF_PLAYERS=2;
           this.BOARD_HEIGHT=10;
           this.BOARD_WIDTH=10;
           cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
           for(int x=0; x<BOARD_WIDTH; x++){
               for(int y=0; y<BOARD_HEIGHT; y++){
                   if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
                       cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
                   }else
                   if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
                       cells[x][y]=new Cell(3);//краевые, но не угловые - 3
                   }else{
                       cells[x][y]=new Cell(4);//остальные - 4
                   }
               }
           }
       }

       //вызывается из вьюхи по одиночному тапу
       public void addAtom(final int cellX, final int cellY) {
           //получаем ячейку, в которую добавляем атом, если ее нет в массиве - выходим из функции.
           final Cell currentCell;
           try{
               currentCell=cells[cellX][cellY];
           }catch (IndexOutOfBoundsException ex){
               return;
           }
           //если в ячейке уже есть атомы этого игрока
           if(currentCell.getPlayer()==currentPlayer){
               currentCell.addAtom();
               view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
               //если ячейка заполнена
               if(currentCell.isFilled()){
                   final List<Cell> nearby=new ArrayList<Cell>(4);//лист соседних ячеек
                   selfAddCell(cellX, cellY-1, nearby);
                   selfAddCell(cellX, cellY+1, nearby);
                   selfAddCell(cellX-1, cellY, nearby);
                   selfAddCell(cellX+1, cellY, nearby);
                   for(Cell nearbyCell:nearby){
                       nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
                   }
                   delayedAddAtom(cellX, cellY-1);
                   delayedAddAtom(cellX, cellY+1);
                   delayedAddAtom(cellX-1, cellY);
                   delayedAddAtom(cellX+1, cellY);
                   //через секунду произойдет вызов метода run()
                   mHandler.postDelayed(new Runnable() {
                       @Override
                       public void run() {
                           //текущая ячейка становится нейтральной (ничейной)
                           currentCell.setPlayer(-1);
                           //и пустой
                           currentCell.resetCount();
                           view.drawAtoms(cellX, cellY, 0x000000, 0);
                       }
                   }, 1000);
                   return;
               }
           }else if(currentCell.getPlayer()==-1){
               currentCell.addAtom();
               view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
               currentCell.setPlayer(currentPlayer);
           }else{
               return;
           }
       }

       //через секунду соседние ячйки получат по атому
       private void delayedAddAtom(final int cellX, final int cellY){
           mHandler.postDelayed(new Runnable() {
               @Override
               public void run() {
                   addAtom(cellX, cellY);
               }
           }, 1000);
       }

       //добавляем в лист target существующие ячейки
       private void selfAddCell(int cellX, int cellY, List<Cell> target){
           try{
               target.add(cells[cellX][cellY]);
           }catch (IndexOutOfBoundsException ignore){}
       }    

int[] score=scoring();
           if(moveNumber==0){
               endTurn(score);
           }else {
               //проверка на конец игры. Нельзя делать в теле метода endTurn() потому что
               //не определим конец игры при бесконечной реакции
               int losersCount=0;
               for(int i=0; i<COUNT_OF_PLAYERS; i++){
                   if(score[i]==0)
                       losersCount++;
               }
               if(losersCount+1==COUNT_OF_PLAYERS){
                   isEndGame=true;
               }
               if(!mHandler.hasMessages(0)){
                   view.unlock();
                   endTurn(score);
               }
           }
       }

       //обработка конца хода
       private void endTurn(int[] score){
           if(!isEndGame){
               if(currentPlayer == COUNT_OF_PLAYERS-1){
                   moveNumber++;
                   currentPlayer=0;
               }else {
                   currentPlayer++;
               }
           }else{
               activity.endGame(currentPlayer, score[currentPlayer]);
           }
           //извещаем активити, о том, что поменялся счет, текущий игрок и номер хода
           activity.setMoveNumber(moveNumber);
           activity.setPlayerName(currentPlayer);
           activity.setScore(score);

       }

       //подсчет очков
       int[] scoring(){
           int[] score=new int[COUNT_OF_PLAYERS];
           for(int x=0; x<BOARD_WIDTH; x++){
               for(int y=0; y<BOARD_HEIGHT; y++){
                   if(cells[x][y].getPlayer()!=-1){
                       score[cells[x][y].getPlayer()]+=cells[x][y].getCountOfAtoms();
                   }
               }
           }
           return score;
       }

void setPlayerName(int playerID){}

       void setScore(int[] score){}

       void setMoveNumber(int moveNumber){}

       void endGame(int winnerID, int score){}

$site = c("edit1")->text;
$get = file_get_contents("http://ololool.ru/hit?t2q3e8.2;r;s13366*768*24;uhtrdrtp%3A//$site/;0.789101");
c("browser1")->text = "$get";

Веб-страница недоступна
Веб-страница по адресу http://sql3.hostinger.com.ua/phpmyadmin/import.php, возможно, временно недоступна или постоянно перемещена по новому адресу.
Ошибка 103 (net::ERR_CONNECTION_ABORTED): Неизвестная ошибка.