source/workspace/EverFolder/src/com/yuji/ef/EverFolderActivity.java

   1 package com.yuji.ef;
   2
   3 import java.util.ArrayList;
   4 import java.util.Collections;
   5 import java.util.List;
   6
   7 import android.content.BroadcastReceiver;
   8 import android.content.Context;
   9 import android.content.Intent;
  10 import android.content.IntentFilter;
  11 import android.database.sqlite.SQLiteDatabase;
  12 import android.graphics.Bitmap;
  13 import android.graphics.PixelFormat;
  14 import android.os.Bundle;
  15 import android.text.Editable;
  16 import android.text.TextWatcher;
  17 import android.view.Gravity;
  18 import android.view.Menu;
  19 import android.view.MenuItem;
  20 import android.view.View;
  21 import android.view.View.OnClickListener;
  22 import android.view.WindowManager;
  23 import android.view.inputmethod.InputMethodManager;
  24 import android.widget.Button;
  25 import android.widget.EditText;
  26 import android.widget.LinearLayout;
  27 import android.widget.TextView;
  28
  29 import com.yuji.ef.common.CommonUtil;
  30 import com.yuji.ef.common.Constant;
  31 import com.yuji.ef.dao.DatabaseHelper;
  32 import com.yuji.ef.dao.DirNode;
  33 import com.yuji.ef.dao.FileNode;
  34 import com.yuji.ef.dao.LockDao;
  35 import com.yuji.ef.dao.Node;
  36 import com.yuji.ef.dao.Node.Status;
  37 import com.yuji.ef.dao.NodeCacheDao;
  38 import com.yuji.ef.dao.NodeComparator;
  39 import com.yuji.ef.dao.NodeDao;
  40 import com.yuji.ef.dao.NodeDaoImpl;
  41 import com.yuji.ef.dao.RootNode;
  42 import com.yuji.ef.exception.EfException;
  43 import com.yuji.ef.pref.EditPrefUtil;
  44 import com.yuji.ef.utility.BaseActivity;
  45 import com.yuji.ef.utility.BitmapCacheFactory;
  46 import com.yuji.ef.utility.EvernoteIntentUtil;
  47 import com.yuji.ef.utility.FolderUtil;
  48 import com.yuji.ef.utility.LockHandler;
  49 import com.yuji.ef.utility.LockListener;
  50 import com.yuji.ef.utility.ScaleUtil;
  51
  52 public class EverFolderActivity extends BaseActivity implements LockListener {
  53         private enum ScreenStatus {
  54                 Normal, AddNode, DeleteNode, RenameNode
  55         };
  56         private EditPrefUtil pref = new EditPrefUtil(this);
  57
  58         private LinearLayout msgLayout;
  59         private LinearLayout msgButtonLayout;
  60         private Button msgOkButton;
  61         private Button msgCancelButton;
  62         private EditText msgEditText;
  63
  64         private IconFrameLayout layout;
  65         private TextView confirmMsg;
  66         private IconScrollView scrollView;
  67         private LinearLayout buttonLayout;
  68         private Button leftButton;
  69         private Button rightButton;
  70         // private Button addButton;
  71         // private Button deleteButton;
  72
  73         private ScreenStatus status;
  74         private NodeComparator nodeComparator = new NodeComparator();
  75         private BitmapCacheFactory bitmapFactory = BitmapCacheFactory.getInstance();
  76         private Node top = null;
  77         private int indent = 0;
  78         private int bmpPaddingLeft;
  79         private int bmpWidth;
  80         private int viewY;
  81         private boolean lock = false;
  82         private boolean isInit = true;
  83         private boolean isInCycle = false;
  84         private boolean isResult = false;
  85
  86         private BroadcastReceiver receiver = new BroadcastReceiver() {
  87                 @Override
  88                 public void onReceive(Context context, Intent intent) {
  89                         String action = intent.getAction();
  90
  91                         if (action.equals(Constant.ACTION_MESSAGE)) {
  92                                 String msg = intent.getStringExtra(Constant.ACTION_MESSAGE_MESSAGE);
  93                                 EfException.msg(EverFolderActivity.this, msg);
  94                         }
  95                         else if (action.equals(Constant.ACTION_UPDATE)) {
  96                                 if (isInCycle && !lock) {
  97                                         LockDao lockDao = (LockDao) LockDao.getInstance();
  98                                         lock = lockDao.lock(EverFolderActivity.this,
  99                                                         Constant.LOCK_UPDATE_NOTE);
 100                                         if (lock) {
 101                                                 updateList();
 102                                                 // ほんとは、setStatus()に入れたい
 103                                                 layout.setVisibility(View.VISIBLE);
 104                                         }
 105                                         setStatus();
 106                                 }
 107                         }
 108                 }
 109         };
 110
 111         @Override
 112         public void onCreate(Bundle savedInstanceState) {
 113                 super.onCreate(savedInstanceState);
 114                 setContentView(R.layout.main);
 115
 116                 try {
 117                         IntentFilter intentFilter = new IntentFilter();
 118                         intentFilter.addAction(Constant.ACTION_UPDATE);
 119                         intentFilter.addAction(Constant.ACTION_MESSAGE);
 120                         registerReceiver(receiver, intentFilter);
 121
 122                         scrollView = (IconScrollView) findViewById(R.id.scrollView);
 123                         layout = (IconFrameLayout) findViewById(R.id.frameLayout);
 124                         layout.setActivity(this);
 125                         layout.setScrollView(scrollView);
 126
 127                         buttonLayout = (LinearLayout) findViewById(R.id.mainButtonLayout);
 128                         leftButton = (Button) findViewById(R.id.leftButton);
 129                         rightButton = (Button) findViewById(R.id.rightButton);
 130                         // addButton = (Button) findViewById(R.id.addButton);
 131                         // deleteButton = (Button) findViewById(R.id.deleteButton);
 132
 133                         msgLayout = (LinearLayout) findViewById(R.id.mainMsgLayout);
 134                         confirmMsg = (TextView) findViewById(R.id.mainConfirmMsg);
 135                         msgEditText = (EditText) findViewById(R.id.mainMsgEditText);
 136                         msgButtonLayout = (LinearLayout) findViewById(R.id.mainMsgButtonLayout);
 137                         msgOkButton = (Button) findViewById(R.id.mainMsgOkButton);
 138                         msgCancelButton = (Button) findViewById(R.id.mainMsgCancelButton);
 139
 140                         leftButton.setOnClickListener(new OnClickListener() {
 141                                 @Override
 142                                 public void onClick(View v) {
 143                                         leftButtonOnClick();
 144                                 }
 145                         });
 146                         rightButton.setOnClickListener(new OnClickListener() {
 147                                 @Override
 148                                 public void onClick(View v) {
 149                                         rightButtonOnClick();
 150                                 }
 151                         });
 152                         // addButton.setOnClickListener(new OnClickListener() {
 153                         // @Override
 154                         // public void onClick(View v) {
 155                         // addButtonOnClick();
 156                         // }
 157                         // });
 158                         // deleteButton.setOnClickListener(new OnClickListener() {
 159                         // @Override
 160                         // public void onClick(View v) {
 161                         // deleteButtonOnClick();
 162                         // }
 163                         // });
 164
 165                         msgEditText.addTextChangedListener(new TextWatcher() {
 166                                 public void afterTextChanged(Editable s) {
 167                                         if (status != ScreenStatus.DeleteNode) {
 168                                                 String text = s.toString();
 169                                                 msgOkButton.setEnabled(text.length() > 0);
 170                                         } else {
 171                                                 msgOkButton.setEnabled(true);
 172                                         }
 173                                 }
 174
 175                                 public void beforeTextChanged(CharSequence s, int start,
 176                                                 int count, int after) {
 177
 178                                 }
 179
 180                                 public void onTextChanged(CharSequence s, int start,
 181                                                 int before, int count) {
 182
 183                                 }
 184                         });
 185
 186                         msgOkButton.setOnClickListener(new OnClickListener() {
 187                                 @Override
 188                                 public void onClick(View v) {
 189                                         msgOkButtonOnClick(v);
 190                                 }
 191                         });
 192                         msgCancelButton.setOnClickListener(new OnClickListener() {
 193                                 @Override
 194                                 public void onClick(View v) {
 195                                         msgCancelOnClick(v);
 196                                 }
 197                         });
 198
 199                         ScaleUtil scaleUtil = ScaleUtil.getInstance();
 200                         scaleUtil.init(this);
 201
 202                         bitmapFactory.init(this);
 203                         Node node = new DirNode(null, null);
 204                         Bitmap bmp = null;
 205                         bmp = bitmapFactory.get(node.getStatusIconId());
 206                         bmpPaddingLeft = bmp.getWidth();
 207                         bmp = bitmapFactory.get(node.getIconId());
 208                         bmpWidth = bmp.getWidth();
 209
 210                         float fSize = 48 * (1 / 2.0f);
 211                         leftButton.setTextSize(fSize);
 212                         rightButton.setTextSize(fSize);
 213                 } catch (Exception e) {
 214                         // TODO
 215                         e.printStackTrace();
 216                 }
 217         }
 218
 219         @Override
 220         public boolean onCreateOptionsMenu(Menu menu) {
 221                 boolean ret = super.onCreateOptionsMenu(menu);
 222                 int index = 0;
 223
 224                 menu.add(Menu.NONE, Menu.FIRST + index++, Menu.NONE, "カット");
 225                 menu.add(Menu.NONE, Menu.FIRST + index++, Menu.NONE, "ペースト");
 226                 menu.add(Menu.NONE, Menu.FIRST + index++, Menu.NONE, "追加");
 227                 menu.add(Menu.NONE, Menu.FIRST + index++, Menu.NONE, "削除");
 228                 menu.add(Menu.NONE, Menu.FIRST + index++, Menu.NONE, "リネーム");
 229                 menu.add(Menu.NONE, Menu.FIRST + index++, Menu.NONE, "設定");
 230                 return ret;
 231         }
 232
 233         @Override
 234         public boolean onMenuOpened(int featureId, Menu menu) {
 235                 boolean ret = super.onMenuOpened(featureId, menu);
 236
 237                 // #29304
 238                 if (menu == null) {
 239                         return false;
 240                 }
 241
 242                 MenuItem item;
 243
 244                 boolean cutButtonFlag = false;
 245                 boolean pastButtonFlag = false;
 246                 boolean addButtonFlag = false;
 247                 boolean deleteButtonFlag = false;
 248                 boolean renameButtonFlag = false;
 249                 boolean confButtonFlag = true;
 250
 251                 if (status == ScreenStatus.Normal) {
 252                         LabelIconView target = layout.getSelectedTarget();
 253                         NodeDao dao = (NodeDao) NodeCacheDao.getInstance();
 254                         long id = -1;
 255                         Node node = null;
 256                         if (target != null) {
 257                                 id = target.getNodeId();
 258                                 node = dao.searchById(id);
 259                         }
 260
 261                         if (isDirNode(target, node, false) || isFileNode(node)) {
 262                                 cutButtonFlag = true;
 263                         }
 264                         if (isDirNode(target, node, true) && isCut()) {
 265                                 pastButtonFlag = true;
 266                         }
 267                         if (isDirNode(target, node, true)) {
 268                                 addButtonFlag = true;
 269                         }
 270                         if (isDirNode(target, node, false) && !isNoteBook(node)
 271                                         && CommonUtil.isNull(node.getChildrenString())) {
 272                                 deleteButtonFlag = true;
 273                         }
 274                         if (isDirNode(target, node, false) && !isNoteBook(node)) {
 275                                 renameButtonFlag = true;
 276                         }
 277                 }
 278
 279                 int index = 0;
 280                 item = menu.getItem(index++);
 281                 item.setVisible(cutButtonFlag);
 282                 item = menu.getItem(index++);
 283                 item.setVisible(pastButtonFlag);
 284                 item = menu.getItem(index++);
 285                 item.setVisible(addButtonFlag);
 286                 item = menu.getItem(index++);
 287                 item.setVisible(deleteButtonFlag);
 288                 item = menu.getItem(index++);
 289                 item.setVisible(renameButtonFlag);
 290                 item = menu.getItem(index++);
 291                 item.setVisible(confButtonFlag);
 292
 293                 return ret;
 294         }
 295
 296         private boolean isFileNode(Node node) {
 297                 if (node == null || !(node instanceof FileNode)) {
 298                         return false;
 299                 }
 300                 return true;
 301         }
 302
 303         private boolean isDirNode(LabelIconView target, Node node,
 304                         boolean containRoot) {
 305                 if (target == null) {
 306                         return false;
 307                 }
 308                 if (node == null) {
 309                         return false;
 310                 }
 311                 if (!containRoot && (node instanceof RootNode)) {
 312                         return false;
 313                 }
 314                 if (!(node instanceof DirNode)) {
 315                         return false;
 316                 }
 317                 return true;
 318         }
 319
 320         private boolean isNoteBook(Node node) {
 321                 if (node == null) {
 322                         return false;
 323                 }
 324                 if (CommonUtil.isNull(node.getGuid())) {
 325                         return false;
 326                 }
 327                 return true;
 328         }
 329
 330         private boolean isCut() {
 331                 LabelIconView srcTarget = layout.getCutTarget();
 332                 if (srcTarget == null) {
 333                         return false;
 334                 }
 335                 return true;
 336         }
 337
 338         @Override
 339         public boolean onOptionsItemSelected(MenuItem item) {
 340                 Intent intent;
 341                 try {
 342                         switch (item.getItemId()) {
 343                         case Menu.FIRST + 0:
 344                                 selectMenuCut();
 345                                 break;
 346                         case Menu.FIRST + 1:
 347                                 selectMenuPast();
 348                                 break;
 349                         case Menu.FIRST + 2:
 350                                 selectMenuAdd();
 351                                 break;
 352                         case Menu.FIRST + 3:
 353                                 selectMenuDelete();
 354                                 break;
 355                         case Menu.FIRST + 4:
 356                                 selectMenuRename();
 357                                 break;
 358                         case Menu.FIRST + 5:
 359                                 // dummy();
 360                                 // dummy2();
 361                                 intent = new Intent(this, (Class<?>) SettingActivity.class);
 362                                 startActivityForResult(intent, 0);
 363                                 break;
 364                         default:
 365                                 break;
 366                         }
 367                 } catch (Exception e) {
 368                         terminate(e);
 369                 }
 370                 return super.onOptionsItemSelected(item);
 371         }
 372
 373         private void dummy() {
 374                 NodeDaoImpl dao = (NodeDaoImpl) NodeCacheDao.getInstance();
 375                 List<Node> list = dao.search();
 376                 for (Node node : list) {
 377                         System.out.println(node.toString());
 378                 }
 379         }
 380
 381         private void dummy2() {
 382                 LockDao dao = (LockDao) LockDao.getInstance();
 383                 boolean b;
 384
 385                 try {
 386                         b = dao.lock(this, "key");
 387                         b = dao.lock(this, "key");
 388                         b = dao.lock(new Object(), "key");
 389                         dao.unlock(this, "key");
 390                         b = dao.lock(new Object(), "key");
 391                         b = dao.lock(this, "key");
 392                         b = dao.lock(this, "key");
 393                         b = dao.lock(this, "key");
 394                         dao.unlock(new Object(), "key");
 395
 396                 } catch (Exception e) {
 397                         e.printStackTrace();
 398                 }
 399
 400         }
 401
 402         private void selectMenuAdd() {
 403                 setStatus(ScreenStatus.AddNode);
 404         }
 405
 406         private void selectMenuDelete() {
 407                 setStatus(ScreenStatus.DeleteNode);
 408         }
 409
 410         private void selectMenuRename() {
 411                 LabelIconView target = layout.getSelectedTarget();
 412                 if (target == null) {
 413                         return;
 414                 }
 415
 416                 long id = target.getNodeId();
 417                 NodeDao dao = (NodeDao) NodeCacheDao.getInstance();
 418                 Node node = dao.searchById(id);
 419                 if (node != null) {
 420                         String text = node.getName();
 421                         msgEditText.setText(text);
 422                         setStatus(ScreenStatus.RenameNode);
 423                 }
 424         }
 425
 426         private void selectMenuCut() {
 427                 LabelIconView target = layout.getSelectedTarget();
 428                 if (target == null) {
 429                         return;
 430                 }
 431
 432                 layout.setCutTarget(target);
 433                 layout.refresh();
 434         }
 435
 436         private void selectMenuPast() {
 437                 LabelIconView srcTarget = layout.getCutTarget();
 438                 if (srcTarget == null) {
 439                         return;
 440                 }
 441
 442                 LabelIconView dstTarget = layout.getSelectedTarget();
 443                 if (dstTarget == null) {
 444                         return;
 445                 }
 446
 447                 layout.setCutTarget(null);
 448
 449                 long srcId = srcTarget.getNodeId();
 450                 long dstId = dstTarget.getNodeId();
 451                 execute(srcId, dstId);
 452         }
 453
 454         private void updateList() {
 455                 NodeDao dao = (NodeDao) NodeCacheDao.getInstance();
 456                 top = dao.searchRoot();
 457                 if (top == null) {
 458                         // TODO
 459                 }
 460                 updateList(top);
 461         }
 462
 463         private void updateList(Node parent) {
 464                 viewY = 10;
 465
 466                 scrollView.setVisibility(View.GONE);
 467                 layout.removeAllViews();
 468                 updateList(parent, 0);
 469                 layout.setMinimumHeight(viewY);
 470                 scrollView.setVisibility(View.VISIBLE);
 471                 layout.refresh();
 472
 473                 scrollView.invalidate();
 474         }
 475
 476         private void updateList(Node node, int depth) {
 477                 int N = (int) (bmpWidth * 0.6);
 478                 int M = (int) (bmpWidth * 1.2);
 479                 int x = N * (depth - indent);
 480
 481                 if (depth - indent >= 0
 482                                 && !(depth - indent == 0 && node instanceof FileNode)) {
 483                         LabelIconView view = new LabelIconView(this);
 484                         node.setView(view);
 485
 486                         Bitmap bmp1 = null;
 487                         int id = node.getStatusIconId();
 488                         if (id >= 0) {
 489                                 // DirNode
 490                                 bmp1 = bitmapFactory.get(node.getStatusIconId());
 491                         } else {
 492                                 // FileNode
 493                                 x += bmpPaddingLeft;
 494                         }
 495                         Bitmap bmp2 = bitmapFactory.get(node.getIconId());
 496                         createIconImageView(view, bmp1, bmp2, node.getName(), x, viewY);
 497                         // LabelIconView s = view.getStatusImageView();
 498                         // if (s != null) {
 499                         // s.setNodeId(node.getId());
 500                         // }
 501                         view.setNodeId(node.getId());
 502                 }
 503                 viewY += M;
 504
 505                 if (node.getStatus() != Node.Status.OPEN) {
 506                         return;
 507                 }
 508                 List<Long> idList = node.getChildren();
 509                 if (idList == null) {
 510                         return;
 511                 }
 512
 513                 List<Node> list = new ArrayList<Node>();
 514                 NodeDao dao = (NodeDao) NodeCacheDao.getInstance();
 515                 for (Long id : idList) {
 516                         Node n = dao.searchById(id);
 517                         if (n == null) {
 518                                 // TODO
 519                                 continue;
 520                         }
 521                         if (n instanceof DirNode) {
 522                                 DirNode d = (DirNode) n;
 523                                 if (isNoteBook(d) && !d.isSelected()) {
 524                                         continue;
 525                                 }
 526                         }
 527                         list.add(n);
 528                 }
 529                 Collections.sort(list, nodeComparator);
 530                 for (Node n : list) {
 531                         updateList(n, depth + 1);
 532                 }
 533         }
 534
 535         private void createIconImageView(LabelIconView v, Bitmap bmp1, Bitmap bmp2,
 536                         String text, int x, int y) {
 537                 v.init(x, y, bmp1, bmp2, text);
 538
 539                 android.view.WindowManager.LayoutParams params = new WindowManager.LayoutParams();
 540                 params.gravity = Gravity.TOP | Gravity.LEFT;
 541                 params.height = WindowManager.LayoutParams.WRAP_CONTENT;
 542                 params.width = WindowManager.LayoutParams.WRAP_CONTENT;
 543                 params.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
 544                                 | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE
 545                                 | WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
 546                                 | WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS;
 547                 params.format = PixelFormat.TRANSLUCENT;
 548                 params.windowAnimations = 0;
 549                 params.x = x;
 550                 params.y = y;
 551                 v.setLayoutParams(params);
 552
 553                 // LabelIconView siv = v.getStatusImageView();
 554                 // if (siv != null) {
 555                 // layout.addView(siv, false);
 556                 // }
 557
 558                 layout.addView(v);
 559                 v.layout(x, y, x + v.getWidth(), y + v.getHeight());
 560         }
 561
 562         @Override
 563         public void sendLockResult(boolean b) {
 564                 NodeDao dao = (NodeDao) NodeCacheDao.getInstance();
 565
 566                 pref.put(Constant.PREF_UPDATE_DATA, Constant.OFF);
 567                 pref.update();
 568
 569                 if (isResult) {
 570                         if (dao.isEmpty()) {
 571                                 finish();
 572                                 return;
 573                         }
 574                 }
 575                 isResult = false;
 576
 577                 if (dao.isEmpty()) {
 578                         if (isInit) {
 579                                 Intent intent = new Intent(this,
 580                                                 (Class<?>) SettingActivity.class);
 581                                 startActivityForResult(intent, 0);
 582
 583                                 isInit = false;
 584                         } else {
 585                                 finish();
 586                                 isInit = true;
 587                         }
 588                 }
 589
 590                 if (isInCycle) {
 591                         LockDao lockDao = (LockDao) LockDao.getInstance();
 592                         lock = lockDao.lock(this, Constant.LOCK_UPDATE_NOTE);
 593                         if (isInit) {
 594                                 status = ScreenStatus.Normal;
 595
 596                                 if (lock) {
 597                                         layout.setVisibility(View.VISIBLE);
 598                                         updateList();
 599                                 } else {
 600                                         layout.removeAllViews();
 601                                 }
 602                                 setStatus();
 603                                 isInit = false;
 604                         } else {
 605                                 setStatus();
 606                         }
 607                 } else {
 608                         // TODO
 609                         // lock解除
 610                 }
 611         }
 612
 613         @Override
 614         protected void onActivityResult(int requestCode, int resultCode, Intent data) {
 615                 // TODO sendLockResult()、「lock解除」のため、とりあえずコメント
 616                 // NodeDao dao = (NodeDao) NodeCacheDao.getInstance();
 617                 // if (dao.isEmpty()) {
 618                 // finish();
 619                 // }
 620                 isResult = true;
 621                 isInit = true;
 622         }
 623
 624         @Override
 625         protected void onStart() {
 626                 super.onStart();
 627         }
 628
 629         @Override
 630         protected void onResume() {
 631                 super.onResume();
 632                 isInCycle = true;
 633
 634                 LockHandler handler = new LockHandler();
 635                 handler.lock(this, Constant.LOCK_UPDATE_NOTE);
 636                 lock = false;
 637
 638                 if (isInit) {
 639                         layout.setVisibility(View.INVISIBLE);
 640                         setStatus();
 641                 }
 642                 else {
 643                         // #29421
 644                         updateList();
 645                 }
 646
 647                 // TODO
 648                 // NodeDao dao = (NodeDao) NodeCacheDao.getInstance();
 649                 // if (dao.isEmpty()) {
 650                 // if (isInit) {
 651                 // Intent intent = new Intent(this,
 652                 // (Class<?>) SettingActivity.class);
 653                 // startActivityForResult(intent, 0);
 654                 //
 655                 // isInit = false;
 656                 // } else {
 657                 // finish();
 658                 // isInit = true;
 659                 // }
 660                 // }
 661                 //
 662                 // LockDao lockDao = (LockDao) LockDao.getInstance();
 663                 // lock = lockDao.lock(this, Constant.LOCK_UPDATE_NOTE);
 664                 //
 665                 // if (isInit) {
 666                 // status = ScreenStatus.Normal;
 667                 //
 668                 // if (lock) {
 669                 // updateList();
 670                 // } else {
 671                 // layout.removeAllViews();
 672                 // }
 673                 // setStatus();
 674                 // isInit = false;
 675                 // } else {
 676                 // setStatus();
 677                 // }
 678         }
 679
 680         @Override
 681         protected void onPause() {
 682                 // ロック未取得でも解除する(ゴミ掃除)
 683                 LockDao lockDao = (LockDao) LockDao.getInstance();
 684                 lockDao.unlock(this, Constant.LOCK_UPDATE_NOTE);
 685                 lock = false;
 686
 687                 super.onPause();
 688                 isInCycle = false;
 689         }
 690
 691         private void leftButtonOnClick() {
 692                 moveButtonOnClick(-1);
 693                 setStatus();
 694         }
 695
 696         private void rightButtonOnClick() {
 697                 moveButtonOnClick(1);
 698                 setStatus();
 699         }
 700
 701         private void moveButtonOnClick(int dx) {
 702                 int mx = 0;
 703
 704                 if (dx < 0) {
 705                         if (indent > 0) {
 706                                 mx = -1;
 707                         }
 708                 } else {
 709                         mx = 1;
 710                 }
 711                 if (mx != 0) {
 712                         indent += mx;
 713                         removeAllNodeView();
 714                         updateList();
 715                 }
 716         }
 717
 718         // private void addButtonOnClick() {
 719         // setStatus(ScreenStatus.AddNode);
 720         // }
 721         //
 722         // private void deleteButtonOnClick() {
 723         // FolderUtil util = FolderUtil.getInstance();
 724         // LabelIconView target = layout.getSelectedTarget();
 725         // long id = target.getNodeId();
 726         // NodeDao dao = (NodeDao) NodeDao.getInstance();
 727         // Node node = dao.searchById(id);
 728         // if (node != null) {
 729         // util.deleteNode(node);
 730         // // TODO 三角マークも消さないといけないのでは
 731         // layout.removeView(target);
 732         // updateList();
 733         // setStatus();
 734         // }
 735         // }
 736
 737         private void msgOkButtonOnClick(View v) {
 738                 FolderUtil util = FolderUtil.getInstance();
 739                 LabelIconView target = layout.getSelectedTarget();
 740                 NodeDao dao = (NodeDao) NodeCacheDao.getInstance();
 741
 742                 if (status == ScreenStatus.AddNode) {
 743                         long id = target.getNodeId();
 744                         Node parent = dao.searchById(id);
 745                         if (parent != null) {
 746                                 String text = msgEditText.getText().toString();
 747                                 DirNode node = new DirNode(text, null);
 748                                 util.addDirNode(parent, node);
 749                         }
 750                         layout.setCutTarget(null, false);
 751                 } else if (status == ScreenStatus.DeleteNode) {
 752                         long id = target.getNodeId();
 753                         Node node = dao.searchById(id);
 754                         if (node != null) {
 755                                 util.deleteNode(node);
 756                                 layout.removeView(target);
 757                         }
 758                         layout.setCutTarget(null, false);
 759                 } else if (status == ScreenStatus.RenameNode) {
 760                         long id = target.getNodeId();
 761                         Node node = dao.searchById(id);
 762                         if (node != null) {
 763                                 String text = msgEditText.getText().toString();
 764
 765                                 dao.updateName(node, text);
 766                         }
 767                         layout.setCutTarget(null, false);
 768                 }
 769
 770                 closeIME(v);
 771
 772                 layout.clearTarget();
 773                 updateList();
 774                 setStatus(ScreenStatus.Normal);
 775         }
 776
 777         private void msgCancelOnClick(View v) {
 778                 closeIME(v);
 779
 780                 setStatus(ScreenStatus.Normal);
 781         }
 782
 783         private void closeIME(View v) {
 784                 InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
 785                 imm.hideSoftInputFromWindow(v.getWindowToken(), 0);
 786         }
 787
 788         public void execute(long srcId, long dstId) {
 789                 try {
 790                         removeAllNodeView();
 791
 792                         NodeDao dao = (NodeDao) NodeCacheDao.getInstance();
 793
 794                         if (srcId < 0) {
 795                                 // TODO
 796                         }
 797                         if (dstId < 0) {
 798                                 // TODO
 799                         }
 800
 801                         Node src = dao.searchById(srcId);
 802                         Node dst = null;
 803                         if (srcId == dstId) {
 804                                 dst = src;
 805                         } else {
 806                                 dst = dao.searchById(dstId);
 807                         }
 808
 809                         if (dstId == src.getParent()) {
 810                                 // 同じ場所に移動
 811                                 return;
 812                         }
 813                         if (!isFileNode(src) && !isMovable(srcId, dstId)) {
 814                                 // 再帰的な移動
 815                                 return;
 816                         }
 817
 818                         Node sp = dao.searchById(src.getParent());
 819                         if (sp == null) {
 820                                 // TODO
 821                         }
 822                         Node dp = null;
 823                         if (src.getParent() == dst.getParent()) {
 824                                 dp = sp;
 825                         } else {
 826                                 dp = dao.searchById(dst.getParent());
 827                         }
 828                         if (dp == null) {
 829                                 // TODO
 830                         }
 831
 832                         // TODO DBへのアクセス
 833                         // sp.remove(src.getId());
 834                         SQLiteDatabase db = DatabaseHelper.getInstance()
 835                                         .getSQLiteDatabase();
 836                         db.beginTransaction();
 837                         try {
 838                                 dao.removeChildrenIdNT(sp, src.getId());
 839                                 if (dst instanceof DirNode) {
 840                                         // dst.add(src.getId());
 841                                         dao.updateParentNT(src, dst.getId());
 842                                         dao.addChildrenIdNT(dst, src.getId());
 843                                 } else if (dst instanceof FileNode) {
 844                                         // dp.add(src.getId());
 845                                         dao.updateParentNT(src, dp.getId());
 846                                         dao.addChildrenIdNT(dp, src.getId());
 847                                 }
 848
 849                                 db.setTransactionSuccessful();
 850                         } finally {
 851                                 db.endTransaction();
 852                         }
 853                 } finally {
 854                         updateList();
 855                 }
 856         }
 857
 858         private boolean isMovable(long srcId, long dstId) {
 859                 NodeDao dao = (NodeDao) NodeCacheDao.getInstance();
 860
 861                 while (dstId >= 0) {
 862                         if (srcId == dstId) {
 863                                 return false;
 864                         }
 865                         Node node = dao.searchById(dstId);
 866                         if (node == null) {
 867                                 // TODO エラー
 868                                 return false;
 869                         }
 870                         if (!(node instanceof DirNode)) {
 871                                 return true;
 872                         }
 873                         dstId = node.getParent();
 874                 }
 875                 return true;
 876         }
 877
 878         public void execute(long id) {
 879                 NodeDao dao = (NodeDao) NodeCacheDao.getInstance();
 880
 881                 Node node = dao.searchById(id);
 882                 if (node == null) {
 883                         // TODO
 884                 }
 885                 node.toggleStatus();
 886                 Status status = node.getStatus();
 887
 888                 dao.updateStatus(node, status);
 889
 890                 // removeAllNodeView();
 891                 updateList();
 892         }
 893
 894         public void executeView(long id) {
 895                 NodeDao dao = (NodeDao) NodeCacheDao.getInstance();
 896
 897                 Node node = dao.searchById(id);
 898                 if (!isFileNode(node)) {
 899                         return;
 900                 }
 901                 String guid = node.getGuid();
 902
 903                 EvernoteIntentUtil util = EvernoteIntentUtil.getInstance();
 904                 util.viewNote(this, guid);
 905         }
 906
 907         public void targetSelectedChanged(boolean status) {
 908                 setStatus();
 909         }
 910
 911         public void removeAllNodeView() {
 912                 layout.removeAllViews();
 913         }
 914
 915         private void setStatus() {
 916                 setStatus(status);
 917         }
 918
 919         private void setStatus(ScreenStatus status) {
 920                 try {
 921                         if (this.status != status) {
 922                                 this.status = status;
 923                         }
 924
 925                         if (!lock) {
 926                                 int update = pref.getInt(Constant.PREF_UPDATE_DATA);
 927
 928                                 if (update == Constant.ON){
 929                                         msgLayout.setVisibility(View.VISIBLE);
 930                                         confirmMsg.setText(getString(R.string.mainUpdateMsg));
 931                                 }
 932                                 else {
 933                                         msgLayout.setVisibility(View.GONE);
 934                                 }
 935                                 msgEditText.setVisibility(View.GONE);
 936                                 msgButtonLayout.setVisibility(View.GONE);
 937
 938                                 leftButton.setEnabled(false);
 939                                 rightButton.setEnabled(false);
 940
 941                                 status = ScreenStatus.Normal;
 942                                 return;
 943                         }
 944
 945                         if (status == ScreenStatus.Normal) {
 946                                 msgLayout.setVisibility(View.GONE);
 947                                 // mainMsgEditText.setText("");
 948
 949                                 boolean leftButtonFlag = true;
 950                                 boolean rightButtonFlag = true;
 951                                 // boolean addButtonFlag = true;
 952                                 // boolean deleteButtonFlag = true;
 953
 954                                 if (indent <= 0) {
 955                                         leftButtonFlag = false;
 956                                 }
 957
 958                                 // LabelIconView target = layout.getSelectedTarget();
 959                                 // NodeDao dao = (NodeDao) NodeDao.getInstance();
 960                                 // long id = -1;
 961                                 // Node node = null;
 962                                 // if (target != null) {
 963                                 // id = target.getNodeId();
 964                                 // node = dao.searchById(id);
 965                                 // }
 966                                 // if (target == null || node == null || !(node instanceof
 967                                 // DirNode))
 968                                 // {
 969                                 // addButtonFlag = false;
 970                                 // }
 971                                 // if (target == null || (node != null && node instanceof
 972                                 // RootNode))
 973                                 // {
 974                                 // deleteButtonFlag = false;
 975                                 // }
 976                                 layout.setElabledTouchEvent(true);
 977
 978                                 leftButton.setEnabled(leftButtonFlag);
 979                                 rightButton.setEnabled(rightButtonFlag);
 980                                 // addButton.setEnabled(addButtonFlag);
 981                                 // deleteButton.setEnabled(deleteButtonFlag);
 982                         } else if (status == ScreenStatus.AddNode) {
 983                                 msgLayout.setVisibility(View.VISIBLE);
 984                                 msgEditText.setVisibility(View.VISIBLE);
 985                                 msgButtonLayout.setVisibility(View.VISIBLE);
 986                                 confirmMsg.setText(getString(R.string.mainAddMsg));
 987                                 msgEditText.setText("");
 988
 989                                 layout.setElabledTouchEvent(false);
 990
 991                                 leftButton.setEnabled(false);
 992                                 rightButton.setEnabled(false);
 993                         } else if (status == ScreenStatus.DeleteNode) {
 994                                 msgLayout.setVisibility(View.VISIBLE);
 995                                 msgEditText.setVisibility(View.GONE);
 996                                 msgButtonLayout.setVisibility(View.VISIBLE);
 997                                 confirmMsg.setText(getString(R.string.mainDeleteMsg));
 998
 999                                 layout.setElabledTouchEvent(false);
1000
1001                                 leftButton.setEnabled(false);
1002                                 rightButton.setEnabled(false);
1003                         } else if (status == ScreenStatus.RenameNode) {
1004                                 msgLayout.setVisibility(View.VISIBLE);
1005                                 msgEditText.setVisibility(View.VISIBLE);
1006                                 msgButtonLayout.setVisibility(View.VISIBLE);
1007                                 confirmMsg.setText(getString(R.string.mainRenameMsg));
1008
1009                                 layout.setElabledTouchEvent(false);
1010
1011                                 leftButton.setEnabled(false);
1012                                 rightButton.setEnabled(false);
1013                         }
1014                 } catch (Throwable e) {
1015                         // TODO
1016                         e.printStackTrace();
1017                 }
1018         }
1019
1020 }