src/com/hughes/android/dictionary/DictionaryActivity.java

   1 // Copyright 2011 Google Inc. All Rights Reserved.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 package com.hughes.android.dictionary;
  16
  17 import android.app.Dialog;
  18 import android.app.ListActivity;
  19 import android.content.Context;
  20 import android.content.Intent;
  21 import android.content.SharedPreferences;
  22 import android.graphics.Typeface;
  23 import android.net.Uri;
  24 import android.os.Bundle;
  25 import android.os.Handler;
  26 import android.preference.PreferenceManager;
  27 import android.text.ClipboardManager;
  28 import android.text.Editable;
  29 import android.text.Selection;
  30 import android.text.Spannable;
  31 import android.text.TextWatcher;
  32 import android.text.method.LinkMovementMethod;
  33 import android.text.style.StyleSpan;
  34 import android.util.Log;
  35 import android.util.TypedValue;
  36 import android.view.ContextMenu;
  37 import android.view.ContextMenu.ContextMenuInfo;
  38 import android.view.KeyEvent;
  39 import android.view.Menu;
  40 import android.view.MenuItem;
  41 import android.view.MenuItem.OnMenuItemClickListener;
  42 import android.view.MotionEvent;
  43 import android.view.View;
  44 import android.view.View.OnClickListener;
  45 import android.view.View.OnLongClickListener;
  46 import android.view.ViewGroup;
  47 import android.view.WindowManager;
  48 import android.view.inputmethod.InputMethodManager;
  49 import android.widget.AdapterView;
  50 import android.widget.AdapterView.AdapterContextMenuInfo;
  51 import android.widget.BaseAdapter;
  52 import android.widget.Button;
  53 import android.widget.EditText;
  54 import android.widget.ImageButton;
  55 import android.widget.ImageView;
  56 import android.widget.LinearLayout;
  57 import android.widget.ListAdapter;
  58 import android.widget.ListView;
  59 import android.widget.TableLayout;
  60 import android.widget.TableRow;
  61 import android.widget.TextView;
  62 import android.widget.Toast;
  63
  64 import com.hughes.android.dictionary.DictionaryInfo.IndexInfo;
  65 import com.hughes.android.dictionary.engine.Dictionary;
  66 import com.hughes.android.dictionary.engine.EntrySource;
  67 import com.hughes.android.dictionary.engine.HtmlEntry;
  68 import com.hughes.android.dictionary.engine.Index;
  69 import com.hughes.android.dictionary.engine.Index.IndexEntry;
  70 import com.hughes.android.dictionary.engine.PairEntry;
  71 import com.hughes.android.dictionary.engine.PairEntry.Pair;
  72 import com.hughes.android.dictionary.engine.RowBase;
  73 import com.hughes.android.dictionary.engine.TokenRow;
  74 import com.hughes.android.dictionary.engine.TransliteratorManager;
  75 import com.hughes.android.util.IntentLauncher;
  76 import com.hughes.android.util.NonLinkClickableSpan;
  77
  78 import java.io.File;
  79 import java.io.FileWriter;
  80 import java.io.IOException;
  81 import java.io.PrintWriter;
  82 import java.io.RandomAccessFile;
  83 import java.text.SimpleDateFormat;
  84 import java.util.Arrays;
  85 import java.util.Collections;
  86 import java.util.Date;
  87 import java.util.LinkedHashSet;
  88 import java.util.List;
  89 import java.util.Random;
  90 import java.util.Set;
  91 import java.util.concurrent.Executor;
  92 import java.util.concurrent.Executors;
  93 import java.util.concurrent.ThreadFactory;
  94 import java.util.concurrent.atomic.AtomicBoolean;
  95 import java.util.regex.Matcher;
  96 import java.util.regex.Pattern;
  97
  98 public class DictionaryActivity extends ListActivity {
  99
 100     static final String LOG = "QuickDic";
 101
 102     private String initialSearchText;
 103
 104     DictionaryApplication application;
 105
 106     File dictFile = null;
 107
 108     RandomAccessFile dictRaf = null;
 109
 110     Dictionary dictionary = null;
 111
 112     int indexIndex = 0;
 113
 114     Index index = null;
 115
 116     List<RowBase> rowsToShow = null; // if not null, just show these rows.
 117
 118     // package for test.
 119     final Handler uiHandler = new Handler();
 120
 121     private final Executor searchExecutor = Executors.newSingleThreadExecutor(new ThreadFactory() {
 122         @Override
 123         public Thread newThread(Runnable r) {
 124             return new Thread(r, "searchExecutor");
 125         }
 126     });
 127
 128     private SearchOperation currentSearchOperation = null;
 129
 130     C.Theme theme = C.Theme.LIGHT;
 131
 132     Typeface typeface;
 133
 134     int fontSizeSp;
 135
 136     EditText searchText;
 137
 138     Button langButton;
 139
 140     // Never null.
 141     private File wordList = null;
 142
 143     private boolean saveOnlyFirstSubentry = false;
 144
 145     private boolean clickOpensContextMenu = false;
 146
 147     // Visible for testing.
 148     ListAdapter indexAdapter = null;
 149
 150     final SearchTextWatcher searchTextWatcher = new SearchTextWatcher();
 151
 152     /**
 153      * For some languages, loading the transliterators used in this search takes
 154      * a long time, so we fire it up on a different thread, and don't invoke it
 155      * from the main thread until it's already finished once.
 156      */
 157     private volatile boolean indexPrepFinished = false;
 158
 159     public DictionaryActivity() {
 160     }
 161
 162     public static Intent getLaunchIntent(final File dictFile, final int indexIndex,
 163             final String searchToken) {
 164         final Intent intent = new Intent();
 165         intent.setClassName(DictionaryActivity.class.getPackage().getName(),
 166                 DictionaryActivity.class.getName());
 167         intent.putExtra(C.DICT_FILE, dictFile.getPath());
 168         intent.putExtra(C.INDEX_INDEX, indexIndex);
 169         intent.putExtra(C.SEARCH_TOKEN, searchToken);
 170         return intent;
 171     }
 172
 173     @Override
 174     protected void onSaveInstanceState(final Bundle outState) {
 175         super.onSaveInstanceState(outState);
 176         Log.d(LOG, "onSaveInstanceState: " + searchText.getText().toString());
 177         outState.putInt(C.INDEX_INDEX, indexIndex);
 178         outState.putString(C.SEARCH_TOKEN, searchText.getText().toString());
 179     }
 180
 181     @Override
 182     protected void onRestoreInstanceState(final Bundle outState) {
 183         super.onRestoreInstanceState(outState);
 184         Log.d(LOG, "onRestoreInstanceState: " + outState.getString(C.SEARCH_TOKEN));
 185         onCreate(outState);
 186     }
 187
 188     @Override
 189     public void onCreate(Bundle savedInstanceState) {
 190         final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
 191         prefs.edit().remove(C.INDEX_INDEX).commit(); // Don't auto-launch if
 192                                                      // this fails.
 193
 194         setTheme(((DictionaryApplication) getApplication()).getSelectedTheme().themeId);
 195
 196         Log.d(LOG, "onCreate:" + this);
 197         super.onCreate(savedInstanceState);
 198
 199         application = (DictionaryApplication) getApplication();
 200         theme = application.getSelectedTheme();
 201
 202         final Intent intent = getIntent();
 203         dictFile = new File(intent.getStringExtra(C.DICT_FILE));
 204
 205         try {
 206             final String name = application.getDictionaryName(dictFile.getName());
 207             this.setTitle("QuickDic: " + name);
 208             dictRaf = new RandomAccessFile(dictFile, "r");
 209             dictionary = new Dictionary(dictRaf);
 210         } catch (Exception e) {
 211             Log.e(LOG, "Unable to load dictionary.", e);
 212             if (dictRaf != null) {
 213                 try {
 214                     dictRaf.close();
 215                 } catch (IOException e1) {
 216                     Log.e(LOG, "Unable to close dictRaf.", e1);
 217                 }
 218                 dictRaf = null;
 219             }
 220             Toast.makeText(this, getString(R.string.invalidDictionary, "", e.getMessage()),
 221                     Toast.LENGTH_LONG).show();
 222             startActivity(DictionaryManagerActivity.getLaunchIntent());
 223             finish();
 224             return;
 225         }
 226         indexIndex = intent.getIntExtra(C.INDEX_INDEX, 0);
 227         if (savedInstanceState != null) {
 228             indexIndex = savedInstanceState.getInt(C.INDEX_INDEX, indexIndex);
 229         }
 230         indexIndex %= dictionary.indices.size();
 231         Log.d(LOG, "Loading index " + indexIndex);
 232         index = dictionary.indices.get(indexIndex);
 233         setListAdapter(new IndexAdapter(index));
 234
 235         // Pre-load the collators.
 236         new Thread(new Runnable() {
 237             public void run() {
 238                 final long startMillis = System.currentTimeMillis();
 239                 try {
 240                     TransliteratorManager.init(new TransliteratorManager.Callback() {
 241                         @Override
 242                         public void onTransliteratorReady() {
 243                             uiHandler.post(new Runnable() {
 244                                 @Override
 245                                 public void run() {
 246                                     onSearchTextChange(searchText.getText().toString());
 247                                 }
 248                             });
 249                         }
 250                     });
 251
 252                     for (final Index index : dictionary.indices) {
 253                         final String searchToken = index.sortedIndexEntries.get(0).token;
 254                         final IndexEntry entry = index.findExact(searchToken);
 255                         if (!searchToken.equals(entry.token)) {
 256                             Log.e(LOG, "Couldn't find token: " + searchToken + ", " + entry.token);
 257                         }
 258                     }
 259                     indexPrepFinished = true;
 260                 } catch (Exception e) {
 261                     Log.w(LOG,
 262                             "Exception while prepping.  This can happen if dictionary is closed while search is happening.");
 263                 }
 264                 Log.d(LOG, "Prepping indices took:" + (System.currentTimeMillis() - startMillis));
 265             }
 266         }).start();
 267
 268         String fontName = prefs.getString(getString(R.string.fontKey), "FreeSerif.ttf.jpg");
 269         if ("SYSTEM".equals(fontName)) {
 270             typeface = Typeface.DEFAULT;
 271         } else {
 272             try {
 273                 typeface = Typeface.createFromAsset(getAssets(), fontName);
 274             } catch (Exception e) {
 275                 Log.w(LOG, "Exception trying to use typeface, using default.", e);
 276                 Toast.makeText(this, getString(R.string.fontFailure, e.getLocalizedMessage()),
 277                         Toast.LENGTH_LONG).show();
 278             }
 279         }
 280         // if (!"SYSTEM".equals(fontName)) {
 281         // throw new RuntimeException("Test force using system font: " +
 282         // fontName);
 283         // }
 284         if (typeface == null) {
 285             Log.w(LOG, "Unable to create typeface, using default.");
 286             typeface = Typeface.DEFAULT;
 287         }
 288         final String fontSize = prefs.getString(getString(R.string.fontSizeKey), "14");
 289         try {
 290             fontSizeSp = Integer.parseInt(fontSize.trim());
 291         } catch (NumberFormatException e) {
 292             fontSizeSp = 14;
 293         }
 294
 295         setContentView(R.layout.dictionary_activity);
 296         searchText = (EditText) findViewById(R.id.SearchText);
 297         searchText.requestFocus();
 298         searchText.addTextChangedListener(searchTextWatcher);
 299
 300         // Set the search text from the intent, then the saved state.
 301         String text = getIntent().getStringExtra(C.SEARCH_TOKEN);
 302         if (savedInstanceState != null) {
 303             text = savedInstanceState.getString(C.SEARCH_TOKEN);
 304         }
 305         if (text == null) {
 306             text = "";
 307         }
 308         setSearchText(text, true);
 309         Log.d(LOG, "Trying to restore searchText=" + text);
 310
 311         final View clearSearchTextButton = findViewById(R.id.ClearSearchTextButton);
 312         clearSearchTextButton.setOnClickListener(new OnClickListener() {
 313             public void onClick(View v) {
 314                 onClearSearchTextButton();
 315             }
 316         });
 317         clearSearchTextButton.setVisibility(PreferenceManager.getDefaultSharedPreferences(this)
 318                 .getBoolean(getString(R.string.showClearSearchTextButtonKey), true) ? View.VISIBLE
 319                 : View.GONE);
 320
 321         langButton = (Button) findViewById(R.id.LangButton);
 322         langButton.setOnClickListener(new OnClickListener() {
 323             public void onClick(View v) {
 324                 onLanguageButton();
 325             }
 326         });
 327         langButton.setOnLongClickListener(new OnLongClickListener() {
 328             @Override
 329             public boolean onLongClick(View v) {
 330                 onLanguageButtonLongClick(v.getContext());
 331                 return true;
 332             }
 333         });
 334         updateLangButton();
 335
 336         final View upButton = findViewById(R.id.UpButton);
 337         upButton.setOnClickListener(new OnClickListener() {
 338             public void onClick(View v) {
 339                 onUpDownButton(true);
 340             }
 341         });
 342         final View downButton = findViewById(R.id.DownButton);
 343         downButton.setOnClickListener(new OnClickListener() {
 344             public void onClick(View v) {
 345                 onUpDownButton(false);
 346             }
 347         });
 348
 349         getListView().setOnItemSelectedListener(new ListView.OnItemSelectedListener() {
 350             @Override
 351             public void onItemSelected(AdapterView<?> adapterView, View arg1, final int position,
 352                     long id) {
 353                 if (!searchText.isFocused()) {
 354                     if (!isFiltered()) {
 355                         final RowBase row = (RowBase) getListAdapter().getItem(position);
 356                         Log.d(LOG, "onItemSelected: " + row.index());
 357                         final TokenRow tokenRow = row.getTokenRow(true);
 358                         searchText.setText(tokenRow.getToken());
 359                     }
 360                 }
 361             }
 362
 363             @Override
 364             public void onNothingSelected(AdapterView<?> arg0) {
 365             }
 366         });
 367
 368         // ContextMenu.
 369         registerForContextMenu(getListView());
 370
 371         // Prefs.
 372         wordList = new File(prefs.getString(getString(R.string.wordListFileKey),
 373                 getString(R.string.wordListFileDefault)));
 374         saveOnlyFirstSubentry = prefs.getBoolean(getString(R.string.saveOnlyFirstSubentryKey),
 375                 false);
 376         clickOpensContextMenu = prefs.getBoolean(getString(R.string.clickOpensContextMenuKey),
 377                 false);
 378         // if (prefs.getBoolean(getString(R.string.vibrateOnFailedSearchKey),
 379         // true)) {
 380         // vibrator = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
 381         // }
 382         Log.d(LOG, "wordList=" + wordList + ", saveOnlyFirstSubentry=" + saveOnlyFirstSubentry);
 383
 384         setDictionaryPrefs(this, dictFile, indexIndex, searchText.getText().toString());
 385     }
 386
 387     @Override
 388     protected void onResume() {
 389         super.onResume();
 390         if (PreferenceActivity.prefsMightHaveChanged) {
 391             PreferenceActivity.prefsMightHaveChanged = false;
 392             finish();
 393             startActivity(getIntent());
 394         }
 395         if (initialSearchText != null) {
 396             setSearchText(initialSearchText, true);
 397         }
 398     }
 399
 400     @Override
 401     protected void onPause() {
 402         super.onPause();
 403     }
 404
 405     private static void setDictionaryPrefs(final Context context, final File dictFile,
 406             final int indexIndex, final String searchToken) {
 407         final SharedPreferences.Editor prefs = PreferenceManager.getDefaultSharedPreferences(
 408                 context).edit();
 409         prefs.putString(C.DICT_FILE, dictFile.getPath());
 410         prefs.putInt(C.INDEX_INDEX, indexIndex);
 411         prefs.putString(C.SEARCH_TOKEN, ""); // Don't need to save search token.
 412         prefs.commit();
 413     }
 414
 415     @Override
 416     protected void onDestroy() {
 417         super.onDestroy();
 418         if (dictRaf == null) {
 419             return;
 420         }
 421
 422         final SearchOperation searchOperation = currentSearchOperation;
 423         currentSearchOperation = null;
 424
 425         // Before we close the RAF, we have to wind the current search down.
 426         if (searchOperation != null) {
 427             Log.d(LOG, "Interrupting search to shut down.");
 428             currentSearchOperation = null;
 429             searchOperation.interrupted.set(true);
 430         }
 431
 432         try {
 433             Log.d(LOG, "Closing RAF.");
 434             dictRaf.close();
 435         } catch (IOException e) {
 436             Log.e(LOG, "Failed to close dictionary", e);
 437         }
 438         dictRaf = null;
 439     }
 440
 441     // --------------------------------------------------------------------------
 442     // Buttons
 443     // --------------------------------------------------------------------------
 444
 445     private void onClearSearchTextButton() {
 446         setSearchText("", true);
 447         Log.d(LOG, "Trying to show soft keyboard.");
 448         final InputMethodManager manager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
 449         manager.showSoftInput(searchText, InputMethodManager.SHOW_IMPLICIT);
 450     }
 451
 452     void updateLangButton() {
 453         // final LanguageResources languageResources =
 454         // Language.isoCodeToResources.get(index.shortName);
 455         // if (languageResources != null && languageResources.flagId != 0) {
 456         // langButton.setCompoundDrawablesWithIntrinsicBounds(0, 0,
 457         // languageResources.flagId, 0);
 458         // } else {
 459         // langButton.setCompoundDrawablesWithIntrinsicBounds(0, 0, 0, 0);
 460         langButton.setText(index.shortName);
 461         // }
 462     }
 463
 464     void onLanguageButton() {
 465         if (currentSearchOperation != null) {
 466             currentSearchOperation.interrupted.set(true);
 467             currentSearchOperation = null;
 468         }
 469         changeIndexGetFocusAndResearch((indexIndex + 1) % dictionary.indices.size());
 470     }
 471
 472     void onLanguageButtonLongClick(final Context context) {
 473         final Dialog dialog = new Dialog(context);
 474         dialog.setContentView(R.layout.select_dictionary_dialog);
 475         dialog.setTitle(R.string.selectDictionary);
 476
 477         final List<DictionaryInfo> installedDicts = ((DictionaryApplication) getApplication())
 478                 .getUsableDicts();
 479
 480         ListView listView = (ListView) dialog.findViewById(android.R.id.list);
 481
 482         // final LinearLayout.LayoutParams layoutParams = new
 483         // LinearLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT,
 484         // ViewGroup.LayoutParams.WRAP_CONTENT);
 485         // layoutParams.width = 0;
 486         // layoutParams.weight = 1.0f;
 487
 488         final Button button = new Button(listView.getContext());
 489         final String name = getString(R.string.dictionaryManager);
 490         button.setText(name);
 491         final IntentLauncher intentLauncher = new IntentLauncher(listView.getContext(),
 492                 DictionaryManagerActivity.getLaunchIntent()) {
 493             @Override
 494             protected void onGo() {
 495                 dialog.dismiss();
 496                 DictionaryActivity.this.finish();
 497             };
 498         };
 499         button.setOnClickListener(intentLauncher);
 500         // button.setLayoutParams(layoutParams);
 501         listView.addHeaderView(button);
 502         // listView.setHeaderDividersEnabled(true);
 503
 504         listView.setAdapter(new BaseAdapter() {
 505             @Override
 506             public View getView(int position, View convertView, ViewGroup parent) {
 507                 final LinearLayout result = new LinearLayout(parent.getContext());
 508
 509                 final DictionaryInfo dictionaryInfo = getItem(position);
 510                 for (int i = 0; i < dictionaryInfo.indexInfos.size(); ++i) {
 511                     final IndexInfo indexInfo = dictionaryInfo.indexInfos.get(i);
 512                     final Button button = new Button(parent.getContext());
 513 //                    final String name = application
 514 //                            .getDictionaryName(dictionaryInfo.uncompressedFilename);
 515                     button.setText(indexInfo.shortName);
 516                     final IntentLauncher intentLauncher = new IntentLauncher(parent.getContext(),
 517                             getLaunchIntent(application.getPath(dictionaryInfo.uncompressedFilename),
 518                                     i, searchText.getText().toString())) {
 519                         @Override
 520                         protected void onGo() {
 521                             dialog.dismiss();
 522                             DictionaryActivity.this.finish();
 523                         };
 524                     };
 525                     button.setOnClickListener(intentLauncher);
 526                     final LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(
 527                             ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
 528                     layoutParams.width = 0;
 529                     layoutParams.weight = 1.0f;
 530                     button.setLayoutParams(layoutParams);
 531                     result.addView(button);
 532
 533                     if (i > 0) {
 534                         final TextView dash = new TextView(parent.getContext());
 535                         dash.setText("-");
 536                         result.addView(dash);
 537                     }
 538                 }
 539                 return result;
 540             }
 541
 542             @Override
 543             public long getItemId(int position) {
 544                 return position;
 545             }
 546
 547             @Override
 548             public DictionaryInfo getItem(int position) {
 549                 return installedDicts.get(position);
 550             }
 551
 552             @Override
 553             public int getCount() {
 554                 return installedDicts.size();
 555             }
 556         });
 557
 558         dialog.show();
 559     }
 560
 561     private void changeIndexGetFocusAndResearch(final int newIndex) {
 562         indexIndex = newIndex;
 563         index = dictionary.indices.get(indexIndex);
 564         indexAdapter = new IndexAdapter(index);
 565         Log.d(LOG, "changingIndex, newLang=" + index.longName);
 566         setListAdapter(indexAdapter);
 567         updateLangButton();
 568         searchText.requestFocus(); // Otherwise, nothing may happen.
 569         onSearchTextChange(searchText.getText().toString());
 570         setDictionaryPrefs(this, dictFile, indexIndex, searchText.getText().toString());
 571     }
 572
 573     void onUpDownButton(final boolean up) {
 574         if (isFiltered()) {
 575             return;
 576         }
 577         final int firstVisibleRow = getListView().getFirstVisiblePosition();
 578         final RowBase row = index.rows.get(firstVisibleRow);
 579         final TokenRow tokenRow = row.getTokenRow(true);
 580         final int destIndexEntry;
 581         if (up) {
 582             if (row != tokenRow) {
 583                 destIndexEntry = tokenRow.referenceIndex;
 584             } else {
 585                 destIndexEntry = Math.max(tokenRow.referenceIndex - 1, 0);
 586             }
 587         } else {
 588             // Down
 589             destIndexEntry = Math.min(tokenRow.referenceIndex + 1, index.sortedIndexEntries.size());
 590         }
 591         final Index.IndexEntry dest = index.sortedIndexEntries.get(destIndexEntry);
 592         Log.d(LOG, "onUpDownButton, destIndexEntry=" + dest.token);
 593         searchText.removeTextChangedListener(searchTextWatcher);
 594         searchText.setText(dest.token);
 595         if (searchText.getLayout() != null) {
 596             // Surprising, but this can otherwise crash sometimes...
 597             Selection.moveToRightEdge(searchText.getText(), searchText.getLayout());
 598         }
 599         jumpToRow(index.sortedIndexEntries.get(destIndexEntry).startRow);
 600         searchText.addTextChangedListener(searchTextWatcher);
 601     }
 602
 603     // --------------------------------------------------------------------------
 604     // Options Menu
 605     // --------------------------------------------------------------------------
 606
 607     final Random random = new Random();
 608
 609     @Override
 610     public boolean onCreateOptionsMenu(final Menu menu) {
 611         application.onCreateGlobalOptionsMenu(this, menu);
 612
 613         {
 614             final MenuItem randomWord = menu.add(getString(R.string.randomWord));
 615             randomWord.setOnMenuItemClickListener(new OnMenuItemClickListener() {
 616                 public boolean onMenuItemClick(final MenuItem menuItem) {
 617                     final String word = index.sortedIndexEntries.get(random
 618                             .nextInt(index.sortedIndexEntries.size())).token;
 619                     setSearchText(word, true);
 620                     return false;
 621                 }
 622             });
 623         }
 624
 625         {
 626             final MenuItem dictionaryList = menu.add(getString(R.string.dictionaryManager));
 627             dictionaryList.setOnMenuItemClickListener(new OnMenuItemClickListener() {
 628                 public boolean onMenuItemClick(final MenuItem menuItem) {
 629                     startActivity(DictionaryManagerActivity.getLaunchIntent());
 630                     finish();
 631                     return false;
 632                 }
 633             });
 634         }
 635
 636         {
 637             final MenuItem aboutDictionary = menu.add(getString(R.string.aboutDictionary));
 638             aboutDictionary.setOnMenuItemClickListener(new OnMenuItemClickListener() {
 639                 public boolean onMenuItemClick(final MenuItem menuItem) {
 640                     final Context context = getListView().getContext();
 641                     final Dialog dialog = new Dialog(context);
 642                     dialog.setContentView(R.layout.about_dictionary_dialog);
 643                     final TextView textView = (TextView) dialog.findViewById(R.id.text);
 644
 645                     final String name = application.getDictionaryName(dictFile.getName());
 646                     dialog.setTitle(name);
 647
 648                     final StringBuilder builder = new StringBuilder();
 649                     final DictionaryInfo dictionaryInfo = dictionary.getDictionaryInfo();
 650                     dictionaryInfo.uncompressedBytes = dictFile.length();
 651                     if (dictionaryInfo != null) {
 652                         builder.append(dictionaryInfo.dictInfo).append("\n\n");
 653                         builder.append(getString(R.string.dictionaryPath, dictFile.getPath()))
 654                                 .append("\n");
 655                         builder.append(
 656                                 getString(R.string.dictionarySize, dictionaryInfo.uncompressedBytes))
 657                                 .append("\n");
 658                         builder.append(
 659                                 getString(R.string.dictionaryCreationTime,
 660                                         dictionaryInfo.creationMillis)).append("\n");
 661                         for (final IndexInfo indexInfo : dictionaryInfo.indexInfos) {
 662                             builder.append("\n");
 663                             builder.append(getString(R.string.indexName, indexInfo.shortName))
 664                                     .append("\n");
 665                             builder.append(
 666                                     getString(R.string.mainTokenCount, indexInfo.mainTokenCount))
 667                                     .append("\n");
 668                         }
 669                         builder.append("\n");
 670                         builder.append(getString(R.string.sources)).append("\n");
 671                         for (final EntrySource source : dictionary.sources) {
 672                             builder.append(
 673                                     getString(R.string.sourceInfo, source.getName(),
 674                                             source.getNumEntries())).append("\n");
 675                         }
 676                     }
 677                     // } else {
 678                     // builder.append(getString(R.string.invalidDictionary));
 679                     // }
 680                     textView.setText(builder.toString());
 681
 682                     dialog.show();
 683                     final WindowManager.LayoutParams layoutParams = new WindowManager.LayoutParams();
 684                     layoutParams.width = WindowManager.LayoutParams.MATCH_PARENT;
 685                     layoutParams.height = WindowManager.LayoutParams.MATCH_PARENT;
 686                     dialog.getWindow().setAttributes(layoutParams);
 687                     return false;
 688                 }
 689             });
 690         }
 691
 692         return true;
 693     }
 694
 695     // --------------------------------------------------------------------------
 696     // Context Menu + clicks
 697     // --------------------------------------------------------------------------
 698
 699     @Override
 700     public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
 701         AdapterContextMenuInfo adapterContextMenuInfo = (AdapterContextMenuInfo) menuInfo;
 702         final RowBase row = (RowBase) getListAdapter().getItem(adapterContextMenuInfo.position);
 703
 704         final MenuItem addToWordlist = menu.add(getString(R.string.addToWordList,
 705                 wordList.getName()));
 706         addToWordlist.setOnMenuItemClickListener(new OnMenuItemClickListener() {
 707             public boolean onMenuItemClick(MenuItem item) {
 708                 onAppendToWordList(row);
 709                 return false;
 710             }
 711         });
 712
 713         final MenuItem copy = menu.add(android.R.string.copy);
 714         copy.setOnMenuItemClickListener(new OnMenuItemClickListener() {
 715             public boolean onMenuItemClick(MenuItem item) {
 716                 onCopy(row);
 717                 return false;
 718             }
 719         });
 720
 721         if (selectedSpannableText != null) {
 722             final String selectedText = selectedSpannableText;
 723             final MenuItem searchForSelection = menu.add(getString(R.string.searchForSelection,
 724                     selectedSpannableText));
 725             searchForSelection.setOnMenuItemClickListener(new OnMenuItemClickListener() {
 726                 public boolean onMenuItemClick(MenuItem item) {
 727                     int indexToUse = -1;
 728                     for (int i = 0; i < dictionary.indices.size(); ++i) {
 729                         final Index index = dictionary.indices.get(i);
 730                         if (indexPrepFinished) {
 731                             System.out.println("Doing index lookup: on " + selectedText);
 732                             final IndexEntry indexEntry = index.findExact(selectedText);
 733                             if (indexEntry != null) {
 734                                 final TokenRow tokenRow = index.rows.get(indexEntry.startRow)
 735                                         .getTokenRow(false);
 736                                 if (tokenRow != null && tokenRow.hasMainEntry) {
 737                                     indexToUse = i;
 738                                     break;
 739                                 }
 740                             }
 741                         } else {
 742                             Log.w(LOG, "Skipping findExact on index " + index.shortName);
 743                         }
 744                     }
 745                     if (indexToUse == -1) {
 746                         indexToUse = selectedSpannableIndex;
 747                     }
 748                     final boolean changeIndex = indexIndex != indexToUse;
 749                     setSearchText(selectedText, !changeIndex); // If we're not
 750                                                                // changing
 751                                                                // index, we have
 752                                                                // to
 753                                                                // triggerSearch.
 754                     if (changeIndex) {
 755                         changeIndexGetFocusAndResearch(indexToUse);
 756                     }
 757                     // Give focus back to list view because typing is done.
 758                     getListView().requestFocus();
 759                     return false;
 760                 }
 761             });
 762         }
 763
 764     }
 765
 766     @Override
 767     protected void onListItemClick(ListView l, View v, int row, long id) {
 768         defocusSearchText();
 769         if (clickOpensContextMenu && dictRaf != null) {
 770             openContextMenu(v);
 771         }
 772     }
 773
 774     void onAppendToWordList(final RowBase row) {
 775         defocusSearchText();
 776
 777         final StringBuilder rawText = new StringBuilder();
 778         rawText.append(new SimpleDateFormat("yyyy.MM.dd HH:mm:ss").format(new Date())).append("\t");
 779         rawText.append(index.longName).append("\t");
 780         rawText.append(row.getTokenRow(true).getToken()).append("\t");
 781         rawText.append(row.getRawText(saveOnlyFirstSubentry));
 782         Log.d(LOG, "Writing : " + rawText);
 783
 784         try {
 785             wordList.getParentFile().mkdirs();
 786             final PrintWriter out = new PrintWriter(new FileWriter(wordList, true));
 787             out.println(rawText.toString());
 788             out.close();
 789         } catch (IOException e) {
 790             Log.e(LOG, "Unable to append to " + wordList.getAbsolutePath(), e);
 791             Toast.makeText(this,
 792                     getString(R.string.failedAddingToWordList, wordList.getAbsolutePath()),
 793                     Toast.LENGTH_LONG).show();
 794         }
 795         return;
 796     }
 797
 798     /**
 799      * Called when user clicks outside of search text, so that they can start
 800      * typing again immediately.
 801      */
 802     void defocusSearchText() {
 803         // Log.d(LOG, "defocusSearchText");
 804         // Request focus so that if we start typing again, it clears the text
 805         // input.
 806         getListView().requestFocus();
 807
 808         // Visual indication that a new keystroke will clear the search text.
 809         searchText.selectAll();
 810     }
 811
 812     @SuppressWarnings("deprecation")
 813     void onCopy(final RowBase row) {
 814         defocusSearchText();
 815
 816         Log.d(LOG, "Copy, row=" + row);
 817         final StringBuilder result = new StringBuilder();
 818         result.append(row.getRawText(false));
 819         final ClipboardManager clipboardManager = (ClipboardManager) getSystemService(Context.CLIPBOARD_SERVICE);
 820         clipboardManager.setText(result.toString());
 821         Log.d(LOG, "Copied: " + result);
 822     }
 823
 824     @Override
 825     public boolean onKeyDown(final int keyCode, final KeyEvent event) {
 826         if (event.getUnicodeChar() != 0) {
 827             if (!searchText.hasFocus()) {
 828                 setSearchText("" + (char) event.getUnicodeChar(), true);
 829             }
 830             return true;
 831         }
 832         if (keyCode == KeyEvent.KEYCODE_BACK) {
 833             // Log.d(LOG, "Clearing dictionary prefs.");
 834             // Pretend that we just autolaunched so that we won't do it again.
 835             // DictionaryManagerActivity.lastAutoLaunchMillis =
 836             // System.currentTimeMillis();
 837         }
 838         if (keyCode == KeyEvent.KEYCODE_ENTER) {
 839             Log.d(LOG, "Trying to hide soft keyboard.");
 840             final InputMethodManager inputManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
 841             inputManager.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(),
 842                     InputMethodManager.HIDE_NOT_ALWAYS);
 843             return true;
 844         }
 845         return super.onKeyDown(keyCode, event);
 846     }
 847
 848     private void setSearchText(final String text, final boolean triggerSearch) {
 849         if (!triggerSearch) {
 850             getListView().requestFocus();
 851         }
 852         searchText.setText(text);
 853         searchText.requestFocus();
 854         moveCursorToRight();
 855         if (triggerSearch) {
 856             onSearchTextChange(text);
 857         }
 858     }
 859
 860     private long cursorDelayMillis = 100;
 861
 862     private void moveCursorToRight() {
 863         if (searchText.getLayout() != null) {
 864             cursorDelayMillis = 100;
 865             // Surprising, but this can crash when you rotate...
 866             Selection.moveToRightEdge(searchText.getText(), searchText.getLayout());
 867         } else {
 868             uiHandler.postDelayed(new Runnable() {
 869                 @Override
 870                 public void run() {
 871                     moveCursorToRight();
 872                 }
 873             }, cursorDelayMillis);
 874             cursorDelayMillis = Math.min(10 * 1000, 2 * cursorDelayMillis);
 875         }
 876     }
 877
 878     // --------------------------------------------------------------------------
 879     // SearchOperation
 880     // --------------------------------------------------------------------------
 881
 882     private void searchFinished(final SearchOperation searchOperation) {
 883         if (searchOperation.interrupted.get()) {
 884             Log.d(LOG, "Search operation was interrupted: " + searchOperation);
 885             return;
 886         }
 887         if (searchOperation != this.currentSearchOperation) {
 888             Log.d(LOG, "Stale searchOperation finished: " + searchOperation);
 889             return;
 890         }
 891
 892         final Index.IndexEntry searchResult = searchOperation.searchResult;
 893         Log.d(LOG, "searchFinished: " + searchOperation + ", searchResult=" + searchResult);
 894
 895         currentSearchOperation = null;
 896         uiHandler.postDelayed(new Runnable() {
 897             @Override
 898             public void run() {
 899                 if (currentSearchOperation == null) {
 900                     if (searchResult != null) {
 901                         if (isFiltered()) {
 902                             clearFiltered();
 903                         }
 904                         jumpToRow(searchResult.startRow);
 905                     } else if (searchOperation.multiWordSearchResult != null) {
 906                         // Multi-row search....
 907                         setFiltered(searchOperation);
 908                     } else {
 909                         throw new IllegalStateException("This should never happen.");
 910                     }
 911                 } else {
 912                     Log.d(LOG, "More coming, waiting for currentSearchOperation.");
 913                 }
 914             }
 915         }, 20);
 916
 917     }
 918
 919     private final void jumpToRow(final int row) {
 920         setSelection(row);
 921         getListView().setSelected(true);
 922     }
 923
 924     static final Pattern WHITESPACE = Pattern.compile("\\s+");
 925
 926     final class SearchOperation implements Runnable {
 927
 928         final AtomicBoolean interrupted = new AtomicBoolean(false);
 929
 930         final String searchText;
 931
 932         List<String> searchTokens; // filled in for multiWord.
 933
 934         final Index index;
 935
 936         long searchStartMillis;
 937
 938         Index.IndexEntry searchResult;
 939
 940         List<RowBase> multiWordSearchResult;
 941
 942         boolean done = false;
 943
 944         SearchOperation(final String searchText, final Index index) {
 945             this.searchText = searchText.trim();
 946             this.index = index;
 947         }
 948
 949         public String toString() {
 950             return String.format("SearchOperation(%s,%s)", searchText, interrupted.toString());
 951         }
 952
 953         @Override
 954         public void run() {
 955             try {
 956                 searchStartMillis = System.currentTimeMillis();
 957                 final String[] searchTokenArray = WHITESPACE.split(searchText);
 958                 if (searchTokenArray.length == 1) {
 959                     searchResult = index.findInsertionPoint(searchText, interrupted);
 960                 } else {
 961                     searchTokens = Arrays.asList(searchTokenArray);
 962                     multiWordSearchResult = index.multiWordSearch(searchTokens, interrupted);
 963                 }
 964                 Log.d(LOG,
 965                         "searchText=" + searchText + ", searchDuration="
 966                                 + (System.currentTimeMillis() - searchStartMillis)
 967                                 + ", interrupted=" + interrupted.get());
 968                 if (!interrupted.get()) {
 969                     uiHandler.post(new Runnable() {
 970                         @Override
 971                         public void run() {
 972                             searchFinished(SearchOperation.this);
 973                         }
 974                     });
 975                 }
 976             } catch (Exception e) {
 977                 Log.e(LOG, "Failure during search (can happen during Activity close.");
 978             } finally {
 979                 synchronized (this) {
 980                     done = true;
 981                     this.notifyAll();
 982                 }
 983             }
 984         }
 985     }
 986
 987     // --------------------------------------------------------------------------
 988     // IndexAdapter
 989     // --------------------------------------------------------------------------
 990
 991     static ViewGroup.LayoutParams WEIGHT_1 = new LinearLayout.LayoutParams(
 992             ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.MATCH_PARENT, 1.0f);
 993
 994     static ViewGroup.LayoutParams WEIGHT_0 = new LinearLayout.LayoutParams(
 995             ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.MATCH_PARENT, 0.0f);
 996
 997     final class IndexAdapter extends BaseAdapter {
 998
 999         private static final float PADDING_DEFAULT_DP = 8;
1000
1001         private static final float PADDING_LARGE_DP = 16;
1002
1003         final Index index;
1004
1005         final List<RowBase> rows;
1006
1007         final Set<String> toHighlight;
1008
1009         private int mPaddingDefault;
1010
1011         private int mPaddingLarge;
1012
1013         IndexAdapter(final Index index) {
1014             this.index = index;
1015             rows = index.rows;
1016             this.toHighlight = null;
1017             getMetrics();
1018         }
1019
1020         IndexAdapter(final Index index, final List<RowBase> rows, final List<String> toHighlight) {
1021             this.index = index;
1022             this.rows = rows;
1023             this.toHighlight = new LinkedHashSet<String>(toHighlight);
1024             getMetrics();
1025         }
1026
1027         private void getMetrics() {
1028             // Get the screen's density scale
1029             final float scale = getResources().getDisplayMetrics().density;
1030             // Convert the dps to pixels, based on density scale
1031             mPaddingDefault = (int) (PADDING_DEFAULT_DP * scale + 0.5f);
1032             mPaddingLarge = (int) (PADDING_LARGE_DP * scale + 0.5f);
1033         }
1034
1035         @Override
1036         public int getCount() {
1037             return rows.size();
1038         }
1039
1040         @Override
1041         public RowBase getItem(int position) {
1042             return rows.get(position);
1043         }
1044
1045         @Override
1046         public long getItemId(int position) {
1047             return getItem(position).index();
1048         }
1049
1050         @Override
1051         public TableLayout getView(int position, View convertView, ViewGroup parent) {
1052             final TableLayout result;
1053             if (convertView instanceof TableLayout) {
1054                 result = (TableLayout) convertView;
1055                 result.removeAllViews();
1056             } else {
1057                 result = new TableLayout(parent.getContext());
1058             }
1059             final RowBase row = getItem(position);
1060             if (row instanceof PairEntry.Row) {
1061                 return getView(position, (PairEntry.Row) row, parent, result);
1062             } else if (row instanceof TokenRow) {
1063                 return getView((TokenRow) row, parent, result);
1064             } else if (row instanceof HtmlEntry.Row) {
1065                 return getView((HtmlEntry.Row) row, parent, result);
1066             } else {
1067                 throw new IllegalArgumentException("Unsupported Row type: " + row.getClass());
1068             }
1069         }
1070
1071         private TableLayout getView(final int position, PairEntry.Row row, ViewGroup parent,
1072                 final TableLayout result) {
1073             final PairEntry entry = row.getEntry();
1074             final int rowCount = entry.pairs.size();
1075
1076             final TableRow.LayoutParams layoutParams = new TableRow.LayoutParams();
1077             layoutParams.weight = 0.5f;
1078             layoutParams.leftMargin = mPaddingLarge;
1079
1080             for (int r = 0; r < rowCount; ++r) {
1081                 final TableRow tableRow = new TableRow(result.getContext());
1082
1083                 final TextView col1 = new TextView(tableRow.getContext());
1084                 final TextView col2 = new TextView(tableRow.getContext());
1085
1086                 // Set the columns in the table.
1087                 if (r > 0) {
1088                     final TextView bullet = new TextView(tableRow.getContext());
1089                     bullet.setText(" • ");
1090                     tableRow.addView(bullet);
1091                 }
1092                 tableRow.addView(col1, layoutParams);
1093                 final TextView margin = new TextView(tableRow.getContext());
1094                 margin.setText(" ");
1095                 tableRow.addView(margin);
1096                 if (r > 0) {
1097                     final TextView bullet = new TextView(tableRow.getContext());
1098                     bullet.setText(" • ");
1099                     tableRow.addView(bullet);
1100                 }
1101                 tableRow.addView(col2, layoutParams);
1102                 col1.setWidth(1);
1103                 col2.setWidth(1);
1104
1105                 // Set what's in the columns.
1106
1107                 final Pair pair = entry.pairs.get(r);
1108                 final String col1Text = index.swapPairEntries ? pair.lang2 : pair.lang1;
1109                 final String col2Text = index.swapPairEntries ? pair.lang1 : pair.lang2;
1110
1111                 col1.setText(col1Text, TextView.BufferType.SPANNABLE);
1112                 col2.setText(col2Text, TextView.BufferType.SPANNABLE);
1113
1114                 // Bold the token instances in col1.
1115                 final Set<String> toBold = toHighlight != null ? this.toHighlight : Collections
1116                         .singleton(row.getTokenRow(true).getToken());
1117                 final Spannable col1Spannable = (Spannable) col1.getText();
1118                 for (final String token : toBold) {
1119                     int startPos = 0;
1120                     while ((startPos = col1Text.indexOf(token, startPos)) != -1) {
1121                         col1Spannable.setSpan(new StyleSpan(Typeface.BOLD), startPos, startPos
1122                                 + token.length(), Spannable.SPAN_INCLUSIVE_EXCLUSIVE);
1123                         startPos += token.length();
1124                     }
1125                 }
1126
1127                 createTokenLinkSpans(col1, col1Spannable, col1Text);
1128                 createTokenLinkSpans(col2, (Spannable) col2.getText(), col2Text);
1129
1130                 col1.setTypeface(typeface);
1131                 col2.setTypeface(typeface);
1132                 col1.setTextSize(TypedValue.COMPLEX_UNIT_SP, fontSizeSp);
1133                 col2.setTextSize(TypedValue.COMPLEX_UNIT_SP, fontSizeSp);
1134                 // col2.setBackgroundResource(theme.otherLangBg);
1135
1136                 if (index.swapPairEntries) {
1137                     col2.setOnLongClickListener(textViewLongClickListenerIndex0);
1138                     col1.setOnLongClickListener(textViewLongClickListenerIndex1);
1139                 } else {
1140                     col1.setOnLongClickListener(textViewLongClickListenerIndex0);
1141                     col2.setOnLongClickListener(textViewLongClickListenerIndex1);
1142                 }
1143
1144                 result.addView(tableRow);
1145             }
1146
1147             // Because we have a Button inside a ListView row:
1148             // http://groups.google.com/group/android-developers/browse_thread/thread/3d96af1530a7d62a?pli=1
1149             result.setDescendantFocusability(ViewGroup.FOCUS_BLOCK_DESCENDANTS);
1150             result.setClickable(true);
1151             result.setFocusable(true);
1152             result.setLongClickable(true);
1153             result.setBackgroundResource(android.R.drawable.menuitem_background);
1154             result.setOnClickListener(new TextView.OnClickListener() {
1155                 @Override
1156                 public void onClick(View v) {
1157                     DictionaryActivity.this.onListItemClick(getListView(), v, position, position);
1158                 }
1159             });
1160
1161             return result;
1162         }
1163
1164         private TableLayout getView(HtmlEntry.Row row, ViewGroup parent, final TableLayout result) {
1165             final HtmlEntry htmlEntry = row.getEntry();
1166             return getPossibleHtmlEntryView(htmlEntry.title, false, Collections.singletonList(htmlEntry), parent, result);
1167         }
1168
1169         private TableLayout getPossibleHtmlEntryView(final String text, final boolean hasMainEntry, final List<HtmlEntry> htmlEntries, ViewGroup parent, final TableLayout result) {
1170             final Context context = parent.getContext();
1171
1172             final TableRow tableRow = new TableRow(result.getContext());
1173             tableRow.setBackgroundResource(hasMainEntry ? theme.tokenRowMainBg
1174                     : theme.tokenRowOtherBg);
1175             tableRow.setPadding(mPaddingDefault, mPaddingDefault, mPaddingDefault, 0);
1176             result.addView(tableRow);
1177
1178
1179             final TextView textView = new TextView(context);
1180             textView.setText(text);
1181             // Doesn't work:
1182             // textView.setTextColor(android.R.color.secondary_text_light);
1183             textView.setTextAppearance(context, theme.tokenRowFg);
1184             textView.setTypeface(typeface);
1185             textView.setTextSize(TypedValue.COMPLEX_UNIT_SP, 5 * fontSizeSp / 4);
1186             TableRow.LayoutParams lp = new TableRow.LayoutParams(0);
1187             lp.weight = 1.0f;
1188             textView.setLayoutParams(lp);
1189             tableRow.addView(textView);
1190
1191
1192             if (!htmlEntries.isEmpty()) {
1193                 final ImageButton button = new ImageButton(context);
1194                 button.setImageResource(R.drawable.ic_menu_forward);
1195                 button.setOnClickListener(new OnClickListener() {
1196                     @Override
1197                     public void onClick(View v) {
1198                         final String html = HtmlEntry.htmlBody(htmlEntries);
1199                         startActivity(HtmlDisplayActivity.getHtmlIntent(String.format(
1200                                 "<html><head></head><body>%s</body></html>", html)));
1201                     }
1202                 });
1203                 tableRow.addView(button);
1204                 lp = new TableRow.LayoutParams(1);
1205                 lp.weight = 0.0f;
1206                 button.setLayoutParams(lp);
1207                 //result.setColumnStretchable(0, true);
1208                 //result.setColumnStretchable(1, false);
1209             }
1210             return result;
1211         }
1212
1213         private TableLayout getView(TokenRow row, ViewGroup parent, final TableLayout result) {
1214             final IndexEntry indexEntry = row.getIndexEntry();
1215             return getPossibleHtmlEntryView(indexEntry.token, row.hasMainEntry, indexEntry.htmlEntries, parent, result);
1216         }
1217
1218     }
1219
1220
1221
1222     static final Pattern CHAR_DASH = Pattern.compile("['\\p{L}\\p{M}\\p{N}]+");
1223
1224     private void createTokenLinkSpans(final TextView textView, final Spannable spannable,
1225             final String text) {
1226         // Saw from the source code that LinkMovementMethod sets the selection!
1227         // http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/2.3.1_r1/android/text/method/LinkMovementMethod.java#LinkMovementMethod
1228         textView.setMovementMethod(LinkMovementMethod.getInstance());
1229         final Matcher matcher = CHAR_DASH.matcher(text);
1230         while (matcher.find()) {
1231             spannable.setSpan(new NonLinkClickableSpan(), matcher.start(), matcher.end(),
1232                     Spannable.SPAN_INCLUSIVE_EXCLUSIVE);
1233         }
1234     }
1235
1236     String selectedSpannableText = null;
1237
1238     int selectedSpannableIndex = -1;
1239
1240     @Override
1241     public boolean onTouchEvent(MotionEvent event) {
1242         selectedSpannableText = null;
1243         selectedSpannableIndex = -1;
1244         return super.onTouchEvent(event);
1245     }
1246
1247     private class TextViewLongClickListener implements OnLongClickListener {
1248         final int index;
1249
1250         private TextViewLongClickListener(final int index) {
1251             this.index = index;
1252         }
1253
1254         @Override
1255         public boolean onLongClick(final View v) {
1256             final TextView textView = (TextView) v;
1257             final int start = textView.getSelectionStart();
1258             final int end = textView.getSelectionEnd();
1259             if (start >= 0 && end >= 0) {
1260                 selectedSpannableText = textView.getText().subSequence(start, end).toString();
1261                 selectedSpannableIndex = index;
1262             }
1263             return false;
1264         }
1265     }
1266
1267     final TextViewLongClickListener textViewLongClickListenerIndex0 = new TextViewLongClickListener(
1268             0);
1269
1270     final TextViewLongClickListener textViewLongClickListenerIndex1 = new TextViewLongClickListener(
1271             1);
1272
1273     // --------------------------------------------------------------------------
1274     // SearchText
1275     // --------------------------------------------------------------------------
1276
1277     void onSearchTextChange(final String text) {
1278         if ("thadolina".equals(text)) {
1279             final Dialog dialog = new Dialog(getListView().getContext());
1280             dialog.setContentView(R.layout.thadolina_dialog);
1281             dialog.setTitle("Ti amo, amore mio!");
1282             final ImageView imageView = (ImageView) dialog.findViewById(R.id.thadolina_image);
1283             imageView.setOnClickListener(new OnClickListener() {
1284                 @Override
1285                 public void onClick(View v) {
1286                     final Intent intent = new Intent(Intent.ACTION_VIEW);
1287                     intent.setData(Uri.parse("https://sites.google.com/site/cfoxroxvday/vday2012"));
1288                     startActivity(intent);
1289                 }
1290             });
1291             dialog.show();
1292         }
1293         if (dictRaf == null) {
1294             Log.d(LOG, "searchText changed during shutdown, doing nothing.");
1295             return;
1296         }
1297         if (!searchText.isFocused()) {
1298             Log.d(LOG, "searchText changed without focus, doing nothing.");
1299             return;
1300         }
1301         Log.d(LOG, "onSearchTextChange: " + text);
1302         if (currentSearchOperation != null) {
1303             Log.d(LOG, "Interrupting currentSearchOperation.");
1304             currentSearchOperation.interrupted.set(true);
1305         }
1306         currentSearchOperation = new SearchOperation(text, index);
1307         searchExecutor.execute(currentSearchOperation);
1308     }
1309
1310     private class SearchTextWatcher implements TextWatcher {
1311         public void afterTextChanged(final Editable searchTextEditable) {
1312             if (searchText.hasFocus()) {
1313                 Log.d(LOG, "Search text changed with focus: " + searchText.getText());
1314                 // If they were typing to cause the change, update the UI.
1315                 onSearchTextChange(searchText.getText().toString());
1316             }
1317         }
1318
1319         public void beforeTextChanged(CharSequence arg0, int arg1, int arg2, int arg3) {
1320         }
1321
1322         public void onTextChanged(CharSequence arg0, int arg1, int arg2, int arg3) {
1323         }
1324     }
1325
1326     // --------------------------------------------------------------------------
1327     // Filtered results.
1328     // --------------------------------------------------------------------------
1329
1330     boolean isFiltered() {
1331         return rowsToShow != null;
1332     }
1333
1334     void setFiltered(final SearchOperation searchOperation) {
1335         ((ImageButton) findViewById(R.id.UpButton)).setEnabled(false);
1336         ((ImageButton) findViewById(R.id.DownButton)).setEnabled(false);
1337         rowsToShow = searchOperation.multiWordSearchResult;
1338         setListAdapter(new IndexAdapter(index, rowsToShow, searchOperation.searchTokens));
1339     }
1340
1341     void clearFiltered() {
1342         ((ImageButton) findViewById(R.id.UpButton)).setEnabled(true);
1343         ((ImageButton) findViewById(R.id.DownButton)).setEnabled(true);
1344         setListAdapter(new IndexAdapter(index));
1345         rowsToShow = null;
1346     }
1347
1348 }