app/src/main/java/jp/sourceforge/gokigen/memoma/drawers/MeMoMaCanvasDrawer.java

   1 package jp.sourceforge.gokigen.memoma.drawers;
   2
   3 import java.util.Enumeration;
   4 import android.content.SharedPreferences;
   5 import android.graphics.Bitmap;
   6 import android.graphics.BitmapFactory;
   7 import android.graphics.Canvas;
   8 import android.graphics.Color;
   9 import android.graphics.DashPathEffect;
  10 import android.graphics.Paint;
  11 import android.graphics.Path;
  12 import android.graphics.RectF;
  13 import android.preference.PreferenceManager;
  14 import android.util.Log;
  15 import android.view.MotionEvent;
  16 import android.view.GestureDetector;
  17 import android.view.ScaleGestureDetector;
  18 import android.widget.SeekBar;
  19 import android.widget.TextView;
  20
  21 import androidx.appcompat.app.AppCompatActivity;
  22
  23 import jp.sourceforge.gokigen.memoma.holders.ObjectConnector;
  24 import jp.sourceforge.gokigen.memoma.holders.PositionObject;
  25 import jp.sourceforge.gokigen.memoma.operations.IObjectSelectionReceiver;
  26 import jp.sourceforge.gokigen.memoma.io.ImageLoader;
  27 import jp.sourceforge.gokigen.memoma.R;
  28 import jp.sourceforge.gokigen.memoma.holders.LineStyleHolder;
  29 import jp.sourceforge.gokigen.memoma.holders.MeMoMaConnectLineHolder;
  30 import jp.sourceforge.gokigen.memoma.holders.MeMoMaObjectHolder;
  31 import jp.sourceforge.gokigen.memoma.holders.OperationModeHolder;
  32
  33 /**
  34  *    メモまの描画クラス
  35  *
  36  * @author MRSa
  37  *
  38  */
  39 public class MeMoMaCanvasDrawer implements ICanvasDrawer,  GestureDetector.OnGestureListener, ScaleGestureDetector.OnScaleGestureListener, SeekBar.OnSeekBarChangeListener
  40 {
  41         private final String TAG = toString();
  42
  43         public static final float OBJECTLABEL_MARGIN = 8.0f;
  44         public static final float OBJECTLABEL_MARGIN_WIDTH = 24.0f;
  45
  46         public static final int BACKGROUND_COLOR_DEFAULT = 0xff004000;
  47         private int backgroundColor = BACKGROUND_COLOR_DEFAULT;
  48
  49         private PositionObject selectedPosition = null;
  50         private float tempPosX = Float.MIN_VALUE;
  51         private float tempPosY = Float.MIN_VALUE;
  52         private float downPosX = Float.MIN_VALUE;
  53         private float downPosY = Float.MIN_VALUE;
  54
  55         // 以下の値は、MeMoMaListenerで初期値を設定する
  56         private int objectStyle = MeMoMaObjectHolder.DRAWSTYLE_RECTANGLE;
  57
  58         private final LineStyleHolder lineStyleHolder;
  59
  60         private float drawScale = 1.0f;    // 表示の倍率
  61         private float drawTransX  = 0.0f;   // 並行移動距離 (X)
  62         private float drawTransY  = 0.0f;   // 並行移動距離 (Y)
  63         private boolean onScaling = false;  // ピンチイン・ピンチアウト操作しているかどうかを示す
  64         private int currentScaleBar= 50;  // 現在のピンチイン・ピンチアウト倍率
  65
  66         private boolean onGestureProcessed = false;   // 長押し時の処理を行なっているかどうかを示す。
  67
  68         private float screenWidth = 0.0f;  // 表示領域の幅
  69         private float screenHeight = 0.0f; // 表示領域の高さ
  70
  71         private int displayObjectInformation = 1;  // オブジェクトラベルの表示
  72
  73         private String backgroundBitmapUri = null;
  74         private Bitmap backgroundBitmap = null;
  75
  76         private final MeMoMaObjectHolder objectHolder;
  77         private final MeMoMaConnectLineHolder lineHolder;
  78         private final IObjectSelectionReceiver selectionReceiver;
  79
  80         private final GestureDetector gestureDetector;
  81         private final ScaleGestureDetector scaleGestureDetector;
  82
  83         private final AppCompatActivity parent;
  84
  85         /**
  86       *   コンストラクタ
  87       *
  88       */
  89           public MeMoMaCanvasDrawer(AppCompatActivity argument, MeMoMaObjectHolder object, LineStyleHolder styleHolder, IObjectSelectionReceiver receiver)
  90           {
  91                   objectHolder = object;
  92                   lineHolder = objectHolder.getConnectLineHolder();
  93                   selectionReceiver = receiver;
  94                   lineStyleHolder = styleHolder;
  95                   parent = argument;
  96
  97                   // ジェスチャを検出するクラスを生成する
  98                   gestureDetector = new GestureDetector(argument, this);
  99                   scaleGestureDetector = new ScaleGestureDetector(argument, this);
 100
 101                   // ズーム倍率を展開する
 102                   restoreTranslateAndZoomScale();
 103           }
 104
 105           /**
 106            *   オブジェクトの形状を変更する
 107            *   (ここで指定された形状のチェックを行っておく。)
 108            *
 109            *
 110            */
 111           public void setObjectStyle(int style)
 112           {
 113                   switch (style)
 114                   {
 115                     case MeMoMaObjectHolder.DRAWSTYLE_OVAL:
 116                     case MeMoMaObjectHolder.DRAWSTYLE_ROUNDRECT:
 117                     case MeMoMaObjectHolder.DRAWSTYLE_RECTANGLE:
 118                     case MeMoMaObjectHolder.DRAWSTYLE_DIAMOND:
 119                     case MeMoMaObjectHolder.DRAWSTYLE_KEYBOARD:
 120                     case MeMoMaObjectHolder.DRAWSTYLE_PAPER:
 121                     case MeMoMaObjectHolder.DRAWSTYLE_DRUM:
 122                     case MeMoMaObjectHolder.DRAWSTYLE_PARALLELOGRAM:
 123                     case MeMoMaObjectHolder.DRAWSTYLE_HEXAGONAL:
 124                     case MeMoMaObjectHolder.DRAWSTYLE_CIRCLE:
 125                     case MeMoMaObjectHolder.DRAWSTYLE_NO_REGION:
 126                     case MeMoMaObjectHolder.DRAWSTYLE_LOOP_START:
 127                     case MeMoMaObjectHolder.DRAWSTYLE_LOOP_END:
 128                     case MeMoMaObjectHolder.DRAWSTYLE_LEFT_ARROW:
 129                     case MeMoMaObjectHolder.DRAWSTYLE_DOWN_ARROW:
 130                     case MeMoMaObjectHolder.DRAWSTYLE_UP_ARROW:
 131                     case MeMoMaObjectHolder.DRAWSTYLE_RIGHT_ARROW:
 132                         objectStyle = style;
 133                             break;
 134
 135                     default:
 136                         objectStyle = MeMoMaObjectHolder.DRAWSTYLE_RECTANGLE;
 137                             break;
 138                   }
 139           }
 140
 141           /**
 142            *
 143            *
 144            */
 145           public void updateBackgroundBitmap(String uri, int width, int height)
 146           {
 147                   // 背景画像の文字列を記憶する
 148                   backgroundBitmapUri = uri;
 149
 150                   // とりあえず、背景画像をクリアしてガベコレする。
 151                   backgroundBitmap = null;
 152                   System.gc();
 153                   if (uri.isEmpty())
 154                   {
 155                           // 背景画像の指定がなかったので、ここでリターンする。
 156                           return;
 157                   }
 158                   try
 159                   {
 160                           // とりあえず設定する情報をログに残してみる
 161                           Log.v(TAG, "MeMoMaCanvasDrawer::updateBackgroundBitmap() : w:" + width + " , h:"+ height + " " + uri);
 162
 163                           // 背景画像を取得して設定する。
 164                           backgroundBitmap = ImageLoader.getBitmapFromUri(parent, ImageLoader.parseUri(uri), width, height);
 165                   }
 166                   catch (Exception ex)
 167                   {
 168                           Log.v(TAG, "MeMoMaCanvasDrawer::updateBackgroundBitmap() : " + uri + " , "+ ex.toString());
 169                           ex.printStackTrace();
 170                           backgroundBitmap = null;
 171                           backgroundBitmapUri = "";
 172                           System.gc();
 173                   }
 174           }
 175
 176           /**
 177            *   背景画像を設定する
 178            *
 179            *
 180            */
 181           public void setBackgroundUri(String uri)
 182           {
 183                   backgroundBitmapUri = uri;
 184           }
 185
 186           /**
 187            *   背景色を(文字列で)設定する
 188            *
 189            *
 190            */
 191           public void setBackgroundColor(String colorString)
 192           {
 193                   try
 194                   {
 195                           backgroundColor = Color.parseColor(colorString);
 196                           return;
 197                   }
 198                   catch (Exception ex)
 199                   {
 200                           //
 201               //Log.v(Main.APP_IDENTIFIER, "Ex:" + ex.toString() + " " + ex.getMessage());
 202                   }
 203                   backgroundColor = BACKGROUND_COLOR_DEFAULT;
 204           }
 205
 206           /**
 207            *    初期化ロジックを設定する
 208            *
 209            */
 210           public void prepareToStart(int width, int height)
 211           {
 212           Log.v(TAG, "MeMoMaCanvasDrawer::prepareToStart() " + "x:" + width + " , " + "y:" + height);
 213
 214           // 背景画像を更新する
 215                   //updateBackgroundBitmap(backgroundBitmapUri, width, height);
 216
 217                   // Preferenceを読み出す
 218                   SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(parent);
 219                   displayObjectInformation = Integer.parseInt(preferences.getString("objectPrintData", "1"));
 220           }
 221
 222           /**
 223            *    画面の大きさが変わってしまった場合...
 224            *
 225            */
 226           public  void changedScreenProperty(int format, int width, int height)
 227           {
 228                   // 背景画像を更新する
 229                   updateBackgroundBitmap(backgroundBitmapUri, width, height);
 230
 231                   // 表示画面サイズを覚える
 232                   screenWidth = width;
 233                   screenHeight = height;
 234
 235           Log.v(TAG, "changedScreenProperty() " + "x:" + width + " , " + "y:" + height);
 236           }
 237
 238
 239           /**
 240            *    キャンバスにオブジェクト（と接続線）を表示する
 241            *
 242            */
 243           public void drawOnCanvas(Canvas canvas)
 244           {
 245                 //Log.v(Main.APP_IDENTIFIER, "MeMoMaCanvasDrawer::drawOnCanvas()");
 246                 try
 247                 {
 248                         // 画面全体をクリアする
 249                         //canvas.drawColor(Color.argb(backgroundColorAlfa, backgroundColorRed, backgroundColorGreen, backgroundColorBlue), Mode.CLEAR);
 250                         canvas.drawColor(backgroundColor);
 251
 252                         // 背景画像が設定されていた場合は、背景画像を描画する
 253                         if (backgroundBitmap != null)
 254                         {
 255                             canvas.drawBitmap(backgroundBitmap, 0, 0, new Paint());
 256                         }
 257
 258                         // 表示位置を移動させる
 259                         canvas.translate(drawTransX, drawTransY);
 260
 261                         // 画面の表示領域を拡大・縮小する
 262                         canvas.scale(drawScale, drawScale);
 263
 264                         // オブジェクト間の接続線をすべて表示する
 265                         drawConnectionLines(canvas, 0.0f, 0.0f);
 266
 267                 // オブジェクトをすべて表示
 268                         drawObjects(canvas, 0.0f, 0.0f);
 269
 270                 //  移動中かどうかのチェックを行う。
 271                         if (isFlicking(canvas))
 272                         {
 273                     // 移動中の場合、フリック時の軌跡と現在位置を表示する
 274                             drawTrackAndPositions(canvas);
 275                         }
 276                 }
 277                 catch (Exception ex)
 278                 {
 279                         // 例外発生...でもそのときには何もしない
 280                         Log.v(TAG, "drawOnCanvas() ex: " + ex.getMessage());
 281                 }
 282           }
 283
 284           /**
 285            *    オブジェクトをBitmapCanvas上に描く
 286            *
 287            */
 288           public void drawOnBitmapCanvas(Canvas canvas, float offsetX, float offsetY)
 289           {
 290                 try
 291                 {
 292                         Paint paint = new Paint();
 293
 294                         // 画面全体をクリアする
 295                         canvas.drawColor(backgroundColor);
 296
 297                         // 背景画像が設定されていた場合は、背景画像を描画する
 298                         if (backgroundBitmap != null)
 299                         {
 300                             canvas.drawBitmap(backgroundBitmap, offsetX, offsetY, paint);
 301                         }
 302
 303                         // オブジェクト間の接続線をすべて表示する
 304                         drawConnectionLines(canvas, offsetX, offsetY);
 305
 306                 // オブジェクトをすべて表示
 307                         drawObjects(canvas, offsetX, offsetY);
 308
 309                         // タイトルとめもまのアイコンを表示する : 文字の色は黒でいいのかな...
 310                         Bitmap bitmap = BitmapFactory.decodeResource(parent.getResources(), R.drawable.icon1);
 311                         canvas.drawBitmap(bitmap, 2.0f, 2.0f, paint);
 312
 313                 // 文字をライトグレー、ちょっと影付きにする
 314                 paint.setColor(Color.LTGRAY);
 315                 paint.setStyle(Paint.Style.FILL_AND_STROKE);
 316                 paint.setShadowLayer(0.5f, 0.5f, 0.5f, Color.DKGRAY);
 317
 318                         canvas.drawText(objectHolder.getDataTitle(), (bitmap.getWidth() + 10.0f), 32.0f, paint);
 319
 320                 }
 321                 catch (Exception ex)
 322                 {
 323                         // 例外発生...でもそのときには何もしない
 324                         Log.v(TAG, "drawOnBitmapCanvas() ex: " + ex.toString() + " " + ex.getMessage());
 325                 }
 326           }
 327
 328           /**
 329            *    オブジェクト間の接続線を表示する
 330            *
 331            *
 332            */
 333           private void drawConnectionLines(Canvas canvas, float offsetX, float offsetY)
 334           {
 335                 // オブジェクトの色と枠線を設定する （連続線用）
 336                 Paint paint = new Paint();
 337                 paint.setColor(Color.WHITE);
 338                 paint.setStyle(Paint.Style.STROKE);
 339
 340                 // オブジェクトの色と枠線を設定する  （点線用）
 341                 Paint dashLinePaint = new Paint();
 342                 dashLinePaint.setColor(Color.WHITE);
 343                 dashLinePaint.setStyle(Paint.Style.STROKE);
 344                 dashLinePaint.setPathEffect(new DashPathEffect(new float[]{ 5.0f, 5.0f }, 0));
 345
 346                 // オブジェクトの描画 （保持しているものはすべて表示する）
 347                 Enumeration<Integer> keys = lineHolder.getLineKeys();
 348                 while (keys.hasMoreElements())
 349                 {
 350                     Integer key = keys.nextElement();
 351                     ObjectConnector line = lineHolder.getLine(key);
 352                     if (line.getKey() > 0)
 353                     {
 354                     // 実際にラインを引く
 355                         drawLine(canvas, paint, dashLinePaint, line, offsetX, offsetY);
 356                     }
 357                     else
 358                     {
 359                         // ここは呼ばれないはず。。。消したはずのものが残っている
 360                         Log.v(TAG, "DETECTED DELETED LINE");
 361                     }
 362                 }
 363           }
 364
 365           /**
 366            *    接続する線を引く
 367        *
 368            */
 369           private void drawLine(Canvas canvas, Paint paint, Paint dashPaint, ObjectConnector line, float offsetX, float offsetY)
 370           {
 371                   try
 372                   {
 373                           if ((objectHolder == null)||(canvas == null))
 374                           {
 375                                   // なにもしない
 376                                   return;
 377                           }
 378
 379                           PositionObject from = objectHolder.getPosition(line.getFromObjectKey());
 380                           PositionObject to = objectHolder.getPosition(line.getToObjectKey());
 381                           if ((from == null)||(to == null))
 382                           {
 383                                   // なにもしない
 384                                   return;
 385                           }
 386
 387                           // ラインの太さを設定する。
 388                           paint.setStrokeWidth((float) line.getLineThickness());
 389
 390                           // ラインの太さを設定する。
 391                           dashPaint.setStrokeWidth((float) line.getLineThickness());
 392
 393                           // ラインのスタイル(連続線 or 点線)を設定する
 394                           Paint linePaint = (line.getLineShape() == LineStyleHolder.LINESHAPE_DASH) ? dashPaint : paint;
 395
 396                           // 初期値として、各オブジェクトの中心座標を設定する
 397                           RectF fromRect = from.getRect();
 398                           RectF toRect = to.getRect();
 399                           float startX = fromRect.centerX() + offsetX;
 400                           float endX = toRect.centerX() + offsetX;
 401                           float startY = fromRect.centerY() + offsetY;
 402                           float endY = toRect.centerY() + offsetY;
 403
 404                           // Y座標の線の位置を補正する
 405                           if (fromRect.bottom < toRect.top)
 406                           {
 407                   startY = fromRect.bottom + offsetY;
 408                   endY = toRect.top + offsetY;
 409                           }
 410                           else if (fromRect.top > toRect.bottom)
 411                           {
 412                   startY = fromRect.top + offsetY;
 413                   endY = toRect.bottom + offsetY;
 414                           }
 415
 416                           // X座標の線の位置を補正する (Y座標が補正されていないとき)
 417               if ((startY != (fromRect.top + offsetY))&&(startY != (fromRect.bottom + offsetY)))
 418                           {
 419                           if (fromRect.right < toRect.left)
 420                           {
 421                       startX = fromRect.right + offsetX;
 422                       endX = toRect.left + offsetX;
 423                           }
 424                           else if (fromRect.left > toRect.right)
 425                           {
 426                       startX = fromRect.left + offsetX;
 427                       endX = toRect.right + offsetX;
 428                           }
 429                           }
 430
 431                           int lineStyle = line.getLineStyle();
 432                           if ((lineStyle == LineStyleHolder.LINESTYLE_TREESTYLE_NO_ARROW)||
 433                                           (lineStyle == LineStyleHolder.LINESTYLE_TREESTYLE_L_ARROW)||
 434                                           (lineStyle == LineStyleHolder.LINESTYLE_TREESTYLE_R_ARROW))
 435                           {
 436                                   // ツリー形式のように接続する ...
 437                                   if (startX == (fromRect.centerX() + offsetX))
 438                                   {
 439                                           float middleY = (startY + endY) / 2;
 440                                       canvas.drawLine(startX, startY, startX, middleY, linePaint);
 441                                       canvas.drawLine(startX, middleY, endX, middleY, linePaint);
 442                                       canvas.drawLine(endX, middleY, endX, endY, linePaint);
 443
 444                                       // やじるしをつける処理
 445                                       if (lineStyle == LineStyleHolder.LINESTYLE_TREESTYLE_L_ARROW)
 446                                       {
 447                                           // 始点に矢印をつける
 448                                           ObjectShapeDrawer.drawArrowTree(canvas, paint, startX,startY, middleY, false);
 449                                       }
 450                                       else if (lineStyle == LineStyleHolder.LINESTYLE_TREESTYLE_R_ARROW)
 451                                       {
 452                                           // 終点に矢印をつける
 453                                           ObjectShapeDrawer.drawArrowTree(canvas, paint, endX, endY, middleY, false);
 454                                       }
 455                                   }
 456                                   else
 457                                   {
 458                                           float middleX = (startX + endX) / 2;
 459                                       canvas.drawLine(startX, startY, middleX, startY, linePaint);
 460                                       canvas.drawLine(middleX, startY, middleX, endY, linePaint);
 461                                       canvas.drawLine(middleX, endY, endX, endY, linePaint);
 462
 463                                       // やじるし(三角形)をつける処理
 464                                       if (lineStyle == LineStyleHolder.LINESTYLE_TREESTYLE_L_ARROW)
 465                                       {
 466                                           // 始点に矢印をつける
 467                                           ObjectShapeDrawer.drawArrowTree(canvas, paint, startX, startY, middleX, true);
 468                                       }
 469                                       else if (lineStyle == LineStyleHolder.LINESTYLE_TREESTYLE_R_ARROW)
 470                                       {
 471                                           // 終点に矢印をつける
 472                                           ObjectShapeDrawer.drawArrowTree(canvas, paint, endX,endY, middleX, true);
 473                                       }
 474                                   }
 475                           }
 476                           else if ((lineStyle == LineStyleHolder.LINESTYLE_CURVESTYLE_NO_ARROW)||
 477                                           (lineStyle == LineStyleHolder.LINESTYLE_CURVESTYLE_L_ARROW)||
 478                                           (lineStyle == LineStyleHolder.LINESTYLE_CURVESTYLE_R_ARROW))
 479                           {
 480                   // 曲線で接続する
 481                                   float middleX = (startX + endX) / 2;
 482                                   float middleY = (startY + endY) / 2;
 483                                   float x1 = (startX + middleX) / 2;
 484                                   float x2 = (middleX + endX) / 2;
 485
 486                               Path pathLine = new Path();
 487                               pathLine.moveTo(startX, startY);
 488                               pathLine.cubicTo(x1, middleY, x2, middleY, endX, endY);
 489                               canvas.drawPath(pathLine, linePaint);
 490
 491                               //  やじるしをつける処理
 492                               if (lineStyle == LineStyleHolder.LINESTYLE_CURVESTYLE_L_ARROW)
 493                               {
 494                                   // 始点に矢印をつける
 495                                   ObjectShapeDrawer.drawArrow(canvas, paint, startX, startY, endX, endY);
 496                               }
 497                               else if (lineStyle == LineStyleHolder.LINESTYLE_CURVESTYLE_R_ARROW)
 498                               {
 499                                   // 終点に矢印をつける
 500                                   ObjectShapeDrawer.drawArrow(canvas, paint, endX, endY, startX, startY);
 501                               }
 502                           }
 503               else  // if (line.lineStyle == MeMoMaConnectLineHolder.LINESTYLE_STRAIGHT)
 504                           {
 505                               // 直線で接続する
 506                               canvas.drawLine(startX, startY, endX, endY, linePaint);
 507
 508                               //  やじるしをつける処理
 509                               if (lineStyle == LineStyleHolder.LINESTYLE_STRAIGHT_L_ARROW)
 510                               {
 511                                   // 始点に矢印をつける
 512                                   ObjectShapeDrawer.drawArrow(canvas, paint, startX, startY, endX, endY);
 513                               }
 514                               else if (lineStyle == LineStyleHolder.LINESTYLE_STRAIGHT_R_ARROW)
 515                               {
 516                                   // 終点に矢印をつける
 517                                   ObjectShapeDrawer.drawArrow(canvas, paint, endX, endY, startX, startY);
 518                               }
 519                           }
 520                   }
 521                   catch (Exception ex)
 522                   {
 523                           // なにもしない
 524                           Log.v(TAG, "EXCEPTION :" + ex.toString());
 525                   }
 526           }
 527
 528     /**
 529      *   オブジェクトを動かしている最中かどうかの判定を行う。
 530      *
 531      *
 532      * @return  trueなら、動かしている最中
 533      */
 534     private boolean isFlicking(Canvas canvas)
 535     {
 536         return (!((tempPosX == Float.MIN_VALUE)||(tempPosY == Float.MIN_VALUE)));
 537     }
 538
 539     /**
 540      *   フリック時の軌跡と現在地点を表示する
 541      *
 542      *
 543      */
 544     private void drawTrackAndPositions(Canvas canvas)
 545     {
 546         // フリック時の軌跡を表示する
 547         float x = (tempPosX - drawTransX) / drawScale;
 548         float y = (tempPosY - drawTransY) / drawScale;
 549
 550         Paint paint = new Paint();
 551         paint.setStyle(Paint.Style.STROKE);
 552         paint.setColor(Color.GRAY);
 553         if (selectedPosition != null)
 554         {
 555             RectF objRect = selectedPosition.getRect();
 556                 float objX = (objRect.right - objRect.left) / 2;
 557                 float objY = (objRect.bottom - objRect.top) / 2;
 558             canvas.drawLine(objRect.centerX(), objRect.centerY(), x, y, paint);
 559             canvas.drawRect((x - objX), (y - objY), (x + objX), (y + objY), paint);
 560
 561             // 現在地点の表示
 562             drawObject(canvas, selectedPosition, true, 0.0f, 0.0f);
 563         }
 564         else   // オブジェクト非選択時の表示
 565         {
 566                 int data = selectionReceiver.touchedVacantArea();
 567                 if (data == OperationModeHolder.OPERATIONMODE_MOVE)
 568                 {
 569                 // 移動モードのとき... （表示領域を移動させる）
 570                         drawTransX = (tempPosX - downPosX);
 571                         drawTransY = (tempPosY - downPosY);
 572
 573                         //  表示領域の移動を記憶する
 574                 SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(parent);
 575                 SharedPreferences.Editor editor = preferences.edit();
 576                 editor.putFloat("drawTransX", drawTransX);
 577                 editor.putFloat("drawTransY", drawTransY);
 578                 editor.apply();
 579                 }
 580                 else
 581                 {
 582                         // 移動モード以外
 583                 paint.setColor(Color.YELLOW);
 584                     canvas.drawLine(((downPosX) / drawScale), ((downPosY) / drawScale), x,  y, paint);
 585                 }
 586         }
 587     }
 588
 589     /**
 590      *    オブジェクト（１個）を表示する
 591      *
 592      */
 593     private void drawObject(Canvas canvas, PositionObject object, boolean isMoving, float offsetX, float offsetY)
 594     {
 595         float label_offsetX = OBJECTLABEL_MARGIN;
 596         float label_offsetY = 0.0f;
 597
 598         // オブジェクトの色と枠線を設定する
 599         Paint paint = new Paint();
 600         if (isMoving)
 601         {
 602             paint.setColor(Color.YELLOW);
 603                 paint.setStyle(Paint.Style.STROKE);
 604             paint.setStrokeWidth(object.getstrokeWidth());
 605         }
 606         else
 607         {
 608             paint.setColor(object.getObjectColor());
 609             paint.setStyle(Paint.Style.valueOf(object.getPaintStyle()));
 610             paint.setStrokeWidth(object.getstrokeWidth());
 611         }
 612
 613        // 図形の形状に合わせて描画する
 614         RectF objectShape = new RectF(object.getRect());
 615         objectShape.left = objectShape.left + offsetX;
 616         objectShape.right = objectShape.right + offsetX;
 617         objectShape.top = objectShape.top + offsetY;
 618         objectShape.bottom = objectShape.bottom + offsetY;
 619
 620         int drawStyle = object.getDrawStyle();
 621         if (drawStyle == MeMoMaObjectHolder.DRAWSTYLE_OVAL)
 622                 {
 623                         // 楕円形の描画
 624                 label_offsetY = ObjectShapeDrawer.drawObjectOval(canvas, objectShape, paint);
 625                 }
 626                 else if (drawStyle == MeMoMaObjectHolder.DRAWSTYLE_ROUNDRECT)
 627                 {
 628                         // 丸角四角形の描画
 629                         label_offsetY = ObjectShapeDrawer.drawObjectRoundRect(canvas, objectShape, paint);
 630                 }
 631                 else if (drawStyle == MeMoMaObjectHolder.DRAWSTYLE_DIAMOND)
 632                 {
 633                         // 菱形の描画
 634                         label_offsetY = ObjectShapeDrawer.drawObjectDiamond(canvas, objectShape, paint);
 635             label_offsetX = OBJECTLABEL_MARGIN;
 636         }
 637                 else if (drawStyle == MeMoMaObjectHolder.DRAWSTYLE_KEYBOARD)
 638                 {
 639                         // 台形(キーボード型)の描画
 640                         label_offsetY = ObjectShapeDrawer.drawObjectKeyboard(canvas, objectShape, paint);
 641         }
 642                 else if (drawStyle == MeMoMaObjectHolder.DRAWSTYLE_PARALLELOGRAM)
 643                 {
 644                         // 平行四辺形の描画
 645                         label_offsetY = ObjectShapeDrawer.drawObjectParallelogram(canvas, objectShape, paint);
 646         }
 647                 else if (drawStyle == MeMoMaObjectHolder.DRAWSTYLE_HEXAGONAL)
 648                 {
 649                         // 六角形の描画
 650                         label_offsetY = ObjectShapeDrawer.drawObjectHexagonal(canvas, objectShape, paint);
 651         }
 652                 else if (drawStyle == MeMoMaObjectHolder.DRAWSTYLE_PAPER)
 653                 {
 654                         // 書類の形の描画
 655                         label_offsetY = ObjectShapeDrawer.drawObjectPaper(canvas, objectShape, paint);
 656         }
 657                 else if (drawStyle == MeMoMaObjectHolder.DRAWSTYLE_DRUM)
 658                 {
 659                         // 円柱の描画
 660                         label_offsetY = ObjectShapeDrawer.drawObjectDrum(canvas, objectShape, paint, Paint.Style.valueOf(object.getPaintStyle()));
 661         }
 662                 else if (drawStyle == MeMoMaObjectHolder.DRAWSTYLE_CIRCLE)
 663                 {
 664                         // 円を描画する
 665                         label_offsetY = ObjectShapeDrawer.drawObjectCircle(canvas, objectShape, paint);
 666                 }
 667                 else if (drawStyle == MeMoMaObjectHolder.DRAWSTYLE_NO_REGION)
 668                 {
 669                           // 枠なしを描画（？）する ... なにもしない
 670                           if (object.getLabel().length() == 0)
 671                           {
 672                                   // 何も表示しないとわからないので、ラベルが無いときには枠を表示する
 673                                   ObjectShapeDrawer.drawObjectNoRegion(canvas, objectShape, paint);
 674                           }
 675                 }
 676                 else if (drawStyle == MeMoMaObjectHolder.DRAWSTYLE_LOOP_START)
 677                 {
 678                         // ループ開始図形の描画
 679                         label_offsetY = ObjectShapeDrawer.drawObjectLoopStart(canvas, objectShape, paint);
 680         }
 681                 else if (drawStyle == MeMoMaObjectHolder.DRAWSTYLE_LOOP_END)
 682                 {
 683                         // ループ終了図形の描画
 684                         label_offsetY = ObjectShapeDrawer.drawObjectLoopEnd(canvas, objectShape, paint);
 685         }
 686                 else if (drawStyle == MeMoMaObjectHolder.DRAWSTYLE_LEFT_ARROW)
 687                 {
 688                         // 左側矢印図形の描画
 689                         label_offsetY = ObjectShapeDrawer.drawObjectLeftArrow(canvas, objectShape, paint);
 690         }
 691                 else if (drawStyle == MeMoMaObjectHolder.DRAWSTYLE_DOWN_ARROW)
 692                 {
 693                         // 下側矢印図形の描画
 694                         label_offsetY = ObjectShapeDrawer.drawObjectDownArrow(canvas, objectShape, paint);
 695         }
 696                 else if (drawStyle == MeMoMaObjectHolder.DRAWSTYLE_UP_ARROW)
 697                 {
 698                         // 上側矢印図形の描画
 699                         label_offsetY = ObjectShapeDrawer.drawObjectUpArrow(canvas, objectShape, paint);
 700         }
 701                 else if (drawStyle == MeMoMaObjectHolder.DRAWSTYLE_RIGHT_ARROW)
 702                 {
 703                         // 右側矢印図形の描画
 704                         label_offsetY = ObjectShapeDrawer.drawObjectRightArrow(canvas, objectShape, paint);
 705         }
 706                 else // if (pos.drawStyle == MeMoMaObjectHolder.DRAWSTYLE_RECTANGLE)
 707         {
 708             // 四角形を描画する
 709             label_offsetY = ObjectShapeDrawer.drawObjectRect(canvas, objectShape, paint);
 710         }
 711
 712         // 文字サイズを設定する。
 713         paint.setTextSize(object.getFontSize());
 714
 715         // 文字ラベルを表示する
 716         ObjectShapeDrawer.drawTextLabel(canvas, paint, object, objectShape, displayObjectInformation, label_offsetX, label_offsetY);
 717     }
 718
 719     /**
 720      *   オブジェクトをすべて表示する
 721      *
 722      *
 723      */
 724     private void drawObjects(Canvas canvas , float offsetX, float offsetY)
 725     {
 726         // オブジェクトの描画 （保持しているものはすべて表示する）
 727         Enumeration<Integer> keys = objectHolder.getObjectKeys();
 728         while (keys.hasMoreElements())
 729         {
 730             Integer key = keys.nextElement();
 731             PositionObject pos = objectHolder.getPosition(key);
 732             drawObject(canvas, pos, false, offsetX, offsetY);
 733         }
 734     }
 735
 736     /**
 737      *   タッチされたタイミングでの処理
 738      *
 739      */
 740     private boolean onTouchDown(MotionEvent event)
 741     {
 742         // タッチ位置を記憶する
 743         downPosX = event.getX() - drawTransX;
 744         downPosY = event.getY() - drawTransY;
 745
 746         // タッチ位置をオブジェクト画像の座標に変換する
 747         float x = downPosX / drawScale;
 748         float y = downPosY / drawScale;
 749
 750         // タッチ位置にオブジェクトが存在するか確認する
 751         selectedPosition = checkSelectedObject(x, y);
 752         if (selectedPosition == null)
 753         {
 754                 // 最初にタップしたときの位置を selectedPositionに設定する
 755                 int data = selectionReceiver.touchedVacantArea();
 756                 if (data == OperationModeHolder.OPERATIONMODE_CREATE)
 757                 {
 758                         // オブジェクト作成モードのとき...オブジェクトを生成する
 759                         selectedPosition = objectHolder.createPosition(x, y, objectStyle);
 760
 761                         // オブジェクトが生成されたことを通知する
 762                         selectionReceiver.objectCreated();
 763                 }
 764 /*
 765                 else if (data ==OperationModeHolder.OPERATIONMODE_MOVE)
 766                 {
 767                         // 移動モードのとき
 768                 }
 769                 else // if (data ==ChangeDrawMode.OPERATIONMODE_DELETE)
 770                 {
 771                         // 削除モードのとき...何もしない
 772                 }
 773 */
 774         }
 775         return (false);
 776     }
 777
 778     /**
 779      *   タッチが離されたタイミングでの処理
 780          *
 781      */
 782     private boolean onTouchUp(MotionEvent event)
 783     {
 784         boolean longPress = false;
 785         if (onGestureProcessed)
 786         {
 787                 // ロングタッチ中だった場合...フラグを落とす
 788                 onGestureProcessed = false;
 789                 longPress = true;
 790         }
 791
 792         // タッチ位置をオブジェクト画像の座標に変換する
 793         float x = (event.getX() - drawTransX) / drawScale;
 794         float y = (event.getY() - drawTransY) / drawScale;
 795
 796         if (selectedPosition == null)
 797         {
 798                 int data = selectionReceiver.touchUppedVacantArea();
 799                 if (data == OperationModeHolder.OPERATIONMODE_DELETE)
 800                 {
 801                 if ((tempPosX == Float.MIN_VALUE)||(tempPosY == Float.MIN_VALUE)||(downPosX == Float.MIN_VALUE)||(downPosY == Float.MIN_VALUE))
 802                 {
 803                         // タッチが２つ揃っていないので、何もしない。
 804                         Log.v(TAG, "onTouchUp : (" + downPosX + "," + downPosY + ") [" + drawScale + "] (" + tempPosX + "," + tempPosY + ") [" + drawTransX + "," + drawTransY + "]");
 805                     return (false);
 806                 }
 807
 808                         // タッチが離された位置にオブジェクトがおらず、オブジェクトが非選択だった場合...オブジェクトが繋がっているラインを切断する
 809                 disconnectObjects((downPosX / drawScale) , (downPosY / drawScale), ((tempPosX - drawTransX) / drawScale), ((tempPosY - drawTransY) / drawScale));
 810
 811                         // 移動位置をクリアする
 812                         tempPosX = Float.MIN_VALUE;
 813                         tempPosY = Float.MIN_VALUE;
 814                         downPosX = Float.MIN_VALUE;
 815                         downPosY = Float.MIN_VALUE;
 816                 return (true);
 817                 }
 818
 819                 // 移動位置をクリアする
 820                         tempPosX = Float.MIN_VALUE;
 821                 tempPosY = Float.MIN_VALUE;
 822                 downPosX = Float.MIN_VALUE;
 823                 downPosY = Float.MIN_VALUE;
 824                 return (true);
 825         }
 826
 827         RectF selectedRect = selectedPosition.getRect();
 828         if (selectedRect.contains(x, y))
 829         {
 830                 //  タッチが離された位置がタッチしたオブジェクトと同じ位置だった場合......
 831
 832                 // タッチが離された位置を認識する
 833                 float diffX = Math.abs(event.getX() - drawTransX - downPosX);
 834                 float diffY = Math.abs(event.getY() - drawTransY - downPosY);
 835
 836                 // タッチが離された位置が動いていた場合、オブジェクト位置の微調整と判定する。
 837                 if (((diffX > 2.0f)||(diffY > 2.0f))||(longPress))
 838                 {
 839                 // タッチが離された場所にはオブジェクトがなかった場合...オブジェクトをその位置に移動させる
 840                 Log.v(TAG, "MOVE OBJECT : (" + diffX + "," + diffY + ")");
 841                         moveObjectPosition(x, y);
 842                         return (true);
 843                 }
 844
 845             //  タッチが押された位置と離された位置が同じ位置だった場合......アイテムが選択された、と認識する。
 846                 Log.v(TAG, " ITEM SELECTED :" + x + "," + y);
 847                 if (selectionReceiver != null)
 848                 {
 849                         // アイテムが選択されたよ！と教える
 850                         boolean isDraw = selectionReceiver.objectSelected(selectedPosition.getKey());
 851
 852                         // 移動位置をクリアする
 853                         tempPosX = Float.MIN_VALUE;
 854                         tempPosY = Float.MIN_VALUE;
 855                         return (isDraw);
 856                 }
 857         }
 858
 859         // タッチが離された位置にオブジェクトがいるかどうかのチェック
 860         PositionObject position = checkSelectedObject(x, y);
 861         if ((position != null)&&(!longPress))
 862         {
 863                 // 他のオブジェクトと重なるように操作した、この場合は、オブジェクト間を線をつなげる
 864                 // （ただし、ボタンを長押ししていなかったとき。）
 865                 lineHolder.setLines(selectedPosition.getKey(), position.getKey(), lineStyleHolder);
 866                 tempPosX = Float.MIN_VALUE;
 867                 tempPosY = Float.MIN_VALUE;
 868                 return (true);
 869         }
 870
 871         // タッチが離された場所にはオブジェクトがなかった場合...オブジェクトをその位置に移動させる
 872         moveObjectPosition(x, y);
 873 /*
 874         tempPosX = Float.MIN_VALUE;
 875         tempPosY = Float.MIN_VALUE;
 876         float positionX = alignPosition(x, (objectSizeX / 2) * (-1));
 877         float positionY = alignPosition(y, (objectSizeY / 2) * (-1));
 878         selectedPosition.rect = new  android.graphics.RectF(positionX, positionY, (positionX + objectSizeX), (positionY + objectSizeY));
 879         // selectedPosition.drawStyle = objectStyle;   // 不要、最初に生成するときだけ必要
 880 */
 881         return (true);
 882     }
 883
 884     /**
 885      *   オブジェクトの位置を移動させる
 886      *
 887      */
 888     private void moveObjectPosition(float x, float y)
 889     {
 890         RectF curRect = selectedPosition.getRect();
 891         tempPosX = Float.MIN_VALUE;
 892         tempPosY = Float.MIN_VALUE;
 893         float sizeX = curRect.right - curRect.left;
 894         float sizeY = curRect.bottom - curRect.top;
 895
 896         float positionX = alignPosition(x, (sizeX / 2) * (-1));
 897         float positionY = alignPosition(y, (sizeY / 2) * (-1));
 898         selectedPosition.setRect(new  android.graphics.RectF(positionX, positionY, (positionX + sizeX), (positionY + sizeY)));
 899     }
 900
 901           /**
 902            *    onTouchEvent : 画面がタッチした時のイベント処理
 903            *    (true なら、画面描画を実施する)
 904            */
 905           public boolean onTouchEvent(MotionEvent event)
 906           {
 907             boolean isDraw;
 908
 909             // スケールジェスチャ(マルチタッチのジェスチャ)を拾う
 910             // isDraw = scaleGestureDetector.onTouchEvent(event);
 911                 if ((onScaling)||(scaleGestureDetector.isInProgress()))
 912                 {
 913                         //  マルチタッチ操作中...
 914                         return (true);
 915                 }
 916
 917                 //  先にジェスチャーを拾ってみよう...
 918             isDraw = gestureDetector.onTouchEvent(event);
 919             if (isDraw)
 920             {
 921                 Log.v(TAG, "MeMoMaCanvasDrawer::onTouchEvent() : isDraw == true");
 922                 return (true);
 923             }
 924
 925                 int action = event.getAction();
 926
 927                 //Log.v(Main.APP_IDENTIFIER, "MeMoMaCanvasDrawer::onTouchEvent() : " + action);
 928                 if (action == MotionEvent.ACTION_DOWN)
 929                 {
 930                         // タッチされたとき
 931                         isDraw = onTouchDown(event);
 932                 }
 933                 else if (action == MotionEvent.ACTION_MOVE)
 934                 {
 935                         // タッチされたまま動かされたときの処理
 936                         tempPosX = event.getX();
 937                 tempPosY = event.getY();
 938                 isDraw = true;
 939                 }
 940                 else if (action == MotionEvent.ACTION_UP)
 941                 {
 942                         // タッチが離されたときの処理...
 943                     isDraw = onTouchUp(event);
 944                 }
 945
 946                 return (isDraw);
 947           }
 948
 949           /**
 950            *   タテヨコ位置を合わせられるよう、調整する。
 951            *
 952            */
 953           private float alignPosition(float pos, float offset)
 954           {
 955                   // 位置を調整する。
 956                   return (pos + offset);
 957           }
 958
 959           /**
 960            *    位置から判定し、選択したオブジェクトを応答する
 961            *    （オブジェクトが選択されていない場合には、nullを応答する）
 962            *
 963            */
 964           private PositionObject checkSelectedObject(float x, float y)
 965           {
 966           Enumeration<Integer> keys = objectHolder.getObjectKeys();
 967               //Log.v(Main.APP_IDENTIFIER, "CHECK POS "  + x + "," + y);
 968                   while (keys.hasMoreElements())
 969                   {
 970                           Integer key = keys.nextElement();
 971                           PositionObject pos = objectHolder.getPosition(key);
 972                           RectF posRect = pos.getRect();
 973                           if (posRect.contains(x, y))
 974                           {
 975                                       Log.v(TAG, "SELECTED :"  + posRect.centerX() + "," + posRect.centerY() +  " KEY :" + key);
 976                                       return (pos);
 977                           }
 978                           //Log.v(Main.APP_IDENTIFIER, "NOT MATCH :"   + pos.rect.centerX() + "," + pos.rect.centerY());
 979                   }
 980                   //Log.v(Main.APP_IDENTIFIER, "RETURN NULL...");
 981                   return (null);
 982           }
 983
 984           /**
 985            *   線と交差するオブジェクト接続線をすべて削除する
 986            *
 987            */
 988       private void disconnectObjects(float startX, float startY, float endX, float endY)
 989       {
 990             Log.v(TAG, "MeMoMaCanvasDrawer::disconnectObjects() [" + startX + "," + startY +"]-[" + endX + "," + endY + "]");
 991                     try
 992                     {
 993                         Enumeration<Integer> keys = lineHolder.getLineKeys();
 994                         while (keys.hasMoreElements())
 995                         {
 996                             Integer key = keys.nextElement();
 997                             ObjectConnector line = lineHolder.getLine(key);
 998                             if (line.getKey() > 0)
 999                             {
1000                                     // 線の始点と終点を取り出す
1001                                             RectF fromRect = objectHolder.getPosition(line.getFromObjectKey()).getRect();
1002                                             RectF toRect = objectHolder.getPosition(line.getToObjectKey()).getRect();
1003
1004                                             // 線が交差しているかチェックする
1005                                             if (checkIntersection(startX, startY, endX, endY, fromRect.centerX(),  fromRect.centerY(),  toRect.centerX(), toRect.centerY()))
1006                                             {
1007                                 // 線が交差していた！ 線を切る！
1008                                                 //Log.v(Main.APP_IDENTIFIER, "CUT LINE [" +  from.rect.centerX() + "," +  from.rect.centerY() +"]-[" + to.rect.centerX() + "," + to.rect.centerY() + "]");
1009                                                     lineHolder.disconnectLines(line.getKey());
1010                                             }
1011                                  }
1012                         }
1013                     }
1014                     catch (Exception ex)
1015                     {
1016                         // 例外発生、でもなにもしない
1017                     }
1018       }
1019
1020       /**
1021        *    線が交差しているかチェックする
1022        *
1023        * @param x1  線１の始点 (X座標)
1024        * @param y1  線１の始点 (Y座標)
1025        * @param x2  線１の終点 (X座標)
1026        * @param y2  線１の終点 (Y座標)
1027        * @param x3  線２の始点 (X座標)
1028        * @param y3  線２の始点 (Y座標)
1029        * @param x4  線２の終点 (X座標)
1030        * @param y4  線２の終点 (Y座標)
1031        * @return  true なら線が交差している
1032        */
1033       private boolean checkIntersection(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4)
1034       {
1035           // 線が平行かどうかのチェックを行う
1036           float denominator = (x2 - x1) * (y4 - y3) - (y2 - y1) * (x4 - x3);
1037           if (Math.abs(denominator) < 0.00001)
1038           {
1039                   // 線が平行と認識、交差しない
1040                   return (false);
1041           }
1042
1043           float tempX = x3 - x1;
1044           float tempY = y3 - y1;
1045           float dR = (((y4 - y3) * tempX) - ((x4 - x3) * tempY)) / denominator;
1046           float dS = (((y2 - y1) * tempX) - ((x2 - x1) * tempY)) / denominator;
1047
1048           // ２直線の交点を求める
1049           //float crossX, crossY;
1050           //crossX = x1 + dR * (x2 - x1);
1051           //crossY = y1 + dR * (y2 - y1);
1052
1053           // 交点が線分内にあるかどうかをチェックする
1054           return ((dR >= 0)&&(dR <= 1)&&(dS >= 0)&&(dS <= 1));
1055       }
1056
1057       /**
1058        *   並行移動・ズームのサイズをリセットする
1059        *
1060        */
1061       public void resetScaleAndLocation(SeekBar zoomBar)
1062       {
1063             // 並行移動をリセットする
1064             drawTransX = 0.0f;
1065             drawTransY = 0.0f;
1066
1067             // プログレスバーの位置をリセットする
1068             drawScale = 1.0f;
1069             zoomBar.setProgress(50);
1070
1071             // preferenceに状態を記録する
1072                 recordTranslateAndZoomScale(50);
1073       }
1074
1075       /**
1076        *    スライドバーを変更された時の処理
1077        */
1078       private void zoomScaleChanged(int progress)
1079       {
1080           float val = ((float) progress - 50.0f) / 50.0f;
1081
1082           // 前の表示領域サイズを取得
1083           float prevSizeWidth = screenWidth * drawScale;
1084           float prevSizeHeight = screenHeight * drawScale;
1085
1086           //  表示倍率を変更し、倍率を画面に表示する
1087           drawScale = (float) Math.round(Math.pow(10.0, val) * 10.0) / 10.0f;
1088           TextView  textview = parent.findViewById(R.id.ZoomRate);
1089           String showText = "x" + drawScale;
1090           textview.setText(showText);
1091
1092           // 現在の表示領域サイズを取得
1093           float showSizeWidth = screenWidth * drawScale;
1094           float showSizeHeight = screenHeight * drawScale;
1095
1096           // 倍率にあわせて並行移動する場所を調整する
1097           drawTransX = (prevSizeWidth - showSizeWidth) / 2.0f  + drawTransX;
1098           drawTransY = (prevSizeHeight - showSizeHeight) / 2.0f + drawTransY;
1099
1100               // preferenceに状態を記録する
1101               recordTranslateAndZoomScale(progress);
1102       }
1103
1104       /**
1105        *    平行移動状態と倍率の状態を記憶する
1106        *
1107        */
1108       private void recordTranslateAndZoomScale(int progress)
1109       {
1110           //Log.v(Main.APP_IDENTIFIER, "recordTranslateAndZoomScale() : x" + drawScale + " X:" + drawTransX + " Y: " + drawTransY);
1111           SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(parent);
1112           SharedPreferences.Editor editor = preferences.edit();
1113           editor.putFloat("drawScale", drawScale);
1114           editor.putFloat("drawTransX", drawTransX);
1115           editor.putFloat("drawTransY", drawTransY);
1116           editor.putInt("zoomProgress", progress);
1117           editor.apply();
1118       }
1119
1120       /**
1121        *    平行移動状態と倍率の状態を記憶する
1122        *
1123        */
1124       private void restoreTranslateAndZoomScale()
1125       {
1126           SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(parent);
1127           drawScale = preferences.getFloat("drawScale", 1.0f);
1128           drawTransX = preferences.getFloat("drawTransX", 0.0f);
1129           drawTransY = preferences.getFloat("drawTransY", 0.0f);
1130           Log.v(TAG, "restoreTranslateAndZoomScale() : x" + drawScale + " X:" + drawTransX + " Y: " + drawTransY);
1131       }
1132
1133       /**
1134        *    GestureDetector.OnGestureListener の実装
1135        */
1136       public boolean onDown(MotionEvent event)
1137       {
1138           //Log.v(Main.APP_IDENTIFIER, "MeMoMaCanvasDrawer::onDown() "  + event.getX()  + "," + event.getY());
1139           return (false);
1140       }
1141
1142       /**
1143        *    GestureDetector.OnGestureListener の実装
1144        */
1145       public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY)
1146       {
1147           //Log.v(Main.APP_IDENTIFIER, "MeMoMaCanvasDrawer::onFling() "  + velocityX  + "," + velocityY);
1148           return (false);
1149       }
1150
1151       /**
1152        *    GestureDetector.OnGestureListener の実装
1153        */
1154       public void onLongPress(MotionEvent event)
1155       {
1156           Log.v(TAG, "MeMoMaCanvasDrawer::onLongPress() "  + event.getX()  + "," + event.getY());
1157
1158           // タッチ位置をオブジェクト画像の座標に変換する
1159           float x = (event.getX() - drawTransX) / drawScale;
1160           float y = (event.getY() - drawTransY) / drawScale;
1161
1162           // タッチ位置にオブジェクトが存在するか確認する
1163           PositionObject  position = checkSelectedObject(x, y);
1164           if (position != null)
1165           {
1166                   // 長押し処理を実施していることを記憶する
1167               onGestureProcessed = true;
1168
1169                   // タッチした場所にオブジェクトが存在した！！
1170               selectionReceiver.objectSelectedContext(position.getKey());
1171           }
1172       }
1173
1174       /**
1175        *    GestureDetector.OnGestureListener の実装
1176        */
1177       public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY)
1178       {
1179           //Log.v(Main.APP_IDENTIFIER, "MeMoMaCanvasDrawer::onScroll() "  + distanceX  + "," + distanceY);
1180           return (false);
1181       }
1182
1183       /**
1184        *    GestureDetector.OnGestureListener の実装
1185        */
1186       public void onShowPress(MotionEvent event)
1187       {
1188          //Log.v(Main.APP_IDENTIFIER, "MeMoMaCanvasDrawer::onShowPress() "  + event.getX()  + "," + event.getY());
1189       }
1190
1191       /**
1192        *    GestureDetector.OnGestureListener の実装
1193        */
1194       public boolean onSingleTapUp(MotionEvent event)
1195       {
1196             //Log.v(Main.APP_IDENTIFIER, "MeMoMaCanvasDrawer::onSingleTapUp() "  + event.getX()  + "," + event.getY());
1197             return (false);
1198       }
1199
1200       /**
1201        *    スライドバーを変更された時の処理
1202        *    (SeekBar.OnSeekBarChangeListener の実装)
1203        */
1204       public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser)
1205       {
1206             // 画面描画の倍率を変更する
1207             zoomScaleChanged(progress);
1208
1209             // 画面描画クラスに再描画を指示する
1210                 final GokigenSurfaceView surfaceView = parent.findViewById(R.id.GraphicView);
1211                 surfaceView.doDraw();
1212       }
1213
1214       /**
1215        *    SeekBar.OnSeekBarChangeListener の実装
1216        */
1217       public void onStartTrackingTouch(SeekBar seekBar)
1218       {
1219            // 何もしない
1220       }
1221
1222       /**
1223        *    SeekBar.OnSeekBarChangeListener の実装
1224        */
1225       public void onStopTrackingTouch(SeekBar seekBar)
1226       {
1227            // 何もしない
1228       }
1229
1230       /**
1231        *   （ScaleGestureDetector.OnScaleGestureListener の実装）
1232        *
1233        *
1234        */
1235       public boolean onScale(ScaleGestureDetector detector)
1236       {
1237           float scaleFactor = detector.getScaleFactor();
1238           //Log.v(Main.APP_IDENTIFIER, "MeMoMaCanvasDrawer::onScale() : " + scaleFactor + " (" + currentScaleBar + ")");
1239
1240           // 画面表示の倍率が変更された！　x < 1 : 縮小、 1 < x : 拡大
1241           if (scaleFactor < 1.0f)
1242           {
1243                   currentScaleBar = (currentScaleBar == 0) ? 0 : currentScaleBar - 1;
1244           }
1245           else if (scaleFactor > 1.0f)
1246           {
1247                   currentScaleBar = (currentScaleBar == 100) ? 100 : currentScaleBar + 1;
1248           }
1249           zoomScaleChanged(currentScaleBar);
1250
1251           return (onScaling);
1252       }
1253
1254       /**
1255        *   （ScaleGestureDetector.OnScaleGestureListener の実装）
1256        *
1257        *
1258        */
1259       public  boolean    onScaleBegin(ScaleGestureDetector detector)
1260       {
1261           //Log.v(Main.APP_IDENTIFIER, "MeMoMaCanvasDrawer::onScaleBegin() ");
1262           SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(parent);
1263           currentScaleBar = preferences.getInt("zoomProgress", 50);
1264           onScaling = true;
1265           return (onScaling);
1266       }
1267
1268       /**
1269        *   （ScaleGestureDetector.OnScaleGestureListener の実装）
1270        *
1271        */
1272       public void        onScaleEnd(ScaleGestureDetector detector)
1273       {
1274           //Log.v(Main.APP_IDENTIFIER, "MeMoMaCanvasDrawer::onScaleEnd() " + currentScaleBar);
1275           onScaling = false;
1276
1277           // シークバーを設定し、値を記憶する
1278               final SeekBar seekbar = parent.findViewById(R.id.ZoomInOut);
1279               seekbar.setProgress(currentScaleBar);
1280               zoomScaleChanged(currentScaleBar);
1281       }
1282  }