Пример #1
0
            public void OnCompleted(int task, int splitLineIndex, string pastedText, List <List <object> > tempLines, int curPos, long tempStartPos, long tempEndPos, bool isRemaining, List <Bookmark> foundBookmarks)
            {
                StringBuilder pinyin = new StringBuilder("");

                RemoteViews smallView = null;

                if (Build.VERSION.SdkInt < BuildVersionCodes.JellyBean)
                {
                    foreach (List <object> line in tempLines)
                    {
                        object lastWord = null;

                        foreach (object word in line)
                        {
                            if (lastWord != null && (lastWord is int? || lastWord.GetType() != word.GetType()))
                            {
                                pinyin.Append(" ");
                            }

                            if (word is string)
                            {
                                pinyin.Append((string)word);
                            }
                            else
                            {
                                pinyin.Append(Dict.PinyinToTones(Dict.GetPinyin((int)word)));
                            }

                            lastWord = word;
                        }
                    }

                    smallView = new RemoteViews(Service.PackageName, Resource.Layout.Notification_Small);
                    smallView.SetTextViewText(Resource.Id.notifsmall_text, pinyin);
                }
                else
                {
                    smallView = new RemoteViews(Service.PackageName, Resource.Layout.Notification_Big);
                }

                Service.dict = null;

                NotificationCompat.Builder mBuilder = (new NotificationCompat.Builder(Service.ApplicationContext))
                                                      .SetSmallIcon(Resource.Drawable.notification)
                                                      .SetContentTitle("ChineseReader")
                                                      .SetContentText(pinyin)
                                                      .SetContent(smallView)
                                                      .SetPriority(NotificationCompat.PriorityMax)
                                                      .SetVibrate(new long[0]);


                Intent resultIntent = new Intent(Service.Application, typeof(MainActivity));

                resultIntent.SetAction(Intent.ActionSend);
                resultIntent.SetType("text/plain");
                resultIntent.PutExtra(Intent.ExtraText, pastedText);

                // The stack builder object will contain an artificial back stack for the
                // started Activity.
                // This ensures that navigating backward from the Activity leads out of
                // your application to the Home screen.
                global::Android.Support.V4.App.TaskStackBuilder stackBuilder = global::Android.Support.V4.App.TaskStackBuilder.Create(Service.ApplicationContext);

                // Adds the back stack for the Intent (but not the Intent itself)
                stackBuilder.AddParentStack(Class.FromType(typeof(MainActivity)));

                // Adds the Intent that starts the Activity to the top of the stack
                stackBuilder.AddNextIntent(resultIntent);
                PendingIntent resultPendingIntent = stackBuilder.GetPendingIntent(0, (int)PendingIntentFlags.UpdateCurrent);

                mBuilder.SetContentIntent(resultPendingIntent);
                NotificationManager mNotificationManager = (NotificationManager)Service.GetSystemService(Context.NotificationService);

                mNotificationManager.CancelAll();

                // mId allows you to update the notification_big later on.
                Notification notif = mBuilder.Build();

                if (Build.VERSION.SdkInt >= BuildVersionCodes.JellyBean)
                {
                    LineView lv = new LineView(Service.context);
                    lv.line         = tempLines[0];
                    lv.lines        = tempLines;
                    lv.hlIndex      = new Point(-1, -1);
                    lv.top          = new List <string>();
                    lv.bottom       = new List <string>();
                    lv.tones        = new List <int>();
                    lv.charTypeface = Typeface.Default;

                    int wordHeight = (int)(lv.WordHeight);
                    int lineCount  = (int)System.Math.Min(tempLines.Count, System.Math.Floor(256 * lv.scale / wordHeight) + 1);
                    int width      = (int)System.Math.Round((double)AnnTask.screenWidth);
                    lv.Measure(width, wordHeight);
                    lv.Layout(0, 0, width, wordHeight);
                    Bitmap bitmap  = Bitmap.CreateBitmap(width, (int)System.Math.Min(System.Math.Max(64 * lv.scale, wordHeight * lineCount), 256 * lv.scale), Bitmap.Config.Argb8888);
                    Canvas canvas  = new Canvas(bitmap);
                    Paint  whiteBg = new Paint();
                    whiteBg.Color = Color.ParseColor("FFFFFFFF");
                    canvas.DrawRect(0, 0, canvas.Width, canvas.Height, whiteBg);

                    for (int i = 0; i < lineCount; i++)
                    {
                        lv.lines = tempLines;
                        lv.line  = tempLines[i];
                        lv.bottom.Clear();
                        lv.top.Clear();
                        lv.tones.Clear();
                        int count = lv.lines[i].Count;

                        if (count == 0 || lv.line[count - 1] is string && ((string)lv.line[count - 1]).Length == 0 || tempEndPos >= pastedText.Length && i == tempLines.Count - 1)
                        {
                            lv.lastLine = true;
                        }
                        else
                        {
                            lv.lastLine = false;
                        }

                        for (int j = 0; j < count; j++)
                        {
                            object word = lv.lines[i][j];

                            if (word is string)
                            {
                                lv.bottom.Add((string)word);
                                lv.top.Add("");
                                lv.tones.Add(0);
                            }
                            else
                            {
                                int    entry = (int)word;
                                string key   = Dict.GetCh(entry);
                                lv.bottom.Add(key);
                                if (Service.sharedPrefs.GetString("pref_pinyinType", "marks").Equals("none"))
                                {
                                    lv.top.Add("");
                                }
                                else
                                {
                                    lv.top.Add(Dict.PinyinToTones(Dict.GetPinyin(entry)));
                                }

                                if (Service.sharedPrefs.GetString("pref_toneColors", "none").Equals("none"))
                                {
                                    lv.tones.Add(0);
                                }
                                else
                                {
                                    int tones        = int.Parse(Regex.Replace(Dict.GetPinyin(entry), @"[\\D]", ""));
                                    int reverseTones = 0;
                                    while (tones != 0)
                                    {
                                        reverseTones = reverseTones * 10 + tones % 10;
                                        tones        = tones / 10;
                                    }
                                    lv.tones.Add(reverseTones);
                                }
                            }
                        }

                        lv.Draw(canvas);
                        canvas.Translate(0, wordHeight);
                    }

                    RemoteViews bigView = new RemoteViews(Service.PackageName, Resource.Layout.Notification_Big);
                    bigView.SetImageViewBitmap(Resource.Id.notif_img, bitmap);
                    smallView.SetImageViewBitmap(Resource.Id.notif_img, Bitmap.CreateBitmap(bitmap, 0, 0, bitmap.Width, (int)(64 * lv.scale)));
                    notif.BigContentView = bigView;
                }

                mNotificationManager.Notify(NOTIFICATION_ID, notif);
            }
        public static List <object> BreakWord(string theText)
        {
            int           textLen = theText.Length, curPos = 0, last;
            List <object> words = new List <object>();

            while (curPos < textLen)
            {
                int i = Math.Min(textLen - curPos - 1, 3);

                if (curPos == 0)
                {
                    i = Math.Min(textLen - curPos - 2, 3);
                }

                last = -1;
                for (; i >= 0; i--)
                {
                    if (i == 3 && curPos > 0)
                    {
                        last = Dict.BinarySearch(theText.SubstringSpecial(curPos, curPos + i + 1), true);
                    }
                    else
                    {
                        if (last >= 0)
                        {
                            last = Dict.BinarySearch(theText.SubstringSpecial(curPos, curPos + i + 1), 0, last - 1, false);
                        }
                        else
                        {
                            last = Dict.BinarySearch(theText.SubstringSpecial(curPos, curPos + i + 1), false);
                        }
                    }

                    if (last >= 0)
                    {
                        if (i == 3)
                        {     //the found entry may be longer than 4 (3 + 1)
                            if (Dict.GetLength(last) > textLen - curPos)
                            { //the found may be longer than the ending
                                continue;
                            }
                            string word = theText.SubstringSpecial(curPos, curPos + Dict.GetLength(last));
                            if (Dict.Equals(last, word))
                            {
                                words.Add(last);
                                curPos += word.Length;
                                break;
                            }
                        }
                        else
                        {
                            words.Add(last);
                            curPos += i + 1;
                            break;
                        }
                    }
                }

                if (i == -1 && last < 0)
                {
                    words.Add(theText.SubstringSpecial(curPos, curPos + 1));
                    curPos++;
                }
            }

            return(words);
        }
        public virtual void show(View anchor, List <object> line, int wordNum, int showX, bool redraw)
        {
            try
            {
                this.showX = showX;

                if (redraw)
                {
                    this.dismiss();
                }

                if (line != null)
                {
                    this.line                 = line;
                    this.wordIndex            = wordNum;
                    this.entry                = (int)line[wordNum];
                    splitButton.Visibility    = ViewStates.Visible;
                    bookmarkButton.Visibility = ViewStates.Visible;
                }
                else
                {
                    this.entry                = wordNum;
                    splitButton.Visibility    = ViewStates.Gone;
                    bookmarkButton.Visibility = ViewStates.Gone;
                }

                string sTrad = Dict.GetCh(entry, "traditional");
                string sSimp = Dict.GetCh(entry, "simplified");

                SpannableStringBuilder text = new SpannableStringBuilder();

                if (sSimp.Length > 1)
                {
                    List <object> subWords = BreakWord(sSimp);
                    foreach (object word in subWords)
                    {
                        if (word is int)
                        { //was found
                            string ch = Dict.GetCh((int)word, "simplified");
                            text.Append(ch).Append(new Java.Lang.String(" "));
                            WordSpan clickable = new WordSpan(this);
                            clickable.link = ch;
                            text.SetSpan(clickable, text.Length() - ch.Length - 1, text.Length() - 1, SpanTypes.User);
                        }
                        else
                        {
                            text.Append((string)word).Append(new Java.Lang.String(" "));
                        }
                    }
                }
                else
                {
                    text.Append(sSimp).Append(new Java.Lang.String(" "));
                    text.SetSpan(new AbsoluteSizeSpan(24, true), text.Length() - sSimp.Length - 1, text.Length() - 1, SpanTypes.User);
                    splitButton.Visibility = ViewStates.Gone;
                }

                if (!sTrad.Equals(sSimp))
                {
                    text.Append(sTrad);
                }

                mChars.SetText(text, TextView.BufferType.Spannable);

                text.Clear();
                string pinyin = Dict.PinyinToTones(Dict.GetPinyin(entry));
                text.Append("[ ").Append(new Java.Lang.String(pinyin)).Append(new Java.Lang.String(" ]  "));

                appendInlineButtons(text, pinyin);

                text.Append("\n");

                string[] parts = Regex.Split(Regex.Replace(Dict.GetEnglish(entry), @"/", "\n• "), @"\\$");

                int i = 0;
                foreach (string s in parts)
                {
                    if (i++ % 2 == 1)
                    {
                        pinyin = Dict.PinyinToTones(s);
                        text.Append("\n\n[ ").Append(new Java.Lang.String(pinyin)).Append(new Java.Lang.String(" ]  "));
                        appendInlineButtons(text, pinyin);
                        text.Append("\n");
                    }
                    else
                    {
                        text.Append("• ");

                        int beforeAppended = text.Length();

                        int bracketIndex, bracketEnd = 0;
                        while ((bracketIndex = s.IndexOf("[", bracketEnd, StringComparison.Ordinal)) > -1)
                        {
                            text.Append(s, bracketEnd, bracketIndex);
                            bracketEnd = s.IndexOf("]", bracketIndex);
                            text.Append(Dict.PinyinToTones(s.SubstringSpecial(bracketIndex, bracketEnd)));
                        }

                        text.Append(s, bracketEnd, s.Length);

                        int afterAppended = text.Length();

                        for (int m = beforeAppended; m < afterAppended; m++)
                        {
                            if (text.CharAt(m) >= '\u25CB' && text.CharAt(m) <= '\u9FA5')
                            {
                                int n = m + 1;
                                while (n < text.Length() && text.CharAt(n) >= '\u25CB' && text.CharAt(n) <= '\u9FA5')
                                {
                                    n++;
                                }

                                WordSpan clickable = new WordSpan(this);
                                clickable.link = text.SubSequence(m, n - m).ToString();
                                text.SetSpan(clickable, m, n, SpanTypes.User);
                            }
                        }
                    }
                }

                mContent.SetText(text, TextView.BufferType.Spannable);

                LinearLayout bookmarkTitleLayout = (LinearLayout)mRootView.FindViewById(Resource.Id.bookmark);
                if (mContext.annoMode != AnnotationActivity.ANNOTATE_FILE)
                {
                    bookmarkButton.Visibility      = ViewStates.Gone;
                    bookmarkTitleLayout.Visibility = ViewStates.Gone;
                }
                else
                {
                    int  lineNum      = mContext.lines.IndexOf(line);
                    long bookmarkPos  = mContext.GetPosition(mContext.lines, lineNum + 1, wordIndex, true);
                    int  bookmarksPos = Bookmark.SearchClosest(bookmarkPos, mContext.mBookmarks);
                    bool isBookmarked = mContext.mBookmarks.Count > bookmarksPos && mContext.mBookmarks[bookmarksPos].mPosition == bookmarkPos;

                    ToggleBookmark(bookmarkButton, isBookmarked);

                    if (isBookmarked)
                    {
                        bookmarkTitleLayout.Visibility = ViewStates.Visible;
                        ((TextView)mRootView.FindViewById(Resource.Id.bookmarkTitle)).Text = mContext.mBookmarks[bookmarksPos].mTitle;
                    }
                    else
                    {
                        bookmarkTitleLayout.Visibility = ViewStates.Gone;
                    }
                }

                ToggleStar(null, AnnotationActivity.sharedPrefs.GetString("stars", "").StartsWith(Dict.GetCh(entry, "simplified") + "\n") || AnnotationActivity.sharedPrefs.GetString("stars", "").Contains("\n" + Dict.GetCh(entry, "simplified") + "\n"));

                this.parent = anchor;

                float xPos = 0, yPos = 0, arrowPos;

                int[] location = new int[2];

                anchor.GetLocationOnScreen(location);

                Rect anchorRect = new Rect(location[0], location[1], location[0] + anchor.Width, location[1] + anchor.Height);

                if (redraw)
                {
                    mWindow.ShowAtLocation(anchor, GravityFlags.NoGravity, 0, 0);
                }
                mBubble.Measure(ViewGroup.LayoutParams.WrapContent, ViewGroup.LayoutParams.WrapContent);

                float rootHeight = mBubble.MeasuredHeight;
                float rootWidth  = mBubble.MeasuredWidth;

                xPos = showX - (rootWidth / 2);

                if ((xPos + rootWidth) > screenX)
                {
                    xPos = screenX - rootWidth;
                }
                else if (xPos < 0)
                {
                    xPos = 0;
                }

                arrowPos = showX - xPos;

                float dyTop    = anchorRect.Top - 60 * scale;
                float dyBottom = screenY - anchorRect.Bottom - 20 * scale;

                bool onTop = dyBottom <rootHeight && dyTop> dyBottom;

                if (onTop)
                {
                    if (rootHeight + 20 * scale > dyTop)
                    {
                        yPos       = 60 * scale;
                        rootHeight = anchorRect.Top - yPos - 20 * scale;
                    }
                    else
                    {
                        yPos = anchorRect.Top - rootHeight - 20 * scale;
                    }
                }
                else
                {
                    yPos = anchorRect.Bottom;

                    if (rootHeight > dyBottom)
                    {
                        rootHeight = dyBottom;
                    }
                }

                showArrow((onTop ? Resource.Id.arrow_down : Resource.Id.arrow_up), arrowPos, rootWidth);

                mWindow.Update((int)Math.Round(xPos), (int)Math.Round(yPos), (int)Math.Round(rootWidth), (int)Math.Round(rootHeight + 21 * scale));
                mScroll.FullScroll(FocusSearchDirection.Up);
            }
            catch (Exception e)
            {
                Toast.MakeText(mContext, "Error: " + e.Message, ToastLength.Long).Show();
            }
        }
        private void BookmarkButton_Click(object sender, EventArgs e)
        {
            int  lineNum      = mContext.lines.IndexOf(line);
            long bookmarkPos  = mContext.GetPosition(mContext.lines, lineNum + 1, wordIndex, true);
            int  bookmarksPos = Bookmark.SearchClosest(bookmarkPos, mContext.mBookmarks);

            if (mContext.mBookmarks.Count > bookmarksPos && mContext.mBookmarks[bookmarksPos].mPosition == bookmarkPos)
            {
                mContext.mBookmarks.RemoveAt(bookmarksPos);
                if (!Bookmark.SaveToFile(mContext.mBookmarks, mContext.curFilePath + ".bookmarks"))
                {
                    Toast.MakeText(mContext, "Bookmarks could not be stored. File location is not writable.", ToastLength.Long).Show();
                }

                int foundBookmarksPos = Bookmark.SearchClosest(bookmarkPos, mContext.mFoundBookmarks);
                if (mContext.mFoundBookmarks.Count > foundBookmarksPos && mContext.mFoundBookmarks[foundBookmarksPos].mPosition == bookmarkPos)
                {
                    mContext.mFoundBookmarks.RemoveAt(foundBookmarksPos);
                }

                mContext.linesAdapter.NotifyItemChanged(lineNum + 1);
                show(mContext.linesLayoutManager.FindViewByPosition(lineNum + 1), line, wordIndex, showX, false);
            }
            else
            {
                AlertDialog.Builder builder = new AlertDialog.Builder(mContext);
                builder.SetTitle("New bookmark");
                EditText inputBookmark = new EditText(mContext);
                inputBookmark.InputType = InputTypes.TextFlagCapSentences;
                inputBookmark.Text      = Dict.PinyinToTones(Dict.GetPinyin(entry));
                inputBookmark.SelectAll();
                builder.SetView(inputBookmark);
                builder.SetCancelable(true);
                builder.SetPositiveButton("OK", delegate
                {
                    try
                    {
                        int lineNum1           = mContext.lines.IndexOf(line);
                        long bookmarkPos1      = mContext.GetPosition(mContext.lines, lineNum1 + 1, wordIndex, true);
                        int bookmarksPos1      = Bookmark.SearchClosest(bookmarkPos1, mContext.mBookmarks);
                        int foundBookmarksPos1 = Bookmark.SearchClosest(bookmarkPos1, mContext.mFoundBookmarks);

                        Bookmark newBookmark = new Bookmark(bookmarkPos1, inputBookmark.Text.ToString());
                        newBookmark.SetAnnotatedPosition(lineNum1, wordIndex);
                        mContext.mFoundBookmarks.Insert(foundBookmarksPos1, newBookmark);
                        mContext.mBookmarks.Insert(bookmarksPos1, newBookmark);

                        if (!Bookmark.SaveToFile(mContext.mBookmarks, mContext.curFilePath + ".bookmarks"))
                        {
                            Toast.MakeText(mContext, "Bookmarks could not be stored. File location is not writable.", ToastLength.Long).Show();
                        }

                        mContext.linesAdapter.NotifyItemChanged(lineNum1 + 1);
                        show(mContext.linesLayoutManager.FindViewByPosition(lineNum1 + 1), line, wordIndex, showX, false);
                    }
                    catch (FormatException)
                    {
                        Toast.MakeText(mContext, "", ToastLength.Long).Show();
                    }
                });
                builder.SetNegativeButton("Cancel", delegate
                {
                });
                AlertDialog dialog = builder.Create();
                dialog.Window.SetSoftInputMode(SoftInput.StateVisible);

                dialog.Show();
            }
        }
        private void SplitButton_Click(object sender, EventArgs e)
        {
            WordPopup view = sender as WordPopup;

            view.dismiss();

            List <object> subWords  = BreakWord(Dict.GetCh(entry));
            int           lineIndex = mContext.lines.IndexOf(line);

            mContext.linesAdapter.NotifyDataSetChanged();

            object firstWord = subWords[0];

            if (mContext.annoMode == AnnotationActivity.ANNOTATE_FILE)
            {
                mContext.curPos = 0;
                mContext.endPos = mContext.GetPosition(mContext.lines, lineIndex + 1, wordIndex, true) + (firstWord is int?Dict.GetLength((int)firstWord) : ((string)firstWord).Length) * 3;
            }
            else
            {
                mContext.endPos = (int)mContext.GetPosition(mContext.lines, lineIndex + 1, wordIndex, false) + (firstWord is int?Dict.GetLength((int)firstWord) : ((string)firstWord).Length);
            }

            List <object> curLine  = (List <object>)line;
            int           toRemove = curLine.Count - wordIndex;

            while (toRemove-- > 0)
            {
                curLine.RemoveAt(wordIndex);
            }
            curLine.Add(subWords[0]);

            int curWidth = 5;

            foreach (object word in curLine)
            {
                curWidth += mContext.testView.GetWordWidth((string)word);
            }

            mContext.SplitAnnotation(lineIndex, curWidth, curLine);
        }
