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

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