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