Пример #6
0
        protected override void OnCreate(Bundle savedInstanceState)
        {
            base.OnCreate(savedInstanceState);

            System.Console.WriteLine("MainActivity >> OnCreate");

            try
            {
                PackageInfo pInfo  = PackageManager.GetPackageInfo(PackageName, 0);
                int         oldVer = sharedPrefs.GetInt("version", 0);
                if (oldVer != pInfo.VersionCode)
                {
                    string stars = sharedPrefs.GetString("stars", "");
                    stars = stars.Replace(" ", "");
                    if (stars.EndsWith(";"))
                    {
                        stars = stars.Substring(1).Replace(";", @"\n");
                    }

                    sharedPrefs.Edit().PutString("stars", stars).Commit();

                    (new File(FilesDir, "dict.db")).Delete();
                    (new File(FilesDir, "idx.db")).Delete();
                    (new File(FilesDir, "entries.bin")).Delete();
                    (new File(FilesDir, "parts.bin")).Delete();
                    new File(global::Android.OS.Environment.ExternalStorageDirectory + "/ChineseReader/").Mkdir();
                    sharedPrefs.Edit().PutInt("version", pInfo.VersionCode).Commit();
                }
                if (oldVer <= 110)
                {
                    ActivityCompat.RequestPermissions(this, new string[] { Manifest.Permission.WriteExternalStorage }, REQUEST_STORAGE_FOR_BOOK);
                }
                if (0 < oldVer && oldVer <= 370)
                {
                    string prefTextSize = sharedPrefs.GetString("pref_textSize", "medium");
                    int    textSizeInt  = 16;
                    if (prefTextSize.Equals("small"))
                    {
                        textSizeInt = 13;
                    }
                    if (prefTextSize.Equals("medium"))
                    {
                        textSizeInt = 16;
                    }
                    if (prefTextSize.Equals("large"))
                    {
                        textSizeInt = 19;
                    }
                    if (prefTextSize.Equals("extra"))
                    {
                        textSizeInt = 23;
                    }

                    string prefPinyinSize = sharedPrefs.GetString("pref_pinyinSize", "medium");
                    int    pinyinSizeInt  = 100;
                    if (prefPinyinSize.Equals("small"))
                    {
                        pinyinSizeInt = 13 * 100 / textSizeInt;
                    }
                    if (prefPinyinSize.Equals("medium"))
                    {
                        pinyinSizeInt = 16 * 100 / textSizeInt;
                    }
                    if (prefPinyinSize.Equals("large"))
                    {
                        pinyinSizeInt = 19 * 100 / textSizeInt;
                    }
                    if (prefPinyinSize.Equals("extra"))
                    {
                        pinyinSizeInt = 23 * 100 / textSizeInt;
                    }

                    sharedPrefs.Edit().PutInt("pref_textSizeInt", textSizeInt).PutInt("pref_pinyinSizeInt", pinyinSizeInt).Commit();
                }

                Dict.LoadDict(this.Application);

                pastedText = GetBufText(this);
                textLen    = pastedText.Length;
                if (isFirstAnnotation)
                {
                    string lastFile = sharedPrefs.GetString("lastFile", "");
                    if (lastFile.Length > 0 && sharedPrefs.GetString("lastText", "").Equals(pastedText))
                    {
                        Annotate(lastFile);
                        return;
                    }
                }

                Title = "Chinese Reader";

                if (!CheckIsShared())
                {
                    if (textLen == 0)
                    {
                        Toast.MakeText(this.Application, GetString(Resource.String.msg_empty), ToastLength.Long).Show();
                    }
                    else
                    {
                        annoMode = ANNOTATE_BUFFER;
                        Annotate(-1);
                    }
                }
            }
            catch (Exception e)
            {
                Toast.MakeText(this, "Error: " + e.Message, ToastLength.Long).Show();
            }
        }
