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