Пример #7
0
        public override void OnBindViewHolder(RecyclerView.ViewHolder holder, int position)
        {
            if (holder is LineViewHolder)
            {
                List <object> line = mLines[position - 1];

                LineView curView = ((LineViewHolder)holder).mLineView;
                curView.line    = line;
                curView.lines   = mLines;
                curView.hlIndex = context.hlIndex;
                curView.bookmarks.Clear();

                if (context.mFoundBookmarks.Count > 0)
                {
                    for (int i = 0; i < line.Count; i++)
                    {
                        Bookmark itsBookmark = Bookmark.SearchAnnotated(position - 1, i, context.mFoundBookmarks);
                        if (itsBookmark != null)
                        {
                            curView.bookmarks.Add(itsBookmark);
                        }
                        else
                        {
                            curView.bookmarks.Add(null);
                        }
                    }
                }

                if (curView.top == null)
                {
                    curView.top = new List <string>();
                }
                else
                {
                    curView.top.Clear();
                }

                if (curView.bottom == null)
                {
                    curView.bottom = new List <string>();
                }
                else
                {
                    curView.bottom.Clear();
                }

                if (curView.tones == null)
                {
                    curView.tones = new List <int>();
                }
                else
                {
                    curView.tones.Clear();
                }

                int count = line.Count;
                for (int i = 0; i < count; i++)
                {
                    var word = line[i];

                    if (word is string)
                    {
                        curView.bottom.Add((string)word);
                        curView.top.Add("");
                        curView.tones.Add(0);
                    }
                    else
                    {
                        int    entry = (int)word;
                        string key   = Dict.GetCh(entry);
                        curView.bottom.Add(key);
                        if (AnnotationActivity.sharedPrefs.GetString("pref_pinyinType", "marks").Equals("none"))
                        {
                            curView.top.Add("");
                        }
                        else
                        {
                            curView.top.Add(Dict.PinyinToTones(Dict.GetPinyin(entry)));
                        }

                        if (AnnotationActivity.sharedPrefs.GetString("pref_toneColors", "none").Equals("none"))
                        {
                            curView.tones.Add(0);
                        }
                        else
                        {
                            int tones        = int.Parse(Regex.Replace(Dict.GetPinyin(entry), @"[\d]", ""));
                            int reverseTones = 0;
                            while (tones != 0)
                            {
                                reverseTones = reverseTones * 10 + tones % 10;
                                tones        = tones / 10;
                            }
                            curView.tones.Add(reverseTones);
                        }
                    }
                }

                if (count == 0 || line[count - 1] is string && ((string)line[count - 1]).Length == 0 || context.endPos >= context.textLen && position - 1 == ItemCount - 3)
                {
                    curView.lastLine = true;
                }
                else
                {
                    curView.lastLine = false;
                }

                curView.UpdateVars();
            }
            else
            {
                if (position == 0 && ShowHeader || position == mLines.Count + 1 && ShowFooter)
                {
                    ((ProgressViewHolder)holder).progressBar.Visibility = ViewStates.Visible;
                }
                else
                {
                    ((ProgressViewHolder)holder).progressBar.Visibility = ViewStates.Gone;
                }
            }
        }
Пример #8
0
            public void OnCompleted(int task, int splitLineIndex, string pastedText, List <List <object> > tempLines, int curPos, long tempStartPos, long tempEndPos, bool isRemaining, List <Bookmark> foundBookmarks)
            {
                try
                {
                    StringBuilder textLine = new StringBuilder();

                    foreach (List <object> line in tempLines)
                    {
                        object lastWord = null;

                        textLine.Length = 0;
                        foreach (object word in line)
                        {
                            if (lastWord != null && word is int)
                            {
                                dumpFileWriter.BaseStream.WriteByte(Convert.ToByte(@"\t"));
                                textLine.Append(@"\t");
                            }

                            if (word is string)
                            {
                                if (((string)word).Length != 0)
                                {
                                    textLine.Append(Regex.Replace((string)word, @"\t", ""));
                                }
                            }
                            else
                            {
                                dumpFileWriter.BaseStream.WriteByte(Convert.ToByte(Dict.PinyinToTones(Dict.GetPinyin((int)word))));
                                textLine.Append(Dict.GetCh((int)word));
                            }

                            if (lastWord != null || !(word is string))
                            {
                                lastWord = word;
                            }
                        }

                        dumpFileWriter.BaseStream.WriteByte(Convert.ToByte(@"\n\r"));
                        dumpFileWriter.BaseStream.WriteByte(Convert.ToByte(textLine.ToString()));
                        dumpFileWriter.BaseStream.WriteByte(Convert.ToByte(@"\n\r"));
                    }

                    if (isRemaining && !dumpCancelled)
                    {
                        int progress = (int)Math.Round((double)tempEndPos * 100 / Activity.textLen);
                        dumpProgress.Progress = progress;
                        dumpProgressText.Text = Convert.ToString(progress) + "%";
                        Activity.DumpBoth(tempStartPos, tempEndPos);
                    }
                    else
                    {
                        dumpFileWriter.Flush();
                        dumpFileWriter.Close();

                        dumpStartButton.Enabled     = true;
                        dumpProgress.Visibility     = ViewStates.Gone;
                        dumpProgressText.Visibility = ViewStates.Gone;
                        Toast.MakeText(Activity.Application, "Saved to " + dumpFilePath, ToastLength.Long).Show();
                    }
                }
                catch (Exception e)
                {
                    Toast.MakeText(Activity.Application, e.Message, ToastLength.Long).Show();
                }
            }
Пример #9
0
        public long GetPosition(List <List <object> > list, int lineNum, int wordNum, bool isFile)
        {
            long pos = startPos;

            for (int i = 0; i < lineNum; i++)
            {
                List <object> row = list[i];
                int           len = row.Count;

                if (i == lineNum - 1 && wordNum > -1)
                {
                    len = wordNum;
                }

                for (int j = 0; j < len; j++)
                {
                    object word = row[j];

                    if (word is string)
                    {
                        try
                        {
                            int wordLen;
                            if (isFile)
                            {
                                wordLen = Encoding.UTF8.GetBytes((string)word).Length;
                            }
                            else
                            {
                                wordLen = ((string)word).Length;
                            }

                            if (wordLen == 0)
                            {
                                pos += 1;
                            }
                            else
                            {
                                pos += wordLen;
                            }
                        }
                        catch (Exception e)
                        {
                            Toast.MakeText(this.Application, e.Message, ToastLength.Long).Show();
                        }
                    }
                    else
                    {
                        if (isFile)
                        {
                            pos += Dict.GetLength((int)word) * 3;
                        }
                        else
                        {
                            pos += Dict.GetLength((int)word);
                        }
                    }
                }
            }

            return(pos);
        }
Пример #10
0
            public void OnCompleted(int task, int splitLineIndex, string pastedText, List <List <object> > tempLines, int curPos, long tempStartPos, long tempEndPos, bool isRemaining, List <Bookmark> foundBookmarks)
            {
                System.Console.WriteLine("UpdateLinesAnnTask => OnCompleted()");

                if (Activity.curSaveName.Equals("") && Activity.curPos == 0)
                {
                    //System.Console.WriteLine("UpdateLinesAnnTask => Step 1");

                    StringBuilder fName = new StringBuilder();
                    int           p = 0, r = 0;
                    while (fName.Length < 16 && r < tempLines.Count && (p < tempLines[r].Count || r < tempLines.Count - 1))
                    {
                        var word = tempLines.ElementAt(r).ElementAt(p);
                        if (word is int)
                        {
                            System.Console.WriteLine("UpdateLinesAnnTask => IS INT");

                            if (fName.Length > 0)
                            {
                                fName.Append("-");
                            }
                            fName.Append(Regex.Replace(Dict.GetPinyin((int)word), @"[^a-zA-Z]+", ""));
                        }
                        else
                        {
                            System.Console.WriteLine("UpdateLinesAnnTask => IS STRING");

                            System.Console.WriteLine("word => " + (string)word);

                            string s = Regex.Replace((string)word, @"[^a-zA-Z0-9]+", "");
                            fName.Append(s.Substring(0, Math.Min(s.Length, 16)));
                        }
                        if (++p == tempLines[r].Count)
                        {
                            p = 0;
                            r++;
                        }
                    }

                    Activity.curSaveName = fName.ToString();
                }

                Activity.curPos = curPos;

                Activity.linesRecyclerView.SetItemAnimator(Activity.defaultItemAnimator);

                switch (task)
                {
                case AnnTask.TASK_ANNOTATE:
                case AnnTask.TASK_SPLIT:

                    if (isRemaining)
                    {
                        Activity.linesAdapter.ShowFooter = true;
                    }
                    else
                    {
                        Activity.linesAdapter.ShowFooter = false;
                    }

                    int  firstVisiblePosition = Activity.linesLayoutManager.FindFirstVisibleItemPosition();
                    View firstVisible         = Activity.linesLayoutManager.FindViewByPosition(firstVisiblePosition);
                    int  top = firstVisible != null ? firstVisible.Top : 0;

                    if (task == AnnTask.TASK_SPLIT)
                    {
                        Activity.linesRecyclerView.SetItemAnimator(null);
                        int toRemove = Activity.lines.Count - splitLineIndex;
                        while (toRemove-- > 0)
                        {
                            Activity.lines.RemoveAt(splitLineIndex);
                            Activity.linesAdapter.NotifyItemRemoved(splitLineIndex + 1);
                        }

                        if (Activity.annoMode == ANNOTATE_FILE && Activity.mBookmarks.Count > 0)
                        {
                            int bookmarksRemoveFrom = Bookmark.SearchClosest(Activity.endPos, Activity.mFoundBookmarks);
                            while (Activity.mFoundBookmarks.Count > bookmarksRemoveFrom)
                            {
                                Activity.mFoundBookmarks.RemoveAt(bookmarksRemoveFrom);
                            }
                        }
                    }

                    int rmCount = -1;
                    if (Activity.annoMode == ANNOTATE_FILE && !Activity.isFirstFileAnnotation && firstVisiblePosition > AnnTask.visibleLines)
                    {
                        rmCount      = firstVisiblePosition - AnnTask.visibleLines;
                        tempStartPos = Activity.GetPosition(Activity.lines, rmCount + 1, 0, true);
                        for (int i = 0; i < rmCount; i++)
                        {
                            Activity.lines.RemoveAt(0);
                            Activity.linesAdapter.NotifyItemRemoved(1);
                        }
                        int bookmarksRemoveUntil = Bookmark.SearchClosest(tempStartPos, Activity.mFoundBookmarks);
                        for (int i = 0; i < bookmarksRemoveUntil; i++)
                        {
                            Activity.mFoundBookmarks.RemoveAt(0);
                        }
                        for (int i = 0; i < Activity.mFoundBookmarks.Count; i++)
                        {
                            Activity.mFoundBookmarks[i].mLine -= rmCount;
                        }
                    }

                    for (int i = 0; i < foundBookmarks.Count; i++)
                    {
                        foundBookmarks[i].mLine += Activity.lines.Count;
                    }
                    Activity.mFoundBookmarks.AddRange(foundBookmarks);

                    Activity.lines.AddRange(tempLines);
                    Activity.linesAdapter.NotifyItemRangeInserted(Activity.lines.Count - tempLines.Count + 1, tempLines.Count);

                    if (tempStartPos > 0)
                    {
                        Activity.linesAdapter.ShowHeader = true;
                        if (Activity.isFirstFileAnnotation)
                        {
                            Activity.linesLayoutManager.ScrollToPositionWithOffset(1, 0);
                        }
                    }
                    else
                    {
                        Activity.linesAdapter.ShowHeader = false;
                    }

                    if (rmCount > -1)
                    {
                        Activity.linesLayoutManager.ScrollToPositionWithOffset(AnnTask.visibleLines, top);
                    }

                    tempLines.Clear();

                    break;

                case AnnTask.TASK_ANNOTATE_BACK:
                    int remainCount = Activity.linesLayoutManager.FindFirstVisibleItemPosition() + AnnTask.visibleLines * 2;
                    if (Activity.lines.Count > remainCount)
                    {
                        rmCount = Activity.lines.Count - remainCount;
                        for (int i = 0; i < rmCount; i++)
                        {
                            List <object> rmLine = Activity.lines[remainCount];
                            Activity.lines.RemoveAt(remainCount);
                            Activity.linesAdapter.NotifyItemRemoved(remainCount + 1);
                            tempEndPos -= LineView.GetLineSize(rmLine, Activity.annoMode == ANNOTATE_FILE);
                        }

                        if (Activity.annoMode == ANNOTATE_FILE && Activity.mFoundBookmarks.Count > 0)
                        {
                            int bookmarksRemoveFrom = Bookmark.SearchClosest(tempEndPos, Activity.mFoundBookmarks);
                            while (Activity.mFoundBookmarks.Count > bookmarksRemoveFrom)
                            {
                                Activity.mFoundBookmarks.RemoveAt(bookmarksRemoveFrom);
                            }
                        }
                    }

                    firstVisiblePosition = Activity.linesLayoutManager.FindFirstVisibleItemPosition();
                    int newFirstVisiblePosition = firstVisiblePosition + tempLines.Count;
                    top = Activity.linesLayoutManager.FindViewByPosition(firstVisiblePosition).Top + Activity.linesLayoutManager.FindViewByPosition(firstVisiblePosition).Height - Activity.linesLayoutManager.FindViewByPosition(firstVisiblePosition + 1).Height;
                    if (tempStartPos == 0)
                    {
                        Activity.linesAdapter.ShowHeader = false;
                    }

                    for (int i = 0; i < Activity.mFoundBookmarks.Count; i++)
                    {
                        Activity.mFoundBookmarks[i].mLine += tempLines.Count;
                    }
                    Activity.mFoundBookmarks.InsertRange(0, foundBookmarks);

                    Activity.lines.InsertRange(0, tempLines);
                    Activity.linesAdapter.NotifyItemRangeInserted(1, tempLines.Count);
                    Activity.linesLayoutManager.ScrollToPositionWithOffset(newFirstVisiblePosition, top);

                    tempLines.Clear();

                    break;
                }

                Activity.isFirstAnnotation     = false;
                Activity.isFirstFileAnnotation = false;

                Activity.startPos = tempStartPos;
                Activity.endPos   = tempEndPos;

                if (Activity.settingsChanged)
                {
                    Activity.Redraw();
                }

                //update header and footer
                Activity.linesAdapter.NotifyItemChanged(0);
                Activity.linesAdapter.NotifyItemChanged(Activity.linesAdapter.ItemCount - 1);
            }
Пример #11
0
        private Task <object> CreateTask()
        {
            CancelToken = new CancellationTokenSource();
            var t = new Task <object>(() =>
            {
                try
                {
                    //System.Console.WriteLine("STEP 1");

                    switch (task)
                    {
                    case TASK_SPLIT:
                        curPos   = 0;
                        BufText  = "";
                        bufLen   = 0;
                        notFound = 0;
                        break;

                    case TASK_ANNOTATE:
                    case TASK_ANNOTATE_BACK:
                        curPos   = 0;
                        BufText  = "";
                        bufLen   = 0;
                        curLine  = new List <object>();
                        hMargin  = TestView != null ? TestView.hMargin : 0;
                        curWidth = hMargin;
                        notFound = 0;
                        break;
                    }

                    tempEndPos     = endPos;
                    tempStartPos   = startPos;
                    mHopelessBreak = false;
                    //System.Console.WriteLine("STEP 2");

                    while ((task == TASK_ANNOTATE || task == TASK_SPLIT) && (curPos < bufLen || curPos == bufLen && tempEndPos < textLen) && (tempLines.Count < visibleLines * 2 || (!Formatting && tempEndPos - endPos < 500)) || task == TASK_ANNOTATE_BACK && (curPos < bufLen || curPos == bufLen && tempStartPos > 0))
                    {
                        //System.Console.WriteLine("STEP 3");

                        if ((task == TASK_ANNOTATE || task == TASK_SPLIT) && bufLen - curPos < 18 && tempEndPos < textLen)
                        {
                            if (notFound > 0)
                            {
                                curLine  = AddNotFound(notFound, curLine);
                                notFound = 0;
                            }
                            BufText = NextBuffer;
                            bufLen  = BufText.Length;
                        }
                        else if (task == TASK_ANNOTATE_BACK && curPos == bufLen)
                        {
                            if (notFound > 0)
                            {
                                curLine  = AddNotFound(notFound, curLine);
                                notFound = 0;
                            }
                            if (curLine.Count > 0)
                            {
                                tempLines.Add(curLine);
                                curLine = new List <object>();
                            }
                            tempBackLines.InsertRange(0, tempLines);
                            tempLines.Clear();
                            if (tempBackLines.Count < visibleLines * 2)
                            {
                                BufText = PrevBuffer;
                                bufLen  = BufText.Length;
                            }
                            else
                            {
                                break;
                            }
                        }
                        //System.Console.WriteLine("STEP 4");

                        if (BufText[curPos] < '\u25CB' || BufText[curPos] > '\u9FA5')
                        {
                            if (CheckCancelled())
                            {
                                //return (-1);
                                return(null);
                            }

                            notFound++;

                            if (BufText[curPos] == ' ' && notFound > 1)
                            {
                                curPos++;
                                curLine  = AddNotFound(notFound, curLine);
                                notFound = 0;

                                if (curFilePos != -1)
                                {
                                    curFilePos++;
                                }

                                continue;
                            }

                            if (notFound > perLine * visibleLines * 2 && task == TASK_ANNOTATE)
                            {
                                notFound--;
                                break;
                            }

                            if (curFilePos != -1)
                            {
                                curFilePos += Encoding.UTF8.GetBytes(BufText.SubstringSpecial(curPos, curPos + 1)).Length;
                            }
                            curPos++;
                            continue;
                        }
                        //System.Console.WriteLine("STEP 5");

                        if (notFound > 0)
                        {
                            curLine  = AddNotFound(notFound, curLine);
                            notFound = 0;
                        }

                        int last = -1;
                        //System.Console.WriteLine("STEP 6");

                        int i = 3;
                        for (; i >= 0; i--)
                        {
                            int j = 1;
                            for (; j <= i && curPos + j < bufLen; j++)
                            {
                                if (BufText[curPos + j] < '\u25CB' || BufText[curPos + j] > '\u9FA5')
                                {
                                    break;
                                }
                            }
                            //System.Console.WriteLine("STEP 7");

                            if (j == i + 1)
                            {
                                if (i == 3)
                                {
                                    last = Dict.BinarySearch(BufText.SubstringSpecial(curPos, curPos + i + 1), true);
                                }
                                else
                                {
                                    if (last >= 0)
                                    {
                                        last = Dict.BinarySearch(BufText.SubstringSpecial(curPos, curPos + i + 1), 0, last - 1, false);
                                    }
                                    else
                                    {
                                        last = Dict.BinarySearch(BufText.SubstringSpecial(curPos, curPos + i + 1), false);
                                    }
                                }
                                //System.Console.WriteLine("STEP 8");

                                if (last >= 0)
                                {
                                    if (i == 3)
                                    {     //the found entry may be longer than 4 (3 + 1)
                                        if (Dict.GetLength(last) > bufLen - curPos)
                                        { //the found may be longer than the ending
                                            continue;
                                        }
                                        string word = BufText.SubstringSpecial(curPos, curPos + Dict.GetLength(last));
                                        if (Dict.Equals(last, word))
                                        {
                                            curLine = AddWord(last, curLine);

                                            Bookmark bookmark = Bookmark.Search(curFilePos, Bookmarks);
                                            if (bookmark != null)
                                            {
                                                bookmark.SetAnnotatedPosition(tempLines.Count, curLine.Count - 1);
                                                FoundBookmarks.Add(bookmark);
                                            }

                                            if (CheckCancelled())
                                            {
                                                return(null);
                                                //return (-1);
                                            }

                                            if (curFilePos != -1)
                                            {
                                                curFilePos += word.Length * 3;
                                            }
                                            curPos += word.Length;
                                            break;
                                        }
                                    }
                                    else
                                    {
                                        curLine = AddWord(last, curLine);

                                        Bookmark bookmark = Bookmark.Search(curFilePos, Bookmarks);
                                        if (bookmark != null)
                                        {
                                            bookmark.SetAnnotatedPosition(tempLines.Count, curLine.Count - 1);
                                            FoundBookmarks.Add(bookmark);
                                        }

                                        if (CheckCancelled())
                                        {
                                            //return (-1);
                                            return(null);
                                        }

                                        if (curFilePos != -1)
                                        {
                                            curFilePos += (i + 1) * 3;
                                        }
                                        curPos += i + 1;

                                        break;
                                    }
                                }
                            }
                        }
                        //System.Console.WriteLine("STEP 9");

                        if (i < 0)
                        {
                            notFound++;
                            if (curFilePos != -1)
                            {
                                curFilePos += Encoding.UTF8.GetBytes(BufText.SubstringSpecial(curPos, curPos + 1)).Length;
                            }
                            curPos++;
                        }
                    }
                    //System.Console.WriteLine("STEP 10");

                    if (notFound > 0)
                    {
                        curLine  = AddNotFound(notFound, curLine);
                        notFound = 0;
                    }
                    //System.Console.WriteLine("STEP 11");

                    if (curLine.Count > 0)
                    {
                        if (task == TASK_ANNOTATE_BACK || tempEndPos == textLen && curPos == bufLen || tempLines.Count == 0)
                        { //back annotation or end of text or 1-line text
                            tempLines.Add(curLine);
                            curLine = new List <object>();
                        }
                        else
                        {
                            curPos -= (int)LineView.GetLineSize(curLine, false);
                        }
                    }
                    //System.Console.WriteLine("STEP 12");

                    if (task == TASK_ANNOTATE || task == TASK_SPLIT)
                    {
                        if (annoMode == AnnotationActivity.ANNOTATE_FILE)
                        {
                            tempEndPos -= Encoding.UTF8.GetBytes(BufText.Substring(curPos)).Length;
                        }
                        else
                        {
                            tempEndPos -= bufLen - curPos;
                        }
                    }

                    if (task == TASK_ANNOTATE_BACK)
                    {
                        tempBackLines.InsertRange(0, tempLines);
                        tempLines = tempBackLines;
                    }

                    return(task);
                }
                catch (Exception e)
                {
                    status = Status.Finished;
                    System.Console.WriteLine("Annotation CreateTask ERROR => " + e.Message);

                    Log.Equals("ChineseReader", "Annotation error");
                }

                return(task);
            }, CancelToken.Token, TaskCreationOptions.None);

            t.ContinueWith(antecendent =>
            {
                status = Status.Finished;

                System.Console.WriteLine("C# Post Execute");

                if (CheckCancelled())
                {
                    return;
                }

                inter.OnCompleted(task, splitLineIndex, PastedText, tempLines, curPos, tempStartPos, tempEndPos, curPos < bufLen || (annoMode == AnnotationActivity.ANNOTATE_FILE && tempEndPos + Encoding.UTF8.GetBytes(BufText.SubstringSpecial(0, curPos)).Length < textLen), FoundBookmarks);
            }, CancelToken.Token, TaskContinuationOptions.None, Scheduler);

            return(t);
        }
Пример #12
0
        protected override Java.Lang.Object DoInBackground(params Java.Lang.Object[] native_parms)
        {
            try
            {
                switch (task)
                {
                case TASK_SPLIT:
                    curPos   = 0;
                    BufText  = "";
                    bufLen   = 0;
                    notFound = 0;
                    break;

                case TASK_ANNOTATE:
                case TASK_ANNOTATE_BACK:
                    curPos   = 0;
                    BufText  = "";
                    bufLen   = 0;
                    curLine  = new List <object>();
                    hMargin  = TestView != null ? TestView.hMargin : 0;
                    curWidth = hMargin;
                    notFound = 0;
                    break;
                }

                tempEndPos     = endPos;
                tempStartPos   = startPos;
                mHopelessBreak = false;

                while ((task == TASK_ANNOTATE || task == TASK_SPLIT) && (curPos < bufLen || curPos == bufLen && tempEndPos < textLen) && (tempLines.Count < visibleLines * 2 || (!Formatting && tempEndPos - endPos < 500)) || task == TASK_ANNOTATE_BACK && (curPos < bufLen || curPos == bufLen && tempStartPos > 0))
                {
                    if ((task == TASK_ANNOTATE || task == TASK_SPLIT) && bufLen - curPos < 18 && tempEndPos < textLen)
                    {
                        if (notFound > 0)
                        {
                            curLine  = AddNotFound(notFound, curLine);
                            notFound = 0;
                        }
                        BufText = NextBuffer;
                        bufLen  = BufText.Length;
                    }
                    else if (task == TASK_ANNOTATE_BACK && curPos == bufLen)
                    {
                        if (notFound > 0)
                        {
                            curLine  = AddNotFound(notFound, curLine);
                            notFound = 0;
                        }
                        if (curLine.Count > 0)
                        {
                            tempLines.Add(curLine);
                            curLine = new List <object>();
                        }
                        tempBackLines.InsertRange(0, tempLines);
                        tempLines.Clear();
                        if (tempBackLines.Count < visibleLines * 2)
                        {
                            BufText = PrevBuffer;
                            bufLen  = BufText.Length;
                        }
                        else
                        {
                            break;
                        }
                    }

                    if (BufText[curPos] < '\u25CB' || BufText[curPos] > '\u9FA5')
                    {
                        if (CheckCancelled())
                        {
                            //return (-1);
                            return(null);
                        }

                        notFound++;

                        if (BufText[curPos] == ' ' && notFound > 1)
                        {
                            curPos++;
                            curLine  = AddNotFound(notFound, curLine);
                            notFound = 0;

                            if (curFilePos != -1)
                            {
                                curFilePos++;
                            }

                            continue;
                        }

                        if (notFound > perLine * visibleLines * 2 && task == TASK_ANNOTATE)
                        {
                            notFound--;
                            break;
                        }

                        if (curFilePos != -1)
                        {
                            curFilePos += Encoding.UTF8.GetBytes(BufText.SubstringSpecial(curPos, curPos + 1)).Length;
                        }
                        curPos++;
                        continue;
                    }

                    if (notFound > 0)
                    {
                        curLine  = AddNotFound(notFound, curLine);
                        notFound = 0;
                    }

                    int last = -1;

                    int i = 3;
                    for (; i >= 0; i--)
                    {
                        int j = 1;
                        for (; j <= i && curPos + j < bufLen; j++)
                        {
                            if (BufText[curPos + j] < '\u25CB' || BufText[curPos + j] > '\u9FA5')
                            {
                                break;
                            }
                        }

                        if (j == i + 1)
                        {
                            if (i == 3)
                            {
                                last = Dict.BinarySearch(BufText.SubstringSpecial(curPos, curPos + i + 1), true);
                            }
                            else
                            {
                                if (last >= 0)
                                {
                                    last = Dict.BinarySearch(BufText.SubstringSpecial(curPos, curPos + i + 1), 0, last - 1, false);
                                }
                                else
                                {
                                    last = Dict.BinarySearch(BufText.SubstringSpecial(curPos, curPos + i + 1), false);
                                }
                            }

                            if (last >= 0)
                            {
                                if (i == 3)
                                {     //the found entry may be longer than 4 (3 + 1)
                                    if (Dict.GetLength(last) > bufLen - curPos)
                                    { //the found may be longer than the ending
                                        continue;
                                    }
                                    string word = BufText.SubstringSpecial(curPos, curPos + Dict.GetLength(last));
                                    if (Dict.Equals(last, word))
                                    {
                                        curLine = AddWord(last, curLine);

                                        Bookmark bookmark = Bookmark.Search(curFilePos, Bookmarks);
                                        if (bookmark != null)
                                        {
                                            bookmark.SetAnnotatedPosition(tempLines.Count, curLine.Count - 1);
                                            FoundBookmarks.Add(bookmark);
                                        }

                                        if (CheckCancelled())
                                        {
                                            return(null);
                                            //return (-1);
                                        }

                                        if (curFilePos != -1)
                                        {
                                            curFilePos += word.Length * 3;
                                        }
                                        curPos += word.Length;
                                        break;
                                    }
                                }
                                else
                                {
                                    curLine = AddWord(last, curLine);

                                    Bookmark bookmark = Bookmark.Search(curFilePos, Bookmarks);
                                    if (bookmark != null)
                                    {
                                        bookmark.SetAnnotatedPosition(tempLines.Count, curLine.Count - 1);
                                        FoundBookmarks.Add(bookmark);
                                    }

                                    if (CheckCancelled())
                                    {
                                        //return (-1);
                                        return(null);
                                    }

                                    if (curFilePos != -1)
                                    {
                                        curFilePos += (i + 1) * 3;
                                    }
                                    curPos += i + 1;

                                    break;
                                }
                            }
                        }
                    }

                    if (i < 0)
                    {
                        notFound++;
                        if (curFilePos != -1)
                        {
                            curFilePos += Encoding.UTF8.GetBytes(BufText.SubstringSpecial(curPos, curPos + 1)).Length;
                        }
                        curPos++;
                    }
                }

                if (notFound > 0)
                {
                    curLine  = AddNotFound(notFound, curLine);
                    notFound = 0;
                }

                if (curLine.Count > 0)
                {
                    if (task == TASK_ANNOTATE_BACK || tempEndPos == textLen && curPos == bufLen || tempLines.Count == 0)
                    { //back annotation or end of text or 1-line text
                        tempLines.Add(curLine);
                        curLine = new List <object>();
                    }
                    else
                    {
                        curPos -= (int)LineView.GetLineSize(curLine, false);
                    }
                }

                if (task == TASK_ANNOTATE || task == TASK_SPLIT)
                {
                    if (annoMode == AnnotationActivity.ANNOTATE_FILE)
                    {
                        tempEndPos -= Encoding.UTF8.GetBytes(BufText.Substring(curPos)).Length;
                    }
                    else
                    {
                        tempEndPos -= bufLen - curPos;
                    }
                }

                if (task == TASK_ANNOTATE_BACK)
                {
                    tempBackLines.InsertRange(0, tempLines);
                    tempLines = tempBackLines;
                }

                return(task);
            }
            catch (Java.Lang.Exception e)
            {
                status = Status.Finished;
                System.Console.WriteLine("Annotation DoInBackground ERROR => " + e.Message);
                Log.Equals("ChineseReader", "Annotation error");
            }

            return(task);
        }
Пример #13
0
        public virtual void StarredExportPleco()
        {
            string stars = sharedPrefs.GetString("stars", "");

            if (stars.Length < 2)
            {
                Toast.MakeText(this, "Starred list is empty. Nothing to export.", ToastLength.Long).Show();
                return;
            }

            try
            {
                File dir = new File(global::Android.OS.Environment.ExternalStorageDirectory.AbsolutePath, "/ChineseReader");

                dir.Mkdirs();
                System.IO.FileStream os  = new System.IO.FileStream(dir.AbsolutePath + "/chinesereader_starred.txt", System.IO.FileMode.Create, System.IO.FileAccess.Write);
                BufferedOutputStream bos = new BufferedOutputStream(os);

                StringBuilder english = new StringBuilder();

                int oldIndex = 0, nIndex;
                while ((nIndex = stars.IndexOf("\n", oldIndex)) > -1)
                {
                    english.Length = 0;

                    int entry = Dict.BinarySearch(stars.SubstringSpecial(oldIndex, nIndex), false);
                    oldIndex = nIndex + 1;

                    if (entry == -1)
                    {
                        continue;
                    }

                    english.Append(Dict.GetCh(entry)).Append("\t").Append(Regex.Replace(Dict.GetPinyin(entry), @"(\\d)", "$1 ")).Append("\t");

                    string[] parts = Regex.Split(Regex.Replace(Dict.GetEnglish(entry), @"/", "; "), @"\\$");
                    int      j     = 0;
                    foreach (string str in parts)
                    {
                        if (j++ % 2 == 1)
                        {
                            english.Append(" [ ").Append(Regex.Replace(str, @"(\\d)", "$1 ")).Append("] ");
                        }
                        else
                        {
                            english.Append(str);
                        }
                    }
                    english.Append("\n");

                    bos.Write(Encoding.UTF8.GetBytes(english.ToString()));
                }
                os.Flush();
                bos.Flush();
                bos.Close();
                os.Close();

                Toast.MakeText(this, "Successfully exported to " + dir.AbsolutePath + "/chinesereader_starred.txt", ToastLength.Long).Show();
            }
            catch (Exception e)
            {
                Toast.MakeText(this, "Could not export: " + e.Message, ToastLength.Long).Show();
            }
        }
Пример #14
0
        public void StarredExport(int exportId)
        {
            string stars = sharedPrefs.GetString("stars", "");

            if (stars == null || stars.Length < 2)
            {
                Toast.MakeText(this, "Starred list is empty. Nothing to export.", ToastLength.Long).Show();
                return;
            }

            System.Random  random = new System.Random();
            SQLiteDatabase db     = OpenOrCreateDatabase("anki.db", FileCreationMode.Private, null);

            string[] commands = Regex.Split(GetString(Resource.String.anki_scheme), ";;");
            foreach (string command in commands)
            {
                db.ExecSQL(command);
            }

            int oldIndex = 0;
            int nIndex;

            while ((nIndex = stars.IndexOf("\n", oldIndex)) > -1)
            {
                int entry = Dict.BinarySearch(stars.SubstringSpecial(oldIndex, nIndex), false);
                oldIndex = nIndex + 1;

                if (entry == -1)
                {
                    continue;
                }

                string        id = Convert.ToString(Math.Abs(random.Next())), uuid = UUID.RandomUUID().ToString().SubstringSpecial(0, 10);
                StringBuilder english = new StringBuilder();

                if (exportId == Resource.Id.menu_starred_export_pinyin)
                {
                    english.Append(Dict.PinyinToTones(Dict.GetPinyin(entry))).Append("<br/>");
                }

                english.Append(Dict.GetCh(entry)).Append("\u001F");

                if (exportId == Resource.Id.menu_starred_export)
                {
                    english.Append("[ ").Append(Dict.PinyinToTones(Dict.GetPinyin(entry))).Append(" ]<br/>");
                }

                string[] parts = Regex.Split(Regex.Replace(Dict.GetEnglish(entry), @"/", "<br/>• "), @"\\$");
                int      j     = 0;
                foreach (string str in parts)
                {
                    if (j++ % 2 == 1)
                    {
                        english.Append("<br/><br/>[ ").Append(Dict.PinyinToTones(str)).Append(" ]<br/>");
                    }
                    else
                    {
                        english.Append("• ");

                        int bracketIndex, bracketEnd = 0;
                        while ((bracketIndex = str.IndexOf("[", bracketEnd)) > -1)
                        {
                            english.Append(str, bracketEnd, bracketIndex);
                            bracketEnd = str.IndexOf("]", bracketIndex);
                            english.Append(Dict.PinyinToTones(str.SubstringSpecial(bracketIndex, bracketEnd)));
                        }
                        english.Append(str, bracketEnd, str.Length);
                    }
                }

                db.ExecSQL("insert into notes values(?, ?, 1399962367564, 1400901624, -1, '', ?, 0, 147133787, 0, '')", new Java.Lang.Object[] { id, uuid, english.ToString() });

                db.ExecSQL("insert into cards values(?, ?, 1400901287521, 0, 1400901624, -1, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, '')", new Java.Lang.Object[] { Convert.ToString(random.Next()), id });
            }
            db.Close();

            try
            {
                File dir = new File(global::Android.OS.Environment.ExternalStorageDirectory.AbsolutePath, "/AnkiDroid");
                if (!dir.Exists())
                {
                    dir = new File(global::Android.OS.Environment.ExternalStorageDirectory.AbsolutePath, "/ChineseReader");
                }

                dir.Mkdirs();
                System.IO.Stream fos = new System.IO.FileStream(dir.AbsolutePath + "/chinesereader_starred.apkg", System.IO.FileMode.Create, System.IO.FileAccess.Write);
                System.IO.Stream fiz = new System.IO.FileStream(GetDatabasePath("anki.db").Path, System.IO.FileMode.Open, System.IO.FileAccess.Read);
                ZipOutputStream  zos = new ZipOutputStream(fos);

                zos.PutNextEntry(new ZipEntry("collection.anki2"));
                byte[] buffer  = new byte[1024];
                int    readLen = 0;
                while ((readLen = fiz.Read(buffer, 0, buffer.Length)) > 0)
                {
                    zos.Write(buffer, 0, readLen);
                }
                zos.CloseEntry();

                zos.PutNextEntry(new ZipEntry("media"));
                buffer[0] = 0x7b;
                buffer[1] = 0x7d;
                zos.Write(buffer, 0, 2);
                zos.CloseEntry();
                zos.Flush();
                zos.Close();
                fiz.Close();
                fos.Flush();
                fos.Close();

                Toast.MakeText(this, "Successfully exported to " + dir.AbsolutePath + "/chinesereader_starred.apkg", ToastLength.Long).Show();
            }
            catch (Exception e)
            {
                Toast.MakeText(this, "Could not export: " + e.Message, ToastLength.Long).Show();
            }
        }