Example usage for android.graphics Canvas save

List of usage examples for android.graphics Canvas save

Introduction

In this page you can find the example usage for android.graphics Canvas save.

Prototype

public int save() 

Source Link

Document

Saves the current matrix and clip onto a private stack.

Usage

From source file:com.appunite.list.AbsListView.java

@Override
public void draw(Canvas canvas) {
    super.draw(canvas);
    if (mEdgeGlowTop != null) {
        final int scrollY = getScrollY();
        boolean needsInvalidate = false;
        if (!mEdgeGlowTop.isFinished()) {
            final int restoreCount = canvas.save();
            final int leftPadding = mListPadding.left + mGlowPaddingLeft;
            final int rightPadding = mListPadding.right + mGlowPaddingRight;
            final int width = getWidth() - leftPadding - rightPadding;

            int edgeY = Math.min(0, scrollY + mFirstPositionDistanceGuess);
            canvas.translate(leftPadding, edgeY);
            mEdgeGlowTop.setSize(width, getHeight());
            if (mEdgeGlowTop.draw(canvas)) {
                needsInvalidate = true;//from w ww  .  j a v  a 2s .co  m
            }
            canvas.restoreToCount(restoreCount);
        }
        if (!mEdgeGlowBottom.isFinished()) {
            final int restoreCount = canvas.save();
            final int leftPadding = mListPadding.left + mGlowPaddingLeft;
            final int rightPadding = mListPadding.right + mGlowPaddingRight;
            final int width = getWidth() - leftPadding - rightPadding;
            final int height = getHeight();

            int edgeX = -width + leftPadding;
            int edgeY = Math.max(height, scrollY + mLastPositionDistanceGuess);
            canvas.translate(edgeX, edgeY);
            canvas.rotate(180, width, 0);
            mEdgeGlowBottom.setSize(width, height);
            if (mEdgeGlowBottom.draw(canvas)) {
                needsInvalidate = true;
            }
            canvas.restoreToCount(restoreCount);
        }
        if (needsInvalidate) {
            invalidate();
        }
    }
    if (mFastScroller != null) {
        final int scrollY = getScrollY();
        if (scrollY != 0) {
            // Pin to the top/bottom during overscroll
            int restoreCount = canvas.save();
            canvas.translate(0, (float) scrollY);
            mFastScroller.draw(canvas);
            canvas.restoreToCount(restoreCount);
        } else {
            mFastScroller.draw(canvas);
        }
    }
}

From source file:com.artifex.mupdflib.TwoWayView.java

private boolean drawEndEdge(Canvas canvas) {
    if (mEndEdge.isFinished()) {
        return false;
    }/*from w w  w .  j  a v a2 s  . c  om*/

    final int restoreCount = canvas.save();
    final int width = getWidth();
    final int height = getHeight();

    if (mIsVertical) {
        canvas.translate(-width, height);
        canvas.rotate(180, width, 0);
    } else {
        canvas.translate(width, 0);
        canvas.rotate(90);
    }

    final boolean needsInvalidate = mEndEdge.draw(canvas);
    canvas.restoreToCount(restoreCount);
    return needsInvalidate;
}

From source file:com.artifex.mupdflib.TwoWayView.java

private boolean drawStartEdge(Canvas canvas) {
    if (mStartEdge.isFinished()) {
        return false;
    }/*from  w  w  w.  j  ava 2s.c o m*/

    if (mIsVertical) {
        return mStartEdge.draw(canvas);
    }

    final int restoreCount = canvas.save();
    final int height = getHeight();

    canvas.translate(0, height);
    canvas.rotate(270);

    final boolean needsInvalidate = mStartEdge.draw(canvas);
    canvas.restoreToCount(restoreCount);
    return needsInvalidate;
}

From source file:org.telegram.ui.ArticleViewer.java

public void setParentActivity(Activity activity) {
    if (parentActivity == activity) {
        return;/*  w  w  w .  j  a  v  a 2s .c  o  m*/
    }
    parentActivity = activity;

    backgroundPaint = new Paint();
    backgroundPaint.setColor(0xffffffff);

    layerShadowDrawable = activity.getResources().getDrawable(R.drawable.layer_shadow);
    slideDotDrawable = activity.getResources().getDrawable(R.drawable.slide_dot_small);
    slideDotBigDrawable = activity.getResources().getDrawable(R.drawable.slide_dot_big);
    scrimPaint = new Paint();

    windowView = new WindowView(activity);
    windowView.setWillNotDraw(false);
    windowView.setClipChildren(true);
    windowView.setFocusable(false);

    containerView = new FrameLayout(activity);
    windowView.addView(containerView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT,
            LayoutHelper.MATCH_PARENT, Gravity.TOP | Gravity.LEFT));
    containerView.setFitsSystemWindows(true);
    if (Build.VERSION.SDK_INT >= 21) {
        containerView.setOnApplyWindowInsetsListener(new View.OnApplyWindowInsetsListener() {
            @SuppressLint("NewApi")
            @Override
            public WindowInsets onApplyWindowInsets(View v, WindowInsets insets) {
                WindowInsets oldInsets = (WindowInsets) lastInsets;
                lastInsets = insets;
                if (oldInsets == null || !oldInsets.toString().equals(insets.toString())) {
                    windowView.requestLayout();
                }
                return insets.consumeSystemWindowInsets();
            }
        });
    }
    containerView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_FULLSCREEN);

    photoContainerBackground = new View(activity);
    photoContainerBackground.setVisibility(View.INVISIBLE);
    photoContainerBackground.setBackgroundDrawable(photoBackgroundDrawable);
    windowView.addView(photoContainerBackground, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT,
            LayoutHelper.MATCH_PARENT, Gravity.TOP | Gravity.LEFT));

    animatingImageView = new ClippingImageView(activity);
    animatingImageView.setAnimationValues(animationValues);
    animatingImageView.setVisibility(View.GONE);
    windowView.addView(animatingImageView, LayoutHelper.createFrame(40, 40));

    photoContainerView = new FrameLayoutDrawer(activity) {
        @Override
        protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
            super.onLayout(changed, left, top, right, bottom);
            int y = bottom - top - captionTextView.getMeasuredHeight();
            if (bottomLayout.getVisibility() == VISIBLE) {
                y -= bottomLayout.getMeasuredHeight();
            }
            captionTextView.layout(0, y, captionTextView.getMeasuredWidth(),
                    y + captionTextView.getMeasuredHeight());
        }
    };
    photoContainerView.setVisibility(View.INVISIBLE);
    photoContainerView.setWillNotDraw(false);
    windowView.addView(photoContainerView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT,
            LayoutHelper.MATCH_PARENT, Gravity.TOP | Gravity.LEFT));

    fullscreenVideoContainer = new FrameLayout(activity);
    fullscreenVideoContainer.setBackgroundColor(0xff000000);
    fullscreenVideoContainer.setVisibility(View.INVISIBLE);
    windowView.addView(fullscreenVideoContainer,
            LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT));

    fullscreenAspectRatioView = new AspectRatioFrameLayout(activity);
    fullscreenAspectRatioView.setVisibility(View.GONE);
    fullscreenVideoContainer.addView(fullscreenAspectRatioView,
            LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT, Gravity.CENTER));

    fullscreenTextureView = new TextureView(activity);

    if (Build.VERSION.SDK_INT >= 21) {
        barBackground = new View(activity);
        barBackground.setBackgroundColor(0xff000000);
        windowView.addView(barBackground);
    }

    listView = new RecyclerListView(activity);
    listView.setLayoutManager(
            layoutManager = new LinearLayoutManager(parentActivity, LinearLayoutManager.VERTICAL, false));
    listView.setAdapter(adapter = new WebpageAdapter(parentActivity));
    listView.setClipToPadding(false);
    listView.setPadding(0, AndroidUtilities.dp(56), 0, 0);
    listView.setTopGlowOffset(AndroidUtilities.dp(56));
    listView.setGlowColor(0xfff5f6f7);
    containerView.addView(listView,
            LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT));
    listView.setOnItemLongClickListener(new RecyclerListView.OnItemLongClickListener() {
        @Override
        public boolean onItemClick(View view, int position) {
            return false;
        }
    });
    listView.setOnItemClickListener(new RecyclerListView.OnItemClickListener() {
        @Override
        public void onItemClick(View view, int position) {
            if (position == blocks.size() && currentPage != null) {
                if (previewsReqId != 0) {
                    return;
                }
                TLRPC.User user = MessagesController.getInstance().getUser("previews");
                if (user != null) {
                    openPreviewsChat(user, currentPage.id);
                } else {
                    final long pageId = currentPage.id;
                    showProgressView(true);
                    TLRPC.TL_contacts_resolveUsername req = new TLRPC.TL_contacts_resolveUsername();
                    req.username = "previews";
                    previewsReqId = ConnectionsManager.getInstance().sendRequest(req, new RequestDelegate() {
                        @Override
                        public void run(final TLObject response, final TLRPC.TL_error error) {
                            AndroidUtilities.runOnUIThread(new Runnable() {
                                @Override
                                public void run() {
                                    if (previewsReqId == 0) {
                                        return;
                                    }
                                    previewsReqId = 0;
                                    showProgressView(false);
                                    if (response != null) {
                                        TLRPC.TL_contacts_resolvedPeer res = (TLRPC.TL_contacts_resolvedPeer) response;
                                        MessagesController.getInstance().putUsers(res.users, false);
                                        MessagesStorage.getInstance().putUsersAndChats(res.users, res.chats,
                                                false, true);
                                        if (!res.users.isEmpty()) {
                                            openPreviewsChat(res.users.get(0), pageId);
                                        }
                                    }
                                }
                            });
                        }
                    });
                }
            }
        }
    });
    listView.setOnScrollListener(new RecyclerView.OnScrollListener() {
        @Override
        public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
            if (listView.getChildCount() == 0) {
                return;
            }
            checkScroll(dy);
        }
    });
    headerView = new FrameLayout(activity);
    headerView.setOnTouchListener(new View.OnTouchListener() {
        @Override
        public boolean onTouch(View v, MotionEvent event) {
            return true;
        }
    });
    headerView.setBackgroundColor(0xff000000);
    containerView.addView(headerView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, 56));

    backButton = new ImageView(activity);
    backButton.setScaleType(ImageView.ScaleType.CENTER);
    backDrawable = new BackDrawable(false);
    backDrawable.setAnimationTime(200.0f);
    backDrawable.setColor(0xffb3b3b3);
    backDrawable.setRotated(false);
    backButton.setImageDrawable(backDrawable);
    backButton.setBackgroundDrawable(Theme.createSelectorDrawable(Theme.ACTION_BAR_WHITE_SELECTOR_COLOR));
    headerView.addView(backButton, LayoutHelper.createFrame(54, 56));
    backButton.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            /*if (collapsed) {
            uncollapse();
            } else {
            collapse();
            }*/
            close(true, true);
        }
    });

    shareContainer = new FrameLayout(activity);
    headerView.addView(shareContainer, LayoutHelper.createFrame(48, 56, Gravity.TOP | Gravity.RIGHT));
    shareContainer.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            if (currentPage == null || parentActivity == null) {
                return;
            }
            showDialog(new ShareAlert(parentActivity, null, currentPage.url, false, currentPage.url, true));
            hideActionBar();
        }
    });

    shareButton = new ImageView(activity);
    shareButton.setScaleType(ImageView.ScaleType.CENTER);
    shareButton.setImageResource(R.drawable.ic_share_article);
    shareButton.setBackgroundDrawable(Theme.createSelectorDrawable(Theme.ACTION_BAR_WHITE_SELECTOR_COLOR));
    shareContainer.addView(shareButton, LayoutHelper.createFrame(48, 56));

    progressView = new ContextProgressView(activity, 2);
    progressView.setVisibility(View.GONE);
    shareContainer.addView(progressView, LayoutHelper.createFrame(48, 56));

    windowLayoutParams = new WindowManager.LayoutParams();
    windowLayoutParams.height = WindowManager.LayoutParams.MATCH_PARENT;
    windowLayoutParams.format = PixelFormat.TRANSLUCENT;
    windowLayoutParams.width = WindowManager.LayoutParams.MATCH_PARENT;
    windowLayoutParams.gravity = Gravity.TOP | Gravity.LEFT;
    windowLayoutParams.type = WindowManager.LayoutParams.LAST_APPLICATION_WINDOW;
    if (Build.VERSION.SDK_INT >= 21) {
        windowLayoutParams.flags = WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
                | WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR
                | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
                | WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS;
    } else {
        windowLayoutParams.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
    }

    if (progressDrawables == null) {
        progressDrawables = new Drawable[4];
        progressDrawables[0] = parentActivity.getResources().getDrawable(R.drawable.circle_big);
        progressDrawables[1] = parentActivity.getResources().getDrawable(R.drawable.cancel_big);
        progressDrawables[2] = parentActivity.getResources().getDrawable(R.drawable.load_big);
        progressDrawables[3] = parentActivity.getResources().getDrawable(R.drawable.play_big);
    }

    scroller = new Scroller(activity);

    blackPaint.setColor(0xff000000);

    actionBar = new ActionBar(activity);
    actionBar.setBackgroundColor(Theme.ACTION_BAR_PHOTO_VIEWER_COLOR);
    actionBar.setOccupyStatusBar(false);
    actionBar.setTitleColor(0xffffffff);
    actionBar.setItemsBackgroundColor(Theme.ACTION_BAR_WHITE_SELECTOR_COLOR, false);
    actionBar.setBackButtonImage(R.drawable.ic_ab_back);
    actionBar.setTitle(LocaleController.formatString("Of", R.string.Of, 1, 1));
    photoContainerView.addView(actionBar,
            LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

    actionBar.setActionBarMenuOnItemClick(new ActionBar.ActionBarMenuOnItemClick() {
        @Override
        public void onItemClick(int id) {
            if (id == -1) {
                closePhoto(true);
            } else if (id == gallery_menu_save) {
                if (Build.VERSION.SDK_INT >= 23 && parentActivity.checkSelfPermission(
                        Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
                    parentActivity
                            .requestPermissions(new String[] { Manifest.permission.WRITE_EXTERNAL_STORAGE }, 4);
                    return;
                }
                File f = getMediaFile(currentIndex);
                if (f != null && f.exists()) {
                    MediaController.saveFile(f.toString(), parentActivity, isMediaVideo(currentIndex) ? 1 : 0,
                            null, null);
                } else {
                    AlertDialog.Builder builder = new AlertDialog.Builder(parentActivity);
                    builder.setTitle(LocaleController.getString("AppName", R.string.AppName));
                    builder.setPositiveButton(LocaleController.getString("OK", R.string.OK), null);
                    builder.setMessage(LocaleController.getString("PleaseDownload", R.string.PleaseDownload));
                    showDialog(builder.create());
                }
            } else if (id == gallery_menu_share) {
                onSharePressed();
            } else if (id == gallery_menu_openin) {
                try {
                    AndroidUtilities.openForView(getMedia(currentIndex), parentActivity);
                    closePhoto(false);
                } catch (Exception e) {
                    FileLog.e(e);
                }
            }
        }

        @Override
        public boolean canOpenMenu() {
            File f = getMediaFile(currentIndex);
            return f != null && f.exists();
        }
    });

    ActionBarMenu menu = actionBar.createMenu();

    menu.addItem(gallery_menu_share, R.drawable.share);
    menuItem = menu.addItem(0, R.drawable.ic_ab_other);
    menuItem.setLayoutInScreen(true);
    menuItem.addSubItem(gallery_menu_openin,
            LocaleController.getString("OpenInExternalApp", R.string.OpenInExternalApp));
    //menuItem.addSubItem(gallery_menu_share, LocaleController.getString("ShareFile", R.string.ShareFile), 0);
    menuItem.addSubItem(gallery_menu_save, LocaleController.getString("SaveToGallery", R.string.SaveToGallery));

    bottomLayout = new FrameLayout(parentActivity);
    bottomLayout.setBackgroundColor(0x7f000000);
    photoContainerView.addView(bottomLayout,
            LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, 48, Gravity.BOTTOM | Gravity.LEFT));

    captionTextViewOld = new TextView(activity);
    captionTextViewOld.setMaxLines(10);
    captionTextViewOld.setBackgroundColor(0x7f000000);
    captionTextViewOld.setPadding(AndroidUtilities.dp(20), AndroidUtilities.dp(8), AndroidUtilities.dp(20),
            AndroidUtilities.dp(8));
    captionTextViewOld.setLinkTextColor(0xffffffff);
    captionTextViewOld.setTextColor(0xffffffff);
    captionTextViewOld.setGravity(Gravity.CENTER_VERTICAL | Gravity.LEFT);
    captionTextViewOld.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
    captionTextViewOld.setVisibility(View.INVISIBLE);
    photoContainerView.addView(captionTextViewOld, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT,
            LayoutHelper.WRAP_CONTENT, Gravity.BOTTOM | Gravity.LEFT));

    captionTextView = captionTextViewNew = new TextView(activity);
    captionTextViewNew.setMaxLines(10);
    captionTextViewNew.setBackgroundColor(0x7f000000);
    captionTextViewNew.setPadding(AndroidUtilities.dp(20), AndroidUtilities.dp(8), AndroidUtilities.dp(20),
            AndroidUtilities.dp(8));
    captionTextViewNew.setLinkTextColor(0xffffffff);
    captionTextViewNew.setTextColor(0xffffffff);
    captionTextViewNew.setGravity(Gravity.CENTER_VERTICAL | Gravity.LEFT);
    captionTextViewNew.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
    captionTextViewNew.setVisibility(View.INVISIBLE);
    photoContainerView.addView(captionTextViewNew, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT,
            LayoutHelper.WRAP_CONTENT, Gravity.BOTTOM | Gravity.LEFT));

    radialProgressViews[0] = new RadialProgressView(activity, photoContainerView);
    radialProgressViews[0].setBackgroundState(0, false);
    radialProgressViews[1] = new RadialProgressView(activity, photoContainerView);
    radialProgressViews[1].setBackgroundState(0, false);
    radialProgressViews[2] = new RadialProgressView(activity, photoContainerView);
    radialProgressViews[2].setBackgroundState(0, false);

    videoPlayerSeekbar = new SeekBar(activity);
    videoPlayerSeekbar.setColors(0x66ffffff, 0xffffffff, 0xffffffff);
    videoPlayerSeekbar.setDelegate(new SeekBar.SeekBarDelegate() {
        @Override
        public void onSeekBarDrag(float progress) {
            if (videoPlayer != null) {
                videoPlayer.seekTo((int) (progress * videoPlayer.getDuration()));
            }
        }
    });

    videoPlayerControlFrameLayout = new FrameLayout(activity) {
        @Override
        public boolean onTouchEvent(MotionEvent event) {
            int x = (int) event.getX();
            int y = (int) event.getY();
            if (videoPlayerSeekbar.onTouch(event.getAction(), event.getX() - AndroidUtilities.dp(48),
                    event.getY())) {
                getParent().requestDisallowInterceptTouchEvent(true);
                invalidate();
                return true;
            }
            return super.onTouchEvent(event);
        }

        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            super.onMeasure(widthMeasureSpec, heightMeasureSpec);
            long duration;
            if (videoPlayer != null) {
                duration = videoPlayer.getDuration();
                if (duration == C.TIME_UNSET) {
                    duration = 0;
                }
            } else {
                duration = 0;
            }
            duration /= 1000;
            int size = (int) Math
                    .ceil(videoPlayerTime.getPaint().measureText(String.format("%02d:%02d / %02d:%02d",
                            duration / 60, duration % 60, duration / 60, duration % 60)));
            videoPlayerSeekbar.setSize(getMeasuredWidth() - AndroidUtilities.dp(48 + 16) - size,
                    getMeasuredHeight());
        }

        @Override
        protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
            super.onLayout(changed, left, top, right, bottom);
            float progress = 0;
            if (videoPlayer != null) {
                progress = videoPlayer.getCurrentPosition() / (float) videoPlayer.getDuration();
            }
            videoPlayerSeekbar.setProgress(progress);
        }

        @Override
        protected void onDraw(Canvas canvas) {
            canvas.save();
            canvas.translate(AndroidUtilities.dp(48), 0);
            videoPlayerSeekbar.draw(canvas);
            canvas.restore();
        }
    };
    videoPlayerControlFrameLayout.setWillNotDraw(false);
    bottomLayout.addView(videoPlayerControlFrameLayout, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT,
            LayoutHelper.MATCH_PARENT, Gravity.TOP | Gravity.LEFT));

    videoPlayButton = new ImageView(activity);
    videoPlayButton.setScaleType(ImageView.ScaleType.CENTER);
    videoPlayerControlFrameLayout.addView(videoPlayButton,
            LayoutHelper.createFrame(48, 48, Gravity.LEFT | Gravity.TOP));
    videoPlayButton.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            if (videoPlayer != null) {
                if (isPlaying) {
                    videoPlayer.pause();
                } else {
                    videoPlayer.play();
                }
            }
        }
    });

    videoPlayerTime = new TextView(activity);
    videoPlayerTime.setTextColor(0xffffffff);
    videoPlayerTime.setGravity(Gravity.CENTER_VERTICAL);
    videoPlayerTime.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 13);
    videoPlayerControlFrameLayout.addView(videoPlayerTime, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT,
            LayoutHelper.MATCH_PARENT, Gravity.RIGHT | Gravity.TOP, 0, 0, 8, 0));

    gestureDetector = new GestureDetector(activity, this);
    gestureDetector.setOnDoubleTapListener(this);

    ImageReceiver.ImageReceiverDelegate imageReceiverDelegate = new ImageReceiver.ImageReceiverDelegate() {
        @Override
        public void didSetImage(ImageReceiver imageReceiver, boolean set, boolean thumb) {
            if (imageReceiver == centerImage && set && scaleToFill()) {
                if (!wasLayout) {
                    dontResetZoomOnFirstLayout = true;
                } else {
                    setScaleToFill();
                }
            }
        }
    };

    centerImage.setParentView(photoContainerView);
    centerImage.setCrossfadeAlpha((byte) 2);
    centerImage.setInvalidateAll(true);
    centerImage.setDelegate(imageReceiverDelegate);
    leftImage.setParentView(photoContainerView);
    leftImage.setCrossfadeAlpha((byte) 2);
    leftImage.setInvalidateAll(true);
    leftImage.setDelegate(imageReceiverDelegate);
    rightImage.setParentView(photoContainerView);
    rightImage.setCrossfadeAlpha((byte) 2);
    rightImage.setInvalidateAll(true);
    rightImage.setDelegate(imageReceiverDelegate);
}

From source file:net.droidsolutions.droidcharts.core.plot.CategoryPlot.java

/**
 * Draws the plot on a Java 2D graphics device (such as the screen or a
 * printer)./* w w  w .ja va  2  s  .c o m*/
 * <P>
 * At your option, you may supply an instance of {@link PlotRenderingInfo}.
 * If you do, it will be populated with information about the drawing,
 * including various plot dimensions and tooltip info.
 * 
 * @param g2
 *            the graphics device.
 * @param area
 *            the area within which the plot (including axes) should be
 *            drawn.
 * @param anchor
 *            the anchor point (<code>null</code> permitted).
 * @param parentState
 *            the state from the parent plot, if there is one.
 * @param state
 *            collects info as the chart is drawn (possibly
 *            <code>null</code>).
 */
public void draw(Canvas g2, Rectangle2D area, Point2D anchor, PlotState parentState, PlotRenderingInfo state) {

    // if the plot area is too small, just return...
    boolean b1 = (area.getWidth() <= MINIMUM_WIDTH_TO_DRAW);
    boolean b2 = (area.getHeight() <= MINIMUM_HEIGHT_TO_DRAW);
    if (b1 || b2) {
        return;
    }

    // record the plot area...
    if (state == null) {
        // if the incoming state is null, no information will be passed
        // back to the caller - but we create a temporary state to record
        // the plot area, since that is used later by the axes
        state = new PlotRenderingInfo(null);
    }
    state.setPlotArea(area);

    // adjust the drawing area for the plot insets (if any)...
    RectangleInsets insets = getInsets();
    insets.trim(area);

    // calculate the data area...
    AxisSpace space = calculateAxisSpace(g2, area);
    Rectangle2D dataArea = space.shrink(area, null);
    this.axisOffset.trim(dataArea);

    state.setDataArea(dataArea);
    createAndAddEntity((Rectangle2D) dataArea.clone(), state, null, null);

    // if there is a renderer, it draws the background, otherwise use the
    // default background...
    if (getRenderer() != null) {
        getRenderer().drawBackground(g2, this, dataArea);
    } else {
        drawBackground(g2, dataArea);
    }

    Map axisStateMap = drawAxes(g2, area, dataArea, state);

    // the anchor point is typically the point where the mouse last
    // clicked - the crosshairs will be driven off this point...
    if (anchor != null && !dataArea.contains(anchor)) {
        anchor = ShapeUtilities.getPointInRectangle(anchor.getX(), anchor.getY(), dataArea);
    }
    CategoryCrosshairState crosshairState = new CategoryCrosshairState();
    crosshairState.setCrosshairDistance(Double.POSITIVE_INFINITY);
    crosshairState.setAnchor(anchor);

    // specify the anchor X and Y coordinates in Java2D space, for the
    // cases where these are not updated during rendering (i.e. no lock
    // on data)
    crosshairState.setAnchorX(Double.NaN);
    crosshairState.setAnchorY(Double.NaN);
    if (anchor != null) {
        ValueAxis rangeAxis = getRangeAxis();
        if (rangeAxis != null) {
            double y;
            if (getOrientation() == PlotOrientation.VERTICAL) {
                y = rangeAxis.java2DToValue(anchor.getY(), dataArea, getRangeAxisEdge());
            } else {
                y = rangeAxis.java2DToValue(anchor.getX(), dataArea, getRangeAxisEdge());
            }
            crosshairState.setAnchorY(y);
        }
    }
    crosshairState.setRowKey(getDomainCrosshairRowKey());
    crosshairState.setColumnKey(getDomainCrosshairColumnKey());
    crosshairState.setCrosshairY(getRangeCrosshairValue());

    // don't let anyone draw outside the data area
    g2.save();
    g2.clipRect((float) dataArea.getMinX(), (float) dataArea.getMaxY(), (float) dataArea.getMaxX(),
            (float) dataArea.getMinY());

    drawDomainGridlines(g2, dataArea);

    AxisState rangeAxisState = (AxisState) axisStateMap.get(getRangeAxis());
    if (rangeAxisState == null) {
        if (parentState != null) {
            rangeAxisState = (AxisState) parentState.getSharedAxisStates().get(getRangeAxis());
        }
    }
    if (rangeAxisState != null) {
        drawRangeGridlines(g2, dataArea, rangeAxisState.getTicks());
        drawZeroRangeBaseline(g2, dataArea);
    }

    // draw the markers...
    for (int i = 0; i < this.renderers.size(); i++) {
        drawDomainMarkers(g2, dataArea, i, Layer.BACKGROUND);
    }
    for (int i = 0; i < this.renderers.size(); i++) {
        drawRangeMarkers(g2, dataArea, i, Layer.BACKGROUND);
    }

    // now render data items...
    boolean foundData = false;

    // set up the alpha-transparency...
    // TODO TRANSPARENCY
    /*
     * pa Composite originalComposite = g2.getComposite();
     * g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
     * getForegroundAlpha()));
     */

    DatasetRenderingOrder order = getDatasetRenderingOrder();
    if (order == DatasetRenderingOrder.FORWARD) {
        for (int i = 0; i < this.datasets.size(); i++) {
            foundData = render(g2, dataArea, i, state, crosshairState) || foundData;
        }
    } else { // DatasetRenderingOrder.REVERSE
        for (int i = this.datasets.size() - 1; i >= 0; i--) {
            foundData = render(g2, dataArea, i, state, crosshairState) || foundData;
        }
    }
    // draw the foreground markers...
    for (int i = 0; i < this.renderers.size(); i++) {
        drawDomainMarkers(g2, dataArea, i, Layer.FOREGROUND);
    }
    for (int i = 0; i < this.renderers.size(); i++) {
        drawRangeMarkers(g2, dataArea, i, Layer.FOREGROUND);
    }

    // draw the annotations (if any)...
    drawAnnotations(g2, dataArea);

    g2.restore();

    if (!foundData) {
        drawNoDataMessage(g2, dataArea);
    }

    int datasetIndex = crosshairState.getDatasetIndex();
    setCrosshairDatasetIndex(datasetIndex, false);

    // draw domain crosshair if required...
    Comparable rowKey = crosshairState.getRowKey();
    Comparable columnKey = crosshairState.getColumnKey();
    setDomainCrosshairRowKey(rowKey, false);
    setDomainCrosshairColumnKey(columnKey, false);
    if (isDomainCrosshairVisible() && columnKey != null) {
        Paint paint = getDomainCrosshairPaint();
        float stroke = getDomainCrosshairStroke();
        drawDomainCrosshair(g2, dataArea, this.orientation, datasetIndex, rowKey, columnKey, stroke, paint);
    }

    // draw range crosshair if required...
    ValueAxis yAxis = getRangeAxisForDataset(datasetIndex);
    RectangleEdge yAxisEdge = getRangeAxisEdge();
    if (!this.rangeCrosshairLockedOnData && anchor != null) {
        double yy;
        if (getOrientation() == PlotOrientation.VERTICAL) {
            yy = yAxis.java2DToValue(anchor.getY(), dataArea, yAxisEdge);
        } else {
            yy = yAxis.java2DToValue(anchor.getX(), dataArea, yAxisEdge);
        }
        crosshairState.setCrosshairY(yy);
    }
    setRangeCrosshairValue(crosshairState.getCrosshairY(), false);
    if (isRangeCrosshairVisible()) {
        double y = getRangeCrosshairValue();
        Paint paint = getRangeCrosshairPaint();
        float stroke = getRangeCrosshairStroke();
        drawRangeCrosshair(g2, dataArea, getOrientation(), y, yAxis, stroke, paint);
    }

    // draw an outline around the plot area...
    if (isOutlineVisible()) {
        if (getRenderer() != null) {
            getRenderer().drawOutline(g2, this, dataArea);
        } else {
            drawOutline(g2, dataArea);
        }
    }

}

From source file:net.droidsolutions.droidcharts.core.plot.XYPlot.java

/**
 * Draws the plot within the specified area on a graphics device.
 * //from w ww  .j a v a2  s . c o m
 * @param g2
 *            the graphics device.
 * @param area
 *            the plot area (in Java2D space).
 * @param anchor
 *            an anchor point in Java2D space (<code>null</code> permitted).
 * @param parentState
 *            the state from the parent plot, if there is one (
 *            <code>null</code> permitted).
 * @param info
 *            collects chart drawing information (<code>null</code>
 *            permitted).
 */
public void draw(Canvas g2, Rectangle2D area, Point2D anchor, PlotState parentState, PlotRenderingInfo info) {

    // if the plot area is too small, just return...
    boolean b1 = (area.getWidth() <= MINIMUM_WIDTH_TO_DRAW);
    boolean b2 = (area.getHeight() <= MINIMUM_HEIGHT_TO_DRAW);
    if (b1 || b2) {
        return;
    }

    // record the plot area...
    if (info != null) {
        info.setPlotArea(area);
    }

    // adjust the drawing area for the plot insets (if any)...
    RectangleInsets insets = getInsets();
    insets.trim(area);

    AxisSpace space = calculateAxisSpace(g2, area);
    Rectangle2D dataArea = space.shrink(area, null);
    this.axisOffset.trim(dataArea);
    createAndAddEntity((Rectangle2D) dataArea.clone(), info, null, null);
    if (info != null) {
        info.setDataArea(dataArea);
    }

    // draw the plot background and axes...
    drawBackground(g2, dataArea);
    Map axisStateMap = drawAxes(g2, area, dataArea, info);

    PlotOrientation orient = getOrientation();

    // the anchor point is typically the point where the mouse last
    // clicked - the crosshairs will be driven off this point...
    if (anchor != null && !dataArea.contains(anchor)) {
        anchor = null;
    }
    CrosshairState crosshairState = new CrosshairState();
    crosshairState.setCrosshairDistance(Double.POSITIVE_INFINITY);
    crosshairState.setAnchor(anchor);

    crosshairState.setAnchorX(Double.NaN);
    crosshairState.setAnchorY(Double.NaN);
    if (anchor != null) {
        ValueAxis domainAxis = getDomainAxis();
        if (domainAxis != null) {
            double x;
            if (orient == PlotOrientation.VERTICAL) {
                x = domainAxis.java2DToValue(anchor.getX(), dataArea, getDomainAxisEdge());
            } else {
                x = domainAxis.java2DToValue(anchor.getY(), dataArea, getDomainAxisEdge());
            }
            crosshairState.setAnchorX(x);
        }
        ValueAxis rangeAxis = getRangeAxis();
        if (rangeAxis != null) {
            double y;
            if (orient == PlotOrientation.VERTICAL) {
                y = rangeAxis.java2DToValue(anchor.getY(), dataArea, getRangeAxisEdge());
            } else {
                y = rangeAxis.java2DToValue(anchor.getX(), dataArea, getRangeAxisEdge());
            }
            crosshairState.setAnchorY(y);
        }
    }
    crosshairState.setCrosshairX(getDomainCrosshairValue());
    crosshairState.setCrosshairY(getRangeCrosshairValue());

    g2.save();
    g2.clipRect((float) dataArea.getMinX(), (float) dataArea.getMinY(), (float) dataArea.getMaxX(),
            (float) dataArea.getMaxY());

    AxisState domainAxisState = (AxisState) axisStateMap.get(getDomainAxis());
    if (domainAxisState == null) {
        if (parentState != null) {
            domainAxisState = (AxisState) parentState.getSharedAxisStates().get(getDomainAxis());
        }
    }

    AxisState rangeAxisState = (AxisState) axisStateMap.get(getRangeAxis());
    if (rangeAxisState == null) {
        if (parentState != null) {
            rangeAxisState = (AxisState) parentState.getSharedAxisStates().get(getRangeAxis());
        }
    }
    if (domainAxisState != null) {
        drawDomainTickBands(g2, dataArea, domainAxisState.getTicks());
    }
    if (rangeAxisState != null) {
        drawRangeTickBands(g2, dataArea, rangeAxisState.getTicks());
    }
    if (domainAxisState != null) {
        drawDomainGridlines(g2, dataArea, domainAxisState.getTicks());
        drawZeroDomainBaseline(g2, dataArea);
    }
    if (rangeAxisState != null) {
        drawRangeGridlines(g2, dataArea, rangeAxisState.getTicks());
        drawZeroRangeBaseline(g2, dataArea);
    }

    // draw the markers that are associated with a specific renderer...
    for (int i = 0; i < this.renderers.size(); i++) {
        drawDomainMarkers(g2, dataArea, i, Layer.BACKGROUND);
    }
    for (int i = 0; i < this.renderers.size(); i++) {
        drawRangeMarkers(g2, dataArea, i, Layer.BACKGROUND);
    }

    // now draw annotations and render data items...
    boolean foundData = false;
    DatasetRenderingOrder order = getDatasetRenderingOrder();
    if (order == DatasetRenderingOrder.FORWARD) {

        // draw background annotations
        int rendererCount = this.renderers.size();
        for (int i = 0; i < rendererCount; i++) {
            XYItemRenderer r = getRenderer(i);
            if (r != null) {
                ValueAxis domainAxis = getDomainAxisForDataset(i);
                ValueAxis rangeAxis = getRangeAxisForDataset(i);
                r.drawAnnotations(g2, dataArea, domainAxis, rangeAxis, Layer.BACKGROUND, info);
            }
        }

        // render data items...
        for (int i = 0; i < getDatasetCount(); i++) {
            foundData = render(g2, dataArea, i, info, crosshairState) || foundData;
        }

        // draw foreground annotations
        for (int i = 0; i < rendererCount; i++) {
            XYItemRenderer r = getRenderer(i);
            if (r != null) {
                ValueAxis domainAxis = getDomainAxisForDataset(i);
                ValueAxis rangeAxis = getRangeAxisForDataset(i);
                r.drawAnnotations(g2, dataArea, domainAxis, rangeAxis, Layer.FOREGROUND, info);
            }
        }

    } else if (order == DatasetRenderingOrder.REVERSE) {

        // draw background annotations
        int rendererCount = this.renderers.size();
        for (int i = rendererCount - 1; i >= 0; i--) {
            XYItemRenderer r = getRenderer(i);
            if (i >= getDatasetCount()) { // we need the dataset to make
                continue; // a link to the axes
            }
            if (r != null) {
                ValueAxis domainAxis = getDomainAxisForDataset(i);
                ValueAxis rangeAxis = getRangeAxisForDataset(i);
                r.drawAnnotations(g2, dataArea, domainAxis, rangeAxis, Layer.BACKGROUND, info);
            }
        }

        for (int i = getDatasetCount() - 1; i >= 0; i--) {
            foundData = render(g2, dataArea, i, info, crosshairState) || foundData;
        }

        // draw foreground annotations
        for (int i = rendererCount - 1; i >= 0; i--) {
            XYItemRenderer r = getRenderer(i);
            if (i >= getDatasetCount()) { // we need the dataset to make
                continue; // a link to the axes
            }
            if (r != null) {
                ValueAxis domainAxis = getDomainAxisForDataset(i);
                ValueAxis rangeAxis = getRangeAxisForDataset(i);
                r.drawAnnotations(g2, dataArea, domainAxis, rangeAxis, Layer.FOREGROUND, info);
            }
        }

    }

    // draw domain crosshair if required...
    int xAxisIndex = crosshairState.getDomainAxisIndex();
    ValueAxis xAxis = getDomainAxis(xAxisIndex);
    RectangleEdge xAxisEdge = getDomainAxisEdge(xAxisIndex);
    if (!this.domainCrosshairLockedOnData && anchor != null) {
        double xx;
        if (orient == PlotOrientation.VERTICAL) {
            xx = xAxis.java2DToValue(anchor.getX(), dataArea, xAxisEdge);
        } else {
            xx = xAxis.java2DToValue(anchor.getY(), dataArea, xAxisEdge);
        }
        crosshairState.setCrosshairX(xx);
    }
    setDomainCrosshairValue(crosshairState.getCrosshairX(), false);
    if (isDomainCrosshairVisible()) {
        double x = getDomainCrosshairValue();
        Paint paint = getDomainCrosshairPaint();
        int oldAlpha = paint.getAlpha();
        paint.setAlpha(getForegroundAlpha());
        Float stroke = getDomainCrosshairStroke();
        drawDomainCrosshair(g2, dataArea, orient, x, xAxis, stroke, paint);
        paint.setAlpha(oldAlpha);
    }

    // draw range crosshair if required...
    int yAxisIndex = crosshairState.getRangeAxisIndex();
    ValueAxis yAxis = getRangeAxis(yAxisIndex);
    RectangleEdge yAxisEdge = getRangeAxisEdge(yAxisIndex);
    if (!this.rangeCrosshairLockedOnData && anchor != null) {
        double yy;
        if (orient == PlotOrientation.VERTICAL) {
            yy = yAxis.java2DToValue(anchor.getY(), dataArea, yAxisEdge);
        } else {
            yy = yAxis.java2DToValue(anchor.getX(), dataArea, yAxisEdge);
        }
        crosshairState.setCrosshairY(yy);
    }
    setRangeCrosshairValue(crosshairState.getCrosshairY(), false);
    if (isRangeCrosshairVisible()) {
        double y = getRangeCrosshairValue();
        Paint paint = getRangeCrosshairPaint();
        int oldAlpha = paint.getAlpha();
        paint.setAlpha(getForegroundAlpha());
        Float stroke = getRangeCrosshairStroke();
        drawRangeCrosshair(g2, dataArea, orient, y, yAxis, stroke, paint);
        paint.setAlpha(oldAlpha);
    }

    if (!foundData) {
        drawNoDataMessage(g2, dataArea);
    }

    for (int i = 0; i < this.renderers.size(); i++) {
        drawDomainMarkers(g2, dataArea, i, Layer.FOREGROUND);
    }
    for (int i = 0; i < this.renderers.size(); i++) {
        drawRangeMarkers(g2, dataArea, i, Layer.FOREGROUND);
    }

    drawAnnotations(g2, dataArea, info);
    g2.restore();
    drawOutline(g2, dataArea);

}

From source file:android.support.v7.widget.RecyclerViewEx.java

@Override
public void draw(Canvas c) {
    super.draw(c);

    final int count = mItemDecorations.size();
    for (int i = 0; i < count; i++) {
        mItemDecorations.get(i).onDrawOver(c, this, mState);
    }//  ww  w.  j a  v a 2 s .  c o m
    // TODO If padding is not 0 and chilChildrenToPadding is false, to draw glows properly, we
    // need find children closest to edges. Not sure if it is worth the effort.
    boolean needsInvalidate = false;
    if (mLeftGlow != null && !mLeftGlow.isFinished()) {
        final int restore = c.save();
        final int padding = mClipToPadding ? getPaddingBottom() : 0;
        c.rotate(270);
        c.translate(-getHeight() + padding, 0);
        needsInvalidate = mLeftGlow != null && mLeftGlow.draw(c);
        c.restoreToCount(restore);
    }
    if (mTopGlow != null && !mTopGlow.isFinished()) {
        final int restore = c.save();
        if (mClipToPadding) {
            c.translate(getPaddingLeft(), getPaddingTop());
        }
        needsInvalidate |= mTopGlow != null && mTopGlow.draw(c);
        c.restoreToCount(restore);
    }
    if (mRightGlow != null && !mRightGlow.isFinished()) {
        final int restore = c.save();
        final int width = getWidth();
        final int padding = mClipToPadding ? getPaddingTop() : 0;
        c.rotate(90);
        c.translate(-padding, -width);
        needsInvalidate |= mRightGlow != null && mRightGlow.draw(c);
        c.restoreToCount(restore);
    }
    if (mBottomGlow != null && !mBottomGlow.isFinished()) {
        final int restore = c.save();
        c.rotate(180);
        if (mClipToPadding) {
            c.translate(-getWidth() + getPaddingRight(), -getHeight() + getPaddingBottom());
        } else {
            c.translate(-getWidth(), -getHeight());
        }
        needsInvalidate |= mBottomGlow != null && mBottomGlow.draw(c);
        c.restoreToCount(restore);
    }

    // If some views are animating, ItemDecorators are likely to move/change with them.
    // Invalidate RecyclerViewEx to re-draw decorators. This is still efficient because children's
    // display lists are not invalidated.
    if (!needsInvalidate && mItemAnimator != null && mItemDecorations.size() > 0 && mItemAnimator.isRunning()) {
        needsInvalidate = true;
    }

    if (needsInvalidate) {
        ViewCompat.postInvalidateOnAnimation(this);
    }
}

From source file:org.telegram.ui.PassportActivity.java

private void createAddressInterface(Context context) {
    languageMap = new HashMap<>();
    try {/*  w  w  w  .  ja va  2s .c  om*/
        BufferedReader reader = new BufferedReader(
                new InputStreamReader(context.getResources().getAssets().open("countries.txt")));
        String line;
        while ((line = reader.readLine()) != null) {
            String[] args = line.split(";");
            languageMap.put(args[1], args[2]);
        }
        reader.close();
    } catch (Exception e) {
        FileLog.e(e);
    }

    topErrorCell = new TextInfoPrivacyCell(context);
    topErrorCell.setBackgroundDrawable(
            Theme.getThemedDrawable(context, R.drawable.greydivider_top, Theme.key_windowBackgroundGrayShadow));
    topErrorCell.setPadding(0, AndroidUtilities.dp(7), 0, 0);
    linearLayout2.addView(topErrorCell,
            LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
    checkTopErrorCell(true);

    if (currentDocumentsType != null) {
        if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeRentalAgreement) {
            actionBar.setTitle(LocaleController.getString("ActionBotDocumentRentalAgreement",
                    R.string.ActionBotDocumentRentalAgreement));
        } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeBankStatement) {
            actionBar.setTitle(LocaleController.getString("ActionBotDocumentBankStatement",
                    R.string.ActionBotDocumentBankStatement));
        } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeUtilityBill) {
            actionBar.setTitle(LocaleController.getString("ActionBotDocumentUtilityBill",
                    R.string.ActionBotDocumentUtilityBill));
        } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypePassportRegistration) {
            actionBar.setTitle(LocaleController.getString("ActionBotDocumentPassportRegistration",
                    R.string.ActionBotDocumentPassportRegistration));
        } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeTemporaryRegistration) {
            actionBar.setTitle(LocaleController.getString("ActionBotDocumentTemporaryRegistration",
                    R.string.ActionBotDocumentTemporaryRegistration));
        }

        headerCell = new HeaderCell(context);
        headerCell.setText(LocaleController.getString("PassportDocuments", R.string.PassportDocuments));
        headerCell.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
        linearLayout2.addView(headerCell,
                LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

        documentsLayout = new LinearLayout(context);
        documentsLayout.setOrientation(LinearLayout.VERTICAL);
        linearLayout2.addView(documentsLayout,
                LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

        uploadDocumentCell = new TextSettingsCell(context);
        uploadDocumentCell.setBackgroundDrawable(Theme.getSelectorDrawable(true));
        linearLayout2.addView(uploadDocumentCell,
                LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
        uploadDocumentCell.setOnClickListener(v -> {
            uploadingFileType = UPLOADING_TYPE_DOCUMENTS;
            openAttachMenu();
        });

        bottomCell = new TextInfoPrivacyCell(context);
        bottomCell.setBackgroundDrawable(
                Theme.getThemedDrawable(context, R.drawable.greydivider, Theme.key_windowBackgroundGrayShadow));

        if (currentBotId != 0) {
            noAllDocumentsErrorText = LocaleController.getString("PassportAddAddressUploadInfo",
                    R.string.PassportAddAddressUploadInfo);
        } else {
            if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeRentalAgreement) {
                noAllDocumentsErrorText = LocaleController.getString("PassportAddAgreementInfo",
                        R.string.PassportAddAgreementInfo);
            } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeUtilityBill) {
                noAllDocumentsErrorText = LocaleController.getString("PassportAddBillInfo",
                        R.string.PassportAddBillInfo);
            } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypePassportRegistration) {
                noAllDocumentsErrorText = LocaleController.getString("PassportAddPassportRegistrationInfo",
                        R.string.PassportAddPassportRegistrationInfo);
            } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeTemporaryRegistration) {
                noAllDocumentsErrorText = LocaleController.getString("PassportAddTemporaryRegistrationInfo",
                        R.string.PassportAddTemporaryRegistrationInfo);
            } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeBankStatement) {
                noAllDocumentsErrorText = LocaleController.getString("PassportAddBankInfo",
                        R.string.PassportAddBankInfo);
            } else {
                noAllDocumentsErrorText = "";
            }
        }

        CharSequence text = noAllDocumentsErrorText;
        if (documentsErrors != null) {
            String errorText;
            if ((errorText = documentsErrors.get("files_all")) != null) {
                SpannableStringBuilder stringBuilder = new SpannableStringBuilder(errorText);
                stringBuilder.append("\n\n");
                stringBuilder.append(noAllDocumentsErrorText);
                text = stringBuilder;
                stringBuilder.setSpan(
                        new ForegroundColorSpan(Theme.getColor(Theme.key_windowBackgroundWhiteRedText3)), 0,
                        errorText.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
                errorsValues.put("files_all", "");
            }
        }
        bottomCell.setText(text);
        linearLayout2.addView(bottomCell,
                LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

        if (currentDocumentsType.translation_required) {
            headerCell = new HeaderCell(context);
            headerCell.setText(LocaleController.getString("PassportTranslation", R.string.PassportTranslation));
            headerCell.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
            linearLayout2.addView(headerCell,
                    LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

            translationLayout = new LinearLayout(context);
            translationLayout.setOrientation(LinearLayout.VERTICAL);
            linearLayout2.addView(translationLayout,
                    LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

            uploadTranslationCell = new TextSettingsCell(context);
            uploadTranslationCell.setBackgroundDrawable(Theme.getSelectorDrawable(true));
            linearLayout2.addView(uploadTranslationCell,
                    LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
            uploadTranslationCell.setOnClickListener(v -> {
                uploadingFileType = UPLOADING_TYPE_TRANSLATION;
                openAttachMenu();
            });

            bottomCellTranslation = new TextInfoPrivacyCell(context);
            bottomCellTranslation.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider,
                    Theme.key_windowBackgroundGrayShadow));

            if (currentBotId != 0) {
                noAllTranslationErrorText = LocaleController.getString("PassportAddTranslationUploadInfo",
                        R.string.PassportAddTranslationUploadInfo);
            } else {
                if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeRentalAgreement) {
                    noAllTranslationErrorText = LocaleController.getString(
                            "PassportAddTranslationAgreementInfo",
                            R.string.PassportAddTranslationAgreementInfo);
                } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeUtilityBill) {
                    noAllTranslationErrorText = LocaleController.getString("PassportAddTranslationBillInfo",
                            R.string.PassportAddTranslationBillInfo);
                } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypePassportRegistration) {
                    noAllTranslationErrorText = LocaleController.getString(
                            "PassportAddTranslationPassportRegistrationInfo",
                            R.string.PassportAddTranslationPassportRegistrationInfo);
                } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeTemporaryRegistration) {
                    noAllTranslationErrorText = LocaleController.getString(
                            "PassportAddTranslationTemporaryRegistrationInfo",
                            R.string.PassportAddTranslationTemporaryRegistrationInfo);
                } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeBankStatement) {
                    noAllTranslationErrorText = LocaleController.getString("PassportAddTranslationBankInfo",
                            R.string.PassportAddTranslationBankInfo);
                } else {
                    noAllTranslationErrorText = "";
                }
            }

            text = noAllTranslationErrorText;
            if (documentsErrors != null) {
                String errorText;
                if ((errorText = documentsErrors.get("translation_all")) != null) {
                    SpannableStringBuilder stringBuilder = new SpannableStringBuilder(errorText);
                    stringBuilder.append("\n\n");
                    stringBuilder.append(noAllTranslationErrorText);
                    text = stringBuilder;
                    stringBuilder.setSpan(
                            new ForegroundColorSpan(Theme.getColor(Theme.key_windowBackgroundWhiteRedText3)), 0,
                            errorText.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
                    errorsValues.put("translation_all", "");
                }
            }
            bottomCellTranslation.setText(text);
            linearLayout2.addView(bottomCellTranslation,
                    LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
        }
    } else {
        actionBar.setTitle(LocaleController.getString("PassportAddress", R.string.PassportAddress));
    }

    headerCell = new HeaderCell(context);
    headerCell.setText(LocaleController.getString("PassportAddressHeader", R.string.PassportAddressHeader));
    headerCell.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
    linearLayout2.addView(headerCell,
            LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

    inputFields = new EditTextBoldCursor[FIELD_ADDRESS_COUNT];
    for (int a = 0; a < FIELD_ADDRESS_COUNT; a++) {
        final EditTextBoldCursor field = new EditTextBoldCursor(context);
        inputFields[a] = field;

        ViewGroup container = new FrameLayout(context) {

            private StaticLayout errorLayout;
            float offsetX;

            @Override
            protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
                int width = MeasureSpec.getSize(widthMeasureSpec) - AndroidUtilities.dp(34);
                errorLayout = field.getErrorLayout(width);
                if (errorLayout != null) {
                    int lineCount = errorLayout.getLineCount();
                    if (lineCount > 1) {
                        int height = AndroidUtilities.dp(64)
                                + (errorLayout.getLineBottom(lineCount - 1) - errorLayout.getLineBottom(0));
                        heightMeasureSpec = MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY);
                    }
                    if (LocaleController.isRTL) {
                        float maxW = 0;
                        for (int a = 0; a < lineCount; a++) {
                            float l = errorLayout.getLineLeft(a);
                            if (l != 0) {
                                offsetX = 0;
                                break;
                            }
                            maxW = Math.max(maxW, errorLayout.getLineWidth(a));
                            if (a == lineCount - 1) {
                                offsetX = width - maxW;
                            }
                        }
                    }
                }
                super.onMeasure(widthMeasureSpec, heightMeasureSpec);
            }

            @Override
            protected void onDraw(Canvas canvas) {
                if (errorLayout != null) {
                    canvas.save();
                    canvas.translate(AndroidUtilities.dp(21) + offsetX,
                            field.getLineY() + AndroidUtilities.dp(3));
                    errorLayout.draw(canvas);
                    canvas.restore();
                }
            }
        };
        container.setWillNotDraw(false);
        linearLayout2.addView(container,
                LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
        container.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));

        if (a == FIELD_ADDRESS_COUNT - 1) {
            extraBackgroundView = new View(context);
            extraBackgroundView.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
            linearLayout2.addView(extraBackgroundView, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 6));
        }

        if (documentOnly && currentDocumentsType != null) {
            container.setVisibility(View.GONE);
            if (extraBackgroundView != null) {
                extraBackgroundView.setVisibility(View.GONE);
            }
        }

        inputFields[a].setTag(a);
        inputFields[a].setSupportRtlHint(true);
        inputFields[a].setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
        inputFields[a].setHintColor(Theme.getColor(Theme.key_windowBackgroundWhiteHintText));
        inputFields[a].setHeaderHintColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlueHeader));
        inputFields[a].setTransformHintToHeader(true);
        inputFields[a].setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
        inputFields[a].setBackgroundDrawable(null);
        inputFields[a].setCursorColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
        inputFields[a].setCursorSize(AndroidUtilities.dp(20));
        inputFields[a].setCursorWidth(1.5f);
        inputFields[a].setLineColors(Theme.getColor(Theme.key_windowBackgroundWhiteInputField),
                Theme.getColor(Theme.key_windowBackgroundWhiteInputFieldActivated),
                Theme.getColor(Theme.key_windowBackgroundWhiteRedText3));
        if (a == FIELD_COUNTRY) {
            inputFields[a].setOnTouchListener((v, event) -> {
                if (getParentActivity() == null) {
                    return false;
                }
                if (event.getAction() == MotionEvent.ACTION_UP) {
                    CountrySelectActivity fragment = new CountrySelectActivity(false);
                    fragment.setCountrySelectActivityDelegate((name, shortName) -> {
                        inputFields[FIELD_COUNTRY].setText(name);
                        currentCitizeship = shortName;
                    });
                    presentFragment(fragment);
                }
                return true;
            });
            inputFields[a].setInputType(0);
            inputFields[a].setFocusable(false);
        } else {
            inputFields[a].setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_CAP_SENTENCES);
            inputFields[a].setImeOptions(EditorInfo.IME_ACTION_NEXT | EditorInfo.IME_FLAG_NO_EXTRACT_UI);
        }
        String value;
        final String key;
        switch (a) {
        case FIELD_STREET1:
            inputFields[a].setHintText(LocaleController.getString("PassportStreet1", R.string.PassportStreet1));
            key = "street_line1";
            break;
        case FIELD_STREET2:
            inputFields[a].setHintText(LocaleController.getString("PassportStreet2", R.string.PassportStreet2));
            key = "street_line2";
            break;
        case FIELD_CITY:
            inputFields[a].setHintText(LocaleController.getString("PassportCity", R.string.PassportCity));
            key = "city";
            break;
        case FIELD_STATE:
            inputFields[a].setHintText(LocaleController.getString("PassportState", R.string.PassportState));
            key = "state";
            break;
        case FIELD_COUNTRY:
            inputFields[a].setHintText(LocaleController.getString("PassportCountry", R.string.PassportCountry));
            key = "country_code";
            break;
        case FIELD_POSTCODE:
            inputFields[a]
                    .setHintText(LocaleController.getString("PassportPostcode", R.string.PassportPostcode));
            key = "post_code";
            break;
        default:
            continue;
        }
        setFieldValues(currentValues, inputFields[a], key);
        if (a == FIELD_POSTCODE) {
            inputFields[a].addTextChangedListener(new TextWatcher() {

                private boolean ignore;

                @Override
                public void beforeTextChanged(CharSequence s, int start, int count, int after) {

                }

                @Override
                public void onTextChanged(CharSequence s, int start, int before, int count) {

                }

                @Override
                public void afterTextChanged(Editable s) {
                    if (ignore) {
                        return;
                    }
                    ignore = true;
                    boolean error = false;
                    for (int a = 0; a < s.length(); a++) {
                        char ch = s.charAt(a);
                        if (!(ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z' || ch >= '0' && ch <= '9'
                                || ch == '-' || ch == ' ')) {
                            error = true;
                            break;
                        }
                    }
                    ignore = false;
                    if (error) {
                        field.setErrorText(LocaleController.getString("PassportUseLatinOnly",
                                R.string.PassportUseLatinOnly));
                    } else {
                        checkFieldForError(field, key, s, false);
                    }
                }
            });
            InputFilter[] inputFilters = new InputFilter[1];
            inputFilters[0] = new InputFilter.LengthFilter(10);
            inputFields[a].setFilters(inputFilters);
        } else {
            inputFields[a].addTextChangedListener(new TextWatcher() {
                @Override
                public void beforeTextChanged(CharSequence s, int start, int count, int after) {

                }

                @Override
                public void onTextChanged(CharSequence s, int start, int before, int count) {

                }

                @Override
                public void afterTextChanged(Editable s) {
                    checkFieldForError(field, key, s, false);
                }
            });
        }

        inputFields[a].setSelection(inputFields[a].length());
        inputFields[a].setPadding(0, 0, 0, 0);
        inputFields[a]
                .setGravity((LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT) | Gravity.CENTER_VERTICAL);
        container.addView(inputFields[a], LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, 64,
                Gravity.LEFT | Gravity.TOP, 21, 0, 21, 0));

        inputFields[a].setOnEditorActionListener((textView, i, keyEvent) -> {
            if (i == EditorInfo.IME_ACTION_NEXT) {
                int num = (Integer) textView.getTag();
                num++;
                if (num < inputFields.length) {
                    if (inputFields[num].isFocusable()) {
                        inputFields[num].requestFocus();
                    } else {
                        inputFields[num]
                                .dispatchTouchEvent(MotionEvent.obtain(0, 0, MotionEvent.ACTION_UP, 0, 0, 0));
                        textView.clearFocus();
                        AndroidUtilities.hideKeyboard(textView);
                    }
                }
                return true;
            }
            return false;
        });
    }

    sectionCell = new ShadowSectionCell(context);
    linearLayout2.addView(sectionCell,
            LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

    if (documentOnly && currentDocumentsType != null) {
        headerCell.setVisibility(View.GONE);
        sectionCell.setVisibility(View.GONE);
    }

    if ((currentBotId != 0 || currentDocumentsType == null) && currentTypeValue != null && !documentOnly
            || currentDocumentsTypeValue != null) {
        if (currentDocumentsTypeValue != null) {
            addDocumentViews(currentDocumentsTypeValue.files);
            addTranslationDocumentViews(currentDocumentsTypeValue.translation);
        }
        sectionCell.setBackgroundDrawable(
                Theme.getThemedDrawable(context, R.drawable.greydivider, Theme.key_windowBackgroundGrayShadow));

        TextSettingsCell settingsCell1 = new TextSettingsCell(context);
        settingsCell1.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteRedText3));
        settingsCell1.setBackgroundDrawable(Theme.getSelectorDrawable(true));
        if (currentDocumentsType == null) {
            settingsCell1.setText(LocaleController.getString("PassportDeleteInfo", R.string.PassportDeleteInfo),
                    false);
        } else {
            settingsCell1.setText(
                    LocaleController.getString("PassportDeleteDocument", R.string.PassportDeleteDocument),
                    false);
        }
        linearLayout2.addView(settingsCell1,
                LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
        settingsCell1.setOnClickListener(v -> createDocumentDeleteAlert());

        sectionCell = new ShadowSectionCell(context);
        sectionCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider_bottom,
                Theme.key_windowBackgroundGrayShadow));
        linearLayout2.addView(sectionCell,
                LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
    } else {
        sectionCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider_bottom,
                Theme.key_windowBackgroundGrayShadow));
        if (documentOnly && currentDocumentsType != null) {
            bottomCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider_bottom,
                    Theme.key_windowBackgroundGrayShadow));
        }
    }
    updateUploadText(UPLOADING_TYPE_DOCUMENTS);
    updateUploadText(UPLOADING_TYPE_TRANSLATION);
}

From source file:kr.wdream.ui.PhotoViewer.java

@SuppressLint("NewApi")
private void onDraw(Canvas canvas) {
    if (animationInProgress == 1 || !isVisible && animationInProgress != 2) {
        return;//from w  w w . j  a  v a  2 s .c  om
    }

    float currentTranslationY;
    float currentTranslationX;
    float currentScale;
    float aty = -1;

    if (imageMoveAnimation != null) {
        if (!scroller.isFinished()) {
            scroller.abortAnimation();
        }

        float ts = scale + (animateToScale - scale) * animationValue;
        float tx = translationX + (animateToX - translationX) * animationValue;
        float ty = translationY + (animateToY - translationY) * animationValue;
        if (currentEditMode == 1) {
            photoCropView.setAnimationProgress(animationValue);
        }

        if (animateToScale == 1 && scale == 1 && translationX == 0) {
            aty = ty;
        }
        currentScale = ts;
        currentTranslationY = ty;
        currentTranslationX = tx;
        containerView.invalidate();
    } else {
        if (animationStartTime != 0) {
            translationX = animateToX;
            translationY = animateToY;
            scale = animateToScale;
            animationStartTime = 0;
            if (currentEditMode == 1) {
                photoCropView.setAnimationProgress(1);
            }
            updateMinMax(scale);
            zoomAnimation = false;
        }
        if (!scroller.isFinished()) {
            if (scroller.computeScrollOffset()) {
                if (scroller.getStartX() < maxX && scroller.getStartX() > minX) {
                    translationX = scroller.getCurrX();
                }
                if (scroller.getStartY() < maxY && scroller.getStartY() > minY) {
                    translationY = scroller.getCurrY();
                }
                containerView.invalidate();
            }
        }
        if (switchImageAfterAnimation != 0) {
            if (switchImageAfterAnimation == 1) {
                setImageIndex(currentIndex + 1, false);
            } else if (switchImageAfterAnimation == 2) {
                setImageIndex(currentIndex - 1, false);
            }
            switchImageAfterAnimation = 0;
        }
        currentScale = scale;
        currentTranslationY = translationY;
        currentTranslationX = translationX;
        if (!moving) {
            aty = translationY;
        }
    }

    if (currentEditMode == 0 && scale == 1 && aty != -1 && !zoomAnimation) {
        float maxValue = getContainerViewHeight() / 4.0f;
        backgroundDrawable
                .setAlpha((int) Math.max(127, 255 * (1.0f - (Math.min(Math.abs(aty), maxValue) / maxValue))));
    } else {
        backgroundDrawable.setAlpha(255);
    }

    ImageReceiver sideImage = null;
    if (currentEditMode == 0) {
        if (scale >= 1.0f && !zoomAnimation && !zooming) {
            if (currentTranslationX > maxX + AndroidUtilities.dp(5)) {
                sideImage = leftImage;
            } else if (currentTranslationX < minX - AndroidUtilities.dp(5)) {
                sideImage = rightImage;
            }
        }
        changingPage = sideImage != null;
    }

    if (sideImage == rightImage) {
        float tranlateX = currentTranslationX;
        float scaleDiff = 0;
        float alpha = 1;
        if (!zoomAnimation && tranlateX < minX) {
            alpha = Math.min(1.0f, (minX - tranlateX) / canvas.getWidth());
            scaleDiff = (1.0f - alpha) * 0.3f;
            tranlateX = -canvas.getWidth() - AndroidUtilities.dp(30) / 2;
        }

        if (sideImage.hasBitmapImage()) {
            canvas.save();
            canvas.translate(getContainerViewWidth() / 2, getContainerViewHeight() / 2);
            canvas.translate(canvas.getWidth() + AndroidUtilities.dp(30) / 2 + tranlateX, 0);
            canvas.scale(1.0f - scaleDiff, 1.0f - scaleDiff);
            int bitmapWidth = sideImage.getBitmapWidth();
            int bitmapHeight = sideImage.getBitmapHeight();

            float scaleX = (float) getContainerViewWidth() / (float) bitmapWidth;
            float scaleY = (float) getContainerViewHeight() / (float) bitmapHeight;
            float scale = scaleX > scaleY ? scaleY : scaleX;
            int width = (int) (bitmapWidth * scale);
            int height = (int) (bitmapHeight * scale);

            sideImage.setAlpha(alpha);
            sideImage.setImageCoords(-width / 2, -height / 2, width, height);
            sideImage.draw(canvas);
            canvas.restore();
        }

        canvas.save();
        canvas.translate(tranlateX, currentTranslationY / currentScale);
        canvas.translate((canvas.getWidth() * (scale + 1) + AndroidUtilities.dp(30)) / 2,
                -currentTranslationY / currentScale);
        radialProgressViews[1].setScale(1.0f - scaleDiff);
        radialProgressViews[1].setAlpha(alpha);
        radialProgressViews[1].onDraw(canvas);
        canvas.restore();
    }

    float translateX = currentTranslationX;
    float scaleDiff = 0;
    float alpha = 1;
    if (!zoomAnimation && translateX > maxX && currentEditMode == 0) {
        alpha = Math.min(1.0f, (translateX - maxX) / canvas.getWidth());
        scaleDiff = alpha * 0.3f;
        alpha = 1.0f - alpha;
        translateX = maxX;
    }
    boolean drawTextureView = Build.VERSION.SDK_INT >= 16 && aspectRatioFrameLayout != null
            && aspectRatioFrameLayout.getVisibility() == View.VISIBLE;
    if (centerImage.hasBitmapImage()) {
        canvas.save();
        canvas.translate(getContainerViewWidth() / 2 + getAdditionX(),
                getContainerViewHeight() / 2 + getAdditionY());
        canvas.translate(translateX, currentTranslationY);
        canvas.scale(currentScale - scaleDiff, currentScale - scaleDiff);

        if (currentEditMode == 1) {
            photoCropView.setBitmapParams(currentScale, translateX, currentTranslationY);
        }

        int bitmapWidth = centerImage.getBitmapWidth();
        int bitmapHeight = centerImage.getBitmapHeight();
        if (drawTextureView && textureUploaded) {
            float scale1 = bitmapWidth / (float) bitmapHeight;
            float scale2 = videoTextureView.getMeasuredWidth() / (float) videoTextureView.getMeasuredHeight();
            if (Math.abs(scale1 - scale2) > 0.01f) {
                bitmapWidth = videoTextureView.getMeasuredWidth();
                bitmapHeight = videoTextureView.getMeasuredHeight();
            }
        }

        float scaleX = (float) getContainerViewWidth() / (float) bitmapWidth;
        float scaleY = (float) getContainerViewHeight() / (float) bitmapHeight;
        float scale = scaleX > scaleY ? scaleY : scaleX;
        int width = (int) (bitmapWidth * scale);
        int height = (int) (bitmapHeight * scale);

        if (!drawTextureView || !textureUploaded || !videoCrossfadeStarted || videoCrossfadeAlpha != 1.0f) {
            centerImage.setAlpha(alpha);
            centerImage.setImageCoords(-width / 2, -height / 2, width, height);
            centerImage.draw(canvas);
        }
        if (drawTextureView) {
            if (!videoCrossfadeStarted && textureUploaded) {
                videoCrossfadeStarted = true;
                videoCrossfadeAlpha = 0.0f;
                videoCrossfadeAlphaLastTime = System.currentTimeMillis();
            }
            canvas.translate(-width / 2, -height / 2);
            videoTextureView.setAlpha(alpha * videoCrossfadeAlpha);
            aspectRatioFrameLayout.draw(canvas);
            if (videoCrossfadeStarted && videoCrossfadeAlpha < 1.0f) {
                long newUpdateTime = System.currentTimeMillis();
                long dt = newUpdateTime - videoCrossfadeAlphaLastTime;
                videoCrossfadeAlphaLastTime = newUpdateTime;
                videoCrossfadeAlpha += dt / 300.0f;
                containerView.invalidate();
                if (videoCrossfadeAlpha > 1.0f) {
                    videoCrossfadeAlpha = 1.0f;
                }
            }
        }
        canvas.restore();
    }
    if (!drawTextureView && (videoPlayerControlFrameLayout == null
            || videoPlayerControlFrameLayout.getVisibility() != View.VISIBLE)) {
        canvas.save();
        canvas.translate(translateX, currentTranslationY / currentScale);
        radialProgressViews[0].setScale(1.0f - scaleDiff);
        radialProgressViews[0].setAlpha(alpha);
        radialProgressViews[0].onDraw(canvas);
        canvas.restore();
    }

    if (sideImage == leftImage) {
        if (sideImage.hasBitmapImage()) {
            canvas.save();
            canvas.translate(getContainerViewWidth() / 2, getContainerViewHeight() / 2);
            canvas.translate(
                    -(canvas.getWidth() * (scale + 1) + AndroidUtilities.dp(30)) / 2 + currentTranslationX, 0);
            int bitmapWidth = sideImage.getBitmapWidth();
            int bitmapHeight = sideImage.getBitmapHeight();

            float scaleX = (float) getContainerViewWidth() / (float) bitmapWidth;
            float scaleY = (float) getContainerViewHeight() / (float) bitmapHeight;
            float scale = scaleX > scaleY ? scaleY : scaleX;
            int width = (int) (bitmapWidth * scale);
            int height = (int) (bitmapHeight * scale);

            sideImage.setAlpha(1.0f);
            sideImage.setImageCoords(-width / 2, -height / 2, width, height);
            sideImage.draw(canvas);
            canvas.restore();
        }

        canvas.save();
        canvas.translate(currentTranslationX, currentTranslationY / currentScale);
        canvas.translate(-(canvas.getWidth() * (scale + 1) + AndroidUtilities.dp(30)) / 2,
                -currentTranslationY / currentScale);
        radialProgressViews[2].setScale(1.0f);
        radialProgressViews[2].setAlpha(1.0f);
        radialProgressViews[2].onDraw(canvas);
        canvas.restore();
    }
}

From source file:org.telegram.ui.PassportActivity.java

private void createIdentityInterface(final Context context) {
    languageMap = new HashMap<>();
    try {//from w  w w. ja  v  a 2  s  . c  o m
        BufferedReader reader = new BufferedReader(
                new InputStreamReader(context.getResources().getAssets().open("countries.txt")));
        String line;
        while ((line = reader.readLine()) != null) {
            String[] args = line.split(";");
            languageMap.put(args[1], args[2]);
        }
        reader.close();
    } catch (Exception e) {
        FileLog.e(e);
    }

    topErrorCell = new TextInfoPrivacyCell(context);
    topErrorCell.setBackgroundDrawable(
            Theme.getThemedDrawable(context, R.drawable.greydivider_top, Theme.key_windowBackgroundGrayShadow));
    topErrorCell.setPadding(0, AndroidUtilities.dp(7), 0, 0);
    linearLayout2.addView(topErrorCell,
            LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
    checkTopErrorCell(true);

    if (currentDocumentsType != null) {
        headerCell = new HeaderCell(context);
        if (documentOnly) {
            headerCell.setText(LocaleController.getString("PassportDocuments", R.string.PassportDocuments));
        } else {
            headerCell.setText(LocaleController.getString("PassportRequiredDocuments",
                    R.string.PassportRequiredDocuments));
        }
        headerCell.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
        linearLayout2.addView(headerCell,
                LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

        frontLayout = new LinearLayout(context);
        frontLayout.setOrientation(LinearLayout.VERTICAL);
        linearLayout2.addView(frontLayout,
                LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

        uploadFrontCell = new TextDetailSettingsCell(context);
        uploadFrontCell.setBackgroundDrawable(Theme.getSelectorDrawable(true));
        linearLayout2.addView(uploadFrontCell,
                LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
        uploadFrontCell.setOnClickListener(v -> {
            uploadingFileType = UPLOADING_TYPE_FRONT;
            openAttachMenu();
        });

        reverseLayout = new LinearLayout(context);
        reverseLayout.setOrientation(LinearLayout.VERTICAL);
        linearLayout2.addView(reverseLayout,
                LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

        boolean divider = currentDocumentsType.selfie_required;

        uploadReverseCell = new TextDetailSettingsCell(context);
        uploadReverseCell.setBackgroundDrawable(Theme.getSelectorDrawable(true));
        uploadReverseCell.setTextAndValue(
                LocaleController.getString("PassportReverseSide", R.string.PassportReverseSide),
                LocaleController.getString("PassportReverseSideInfo", R.string.PassportReverseSideInfo),
                divider);
        linearLayout2.addView(uploadReverseCell,
                LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
        uploadReverseCell.setOnClickListener(v -> {
            uploadingFileType = UPLOADING_TYPE_REVERSE;
            openAttachMenu();
        });

        if (currentDocumentsType.selfie_required) {
            selfieLayout = new LinearLayout(context);
            selfieLayout.setOrientation(LinearLayout.VERTICAL);
            linearLayout2.addView(selfieLayout,
                    LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

            uploadSelfieCell = new TextDetailSettingsCell(context);
            uploadSelfieCell.setBackgroundDrawable(Theme.getSelectorDrawable(true));
            uploadSelfieCell.setTextAndValue(
                    LocaleController.getString("PassportSelfie", R.string.PassportSelfie),
                    LocaleController.getString("PassportSelfieInfo", R.string.PassportSelfieInfo),
                    currentType.translation_required);
            linearLayout2.addView(uploadSelfieCell,
                    LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
            uploadSelfieCell.setOnClickListener(v -> {
                uploadingFileType = UPLOADING_TYPE_SELFIE;
                openAttachMenu();
            });
        }

        bottomCell = new TextInfoPrivacyCell(context);
        bottomCell.setBackgroundDrawable(
                Theme.getThemedDrawable(context, R.drawable.greydivider, Theme.key_windowBackgroundGrayShadow));
        bottomCell.setText(
                LocaleController.getString("PassportPersonalUploadInfo", R.string.PassportPersonalUploadInfo));
        linearLayout2.addView(bottomCell,
                LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

        if (currentDocumentsType.translation_required) {
            headerCell = new HeaderCell(context);
            headerCell.setText(LocaleController.getString("PassportTranslation", R.string.PassportTranslation));
            headerCell.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
            linearLayout2.addView(headerCell,
                    LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

            translationLayout = new LinearLayout(context);
            translationLayout.setOrientation(LinearLayout.VERTICAL);
            linearLayout2.addView(translationLayout,
                    LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

            uploadTranslationCell = new TextSettingsCell(context);
            uploadTranslationCell.setBackgroundDrawable(Theme.getSelectorDrawable(true));
            linearLayout2.addView(uploadTranslationCell,
                    LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
            uploadTranslationCell.setOnClickListener(v -> {
                uploadingFileType = UPLOADING_TYPE_TRANSLATION;
                openAttachMenu();
            });

            bottomCellTranslation = new TextInfoPrivacyCell(context);
            bottomCellTranslation.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider,
                    Theme.key_windowBackgroundGrayShadow));

            if (currentBotId != 0) {
                noAllTranslationErrorText = LocaleController.getString("PassportAddTranslationUploadInfo",
                        R.string.PassportAddTranslationUploadInfo);
            } else {
                if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypePassport) {
                    noAllTranslationErrorText = LocaleController.getString("PassportAddPassportInfo",
                            R.string.PassportAddPassportInfo);
                } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeInternalPassport) {
                    noAllTranslationErrorText = LocaleController.getString("PassportAddInternalPassportInfo",
                            R.string.PassportAddInternalPassportInfo);
                } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeIdentityCard) {
                    noAllTranslationErrorText = LocaleController.getString("PassportAddIdentityCardInfo",
                            R.string.PassportAddIdentityCardInfo);
                } else if (currentDocumentsType.type instanceof TLRPC.TL_secureValueTypeDriverLicense) {
                    noAllTranslationErrorText = LocaleController.getString("PassportAddDriverLicenceInfo",
                            R.string.PassportAddDriverLicenceInfo);
                } else {
                    noAllTranslationErrorText = "";
                }
            }

            CharSequence text = noAllTranslationErrorText;
            if (documentsErrors != null) {
                String errorText;
                if ((errorText = documentsErrors.get("translation_all")) != null) {
                    SpannableStringBuilder stringBuilder = new SpannableStringBuilder(errorText);
                    stringBuilder.append("\n\n");
                    stringBuilder.append(noAllTranslationErrorText);
                    text = stringBuilder;
                    stringBuilder.setSpan(
                            new ForegroundColorSpan(Theme.getColor(Theme.key_windowBackgroundWhiteRedText3)), 0,
                            errorText.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
                    errorsValues.put("translation_all", "");
                }
            }
            bottomCellTranslation.setText(text);
            linearLayout2.addView(bottomCellTranslation,
                    LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
        }
    } else if (Build.VERSION.SDK_INT >= 18) {
        scanDocumentCell = new TextSettingsCell(context);
        scanDocumentCell.setBackgroundDrawable(Theme.getSelectorDrawable(true));
        scanDocumentCell.setText(
                LocaleController.getString("PassportScanPassport", R.string.PassportScanPassport), false);
        linearLayout2.addView(scanDocumentCell,
                LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
        scanDocumentCell.setOnClickListener(v -> {
            if (Build.VERSION.SDK_INT >= 23 && getParentActivity()
                    .checkSelfPermission(Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
                getParentActivity().requestPermissions(new String[] { Manifest.permission.CAMERA }, 22);
                return;
            }
            MrzCameraActivity fragment = new MrzCameraActivity();
            fragment.setDelegate(result -> {
                if (!TextUtils.isEmpty(result.firstName)) {
                    inputFields[FIELD_NAME].setText(result.firstName);
                }
                if (!TextUtils.isEmpty(result.middleName)) {
                    inputFields[FIELD_MIDNAME].setText(result.middleName);
                }
                if (!TextUtils.isEmpty(result.lastName)) {
                    inputFields[FIELD_SURNAME].setText(result.lastName);
                }
                if (result.gender != MrzRecognizer.Result.GENDER_UNKNOWN) {
                    switch (result.gender) {
                    case MrzRecognizer.Result.GENDER_MALE:
                        currentGender = "male";
                        inputFields[FIELD_GENDER]
                                .setText(LocaleController.getString("PassportMale", R.string.PassportMale));
                        break;
                    case MrzRecognizer.Result.GENDER_FEMALE:
                        currentGender = "female";
                        inputFields[FIELD_GENDER]
                                .setText(LocaleController.getString("PassportFemale", R.string.PassportFemale));
                        break;
                    }
                }
                if (!TextUtils.isEmpty(result.nationality)) {
                    currentCitizeship = result.nationality;
                    String country = languageMap.get(currentCitizeship);
                    if (country != null) {
                        inputFields[FIELD_CITIZENSHIP].setText(country);
                    }
                }
                if (!TextUtils.isEmpty(result.issuingCountry)) {
                    currentResidence = result.issuingCountry;
                    String country = languageMap.get(currentResidence);
                    if (country != null) {
                        inputFields[FIELD_RESIDENCE].setText(country);
                    }
                }
                if (result.birthDay > 0 && result.birthMonth > 0 && result.birthYear > 0) {
                    inputFields[FIELD_BIRTHDAY].setText(String.format(Locale.US, "%02d.%02d.%d",
                            result.birthDay, result.birthMonth, result.birthYear));
                }
            });
            presentFragment(fragment);
        });

        bottomCell = new TextInfoPrivacyCell(context);
        bottomCell.setBackgroundDrawable(
                Theme.getThemedDrawable(context, R.drawable.greydivider, Theme.key_windowBackgroundGrayShadow));
        bottomCell.setText(
                LocaleController.getString("PassportScanPassportInfo", R.string.PassportScanPassportInfo));
        linearLayout2.addView(bottomCell,
                LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
    }

    headerCell = new HeaderCell(context);
    if (documentOnly) {
        headerCell.setText(LocaleController.getString("PassportDocument", R.string.PassportDocument));
    } else {
        headerCell.setText(LocaleController.getString("PassportPersonal", R.string.PassportPersonal));
    }
    headerCell.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
    linearLayout2.addView(headerCell,
            LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

    int count = currentDocumentsType != null ? FIELD_IDENTITY_COUNT : FIELD_IDENTITY_NODOC_COUNT;
    inputFields = new EditTextBoldCursor[count];

    for (int a = 0; a < count; a++) {
        final EditTextBoldCursor field = new EditTextBoldCursor(context);
        inputFields[a] = field;

        ViewGroup container = new FrameLayout(context) {

            private StaticLayout errorLayout;
            private float offsetX;

            @Override
            protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
                int width = MeasureSpec.getSize(widthMeasureSpec) - AndroidUtilities.dp(34);
                errorLayout = field.getErrorLayout(width);
                if (errorLayout != null) {
                    int lineCount = errorLayout.getLineCount();
                    if (lineCount > 1) {
                        int height = AndroidUtilities.dp(64)
                                + (errorLayout.getLineBottom(lineCount - 1) - errorLayout.getLineBottom(0));
                        heightMeasureSpec = MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY);
                    }
                    if (LocaleController.isRTL) {
                        float maxW = 0;
                        for (int a = 0; a < lineCount; a++) {
                            float l = errorLayout.getLineLeft(a);
                            if (l != 0) {
                                offsetX = 0;
                                break;
                            }
                            maxW = Math.max(maxW, errorLayout.getLineWidth(a));
                            if (a == lineCount - 1) {
                                offsetX = width - maxW;
                            }
                        }
                    }
                }
                super.onMeasure(widthMeasureSpec, heightMeasureSpec);
            }

            @Override
            protected void onDraw(Canvas canvas) {
                if (errorLayout != null) {
                    canvas.save();
                    canvas.translate(AndroidUtilities.dp(21) + offsetX,
                            field.getLineY() + AndroidUtilities.dp(3));
                    errorLayout.draw(canvas);
                    canvas.restore();
                }
            }
        };
        container.setWillNotDraw(false);
        linearLayout2.addView(container, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 64));
        container.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));

        if (a == count - 1) {
            extraBackgroundView = new View(context);
            extraBackgroundView.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
            linearLayout2.addView(extraBackgroundView, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 6));
        }

        if (documentOnly && currentDocumentsType != null && a < FIELD_CARDNUMBER) {
            container.setVisibility(View.GONE);
            if (extraBackgroundView != null) {
                extraBackgroundView.setVisibility(View.GONE);
            }
        }

        inputFields[a].setTag(a);
        inputFields[a].setSupportRtlHint(true);
        inputFields[a].setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
        inputFields[a].setHintColor(Theme.getColor(Theme.key_windowBackgroundWhiteHintText));
        inputFields[a].setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
        inputFields[a].setHeaderHintColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlueHeader));
        inputFields[a].setTransformHintToHeader(true);
        inputFields[a].setBackgroundDrawable(null);
        inputFields[a].setCursorColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
        inputFields[a].setCursorSize(AndroidUtilities.dp(20));
        inputFields[a].setCursorWidth(1.5f);
        inputFields[a].setLineColors(Theme.getColor(Theme.key_windowBackgroundWhiteInputField),
                Theme.getColor(Theme.key_windowBackgroundWhiteInputFieldActivated),
                Theme.getColor(Theme.key_windowBackgroundWhiteRedText3));
        if (a == FIELD_CITIZENSHIP || a == FIELD_RESIDENCE) {
            inputFields[a].setOnTouchListener((v, event) -> {
                if (getParentActivity() == null) {
                    return false;
                }
                if (event.getAction() == MotionEvent.ACTION_UP) {
                    CountrySelectActivity fragment = new CountrySelectActivity(false);
                    fragment.setCountrySelectActivityDelegate((name, shortName) -> {
                        int field12 = (Integer) v.getTag();
                        final EditTextBoldCursor editText = inputFields[field12];
                        if (field12 == FIELD_CITIZENSHIP) {
                            currentCitizeship = shortName;
                        } else {
                            currentResidence = shortName;
                        }
                        editText.setText(name);
                    });
                    presentFragment(fragment);
                }
                return true;
            });
            inputFields[a].setInputType(0);
        } else if (a == FIELD_BIRTHDAY || a == FIELD_EXPIRE) {
            inputFields[a].setOnTouchListener((v, event) -> {
                if (getParentActivity() == null) {
                    return false;
                }
                if (event.getAction() == MotionEvent.ACTION_UP) {
                    Calendar calendar = Calendar.getInstance();
                    int year = calendar.get(Calendar.YEAR);
                    int monthOfYear = calendar.get(Calendar.MONTH);
                    int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH);
                    try {
                        final EditTextBoldCursor field1 = (EditTextBoldCursor) v;
                        int num = (Integer) field1.getTag();
                        int minYear;
                        int maxYear;
                        int currentYearDiff;
                        String title;
                        if (num == FIELD_EXPIRE) {
                            title = LocaleController.getString("PassportSelectExpiredDate",
                                    R.string.PassportSelectExpiredDate);
                            minYear = 0;
                            maxYear = 20;
                            currentYearDiff = 0;
                        } else {
                            title = LocaleController.getString("PassportSelectBithdayDate",
                                    R.string.PassportSelectBithdayDate);
                            minYear = -120;
                            maxYear = 0;
                            currentYearDiff = -18;
                        }
                        int selectedDay = -1;
                        int selectedMonth = -1;
                        int selectedYear = -1;
                        String args[] = field1.getText().toString().split("\\.");
                        if (args.length == 3) {
                            selectedDay = Utilities.parseInt(args[0]);
                            selectedMonth = Utilities.parseInt(args[1]);
                            selectedYear = Utilities.parseInt(args[2]);
                        }
                        AlertDialog.Builder builder = AlertsCreator.createDatePickerDialog(context, minYear,
                                maxYear, currentYearDiff, selectedDay, selectedMonth, selectedYear, title,
                                num == FIELD_EXPIRE, (year1, month, dayOfMonth1) -> {
                                    if (num == FIELD_EXPIRE) {
                                        currentExpireDate[0] = year1;
                                        currentExpireDate[1] = month + 1;
                                        currentExpireDate[2] = dayOfMonth1;
                                    }
                                    field1.setText(String.format(Locale.US, "%02d.%02d.%d", dayOfMonth1,
                                            month + 1, year1));
                                });
                        if (num == FIELD_EXPIRE) {
                            builder.setNegativeButton(LocaleController.getString("PassportSelectNotExpire",
                                    R.string.PassportSelectNotExpire), (dialog, which) -> {
                                        currentExpireDate[0] = currentExpireDate[1] = currentExpireDate[2] = 0;
                                        field1.setText(LocaleController.getString("PassportNoExpireDate",
                                                R.string.PassportNoExpireDate));
                                    });
                        }
                        showDialog(builder.create());
                    } catch (Exception e) {
                        FileLog.e(e);
                    }
                }
                return true;
            });
            inputFields[a].setInputType(0);
            inputFields[a].setFocusable(false);
        } else if (a == FIELD_GENDER) {
            inputFields[a].setOnTouchListener((v, event) -> {
                if (getParentActivity() == null) {
                    return false;
                }
                if (event.getAction() == MotionEvent.ACTION_UP) {
                    AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
                    builder.setTitle(
                            LocaleController.getString("PassportSelectGender", R.string.PassportSelectGender));
                    builder.setItems(
                            new CharSequence[] {
                                    LocaleController.getString("PassportMale", R.string.PassportMale),
                                    LocaleController.getString("PassportFemale", R.string.PassportFemale) },
                            (dialogInterface, i) -> {
                                if (i == 0) {
                                    currentGender = "male";
                                    inputFields[FIELD_GENDER].setText(
                                            LocaleController.getString("PassportMale", R.string.PassportMale));
                                } else if (i == 1) {
                                    currentGender = "female";
                                    inputFields[FIELD_GENDER].setText(LocaleController
                                            .getString("PassportFemale", R.string.PassportFemale));
                                }
                            });
                    builder.setPositiveButton(LocaleController.getString("Cancel", R.string.Cancel), null);
                    showDialog(builder.create());
                }
                return true;
            });
            inputFields[a].setInputType(0);
            inputFields[a].setFocusable(false);
        } else {
            inputFields[a].setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_CAP_SENTENCES);
            inputFields[a].setImeOptions(EditorInfo.IME_ACTION_NEXT | EditorInfo.IME_FLAG_NO_EXTRACT_UI);
        }
        String value;
        final String key;
        HashMap<String, String> values;
        switch (a) {
        case FIELD_NAME:
            if (currentType.native_names) {
                inputFields[a].setHintText(
                        LocaleController.getString("PassportNameLatin", R.string.PassportNameLatin));
            } else {
                inputFields[a].setHintText(LocaleController.getString("PassportName", R.string.PassportName));
            }
            key = "first_name";
            values = currentValues;
            break;
        case FIELD_MIDNAME:
            if (currentType.native_names) {
                inputFields[a].setHintText(
                        LocaleController.getString("PassportMidnameLatin", R.string.PassportMidnameLatin));
            } else {
                inputFields[a]
                        .setHintText(LocaleController.getString("PassportMidname", R.string.PassportMidname));
            }
            key = "middle_name";
            values = currentValues;
            break;
        case FIELD_SURNAME:
            if (currentType.native_names) {
                inputFields[a].setHintText(
                        LocaleController.getString("PassportSurnameLatin", R.string.PassportSurnameLatin));
            } else {
                inputFields[a]
                        .setHintText(LocaleController.getString("PassportSurname", R.string.PassportSurname));
            }
            key = "last_name";
            values = currentValues;
            break;
        case FIELD_BIRTHDAY:
            inputFields[a]
                    .setHintText(LocaleController.getString("PassportBirthdate", R.string.PassportBirthdate));
            key = "birth_date";
            values = currentValues;
            break;
        case FIELD_GENDER:
            inputFields[a].setHintText(LocaleController.getString("PassportGender", R.string.PassportGender));
            key = "gender";
            values = currentValues;
            break;
        case FIELD_CITIZENSHIP:
            inputFields[a].setHintText(
                    LocaleController.getString("PassportCitizenship", R.string.PassportCitizenship));
            key = "country_code";
            values = currentValues;
            break;
        case FIELD_RESIDENCE:
            inputFields[a]
                    .setHintText(LocaleController.getString("PassportResidence", R.string.PassportResidence));
            key = "residence_country_code";
            values = currentValues;
            break;
        case FIELD_CARDNUMBER:
            inputFields[a].setHintText(
                    LocaleController.getString("PassportDocumentNumber", R.string.PassportDocumentNumber));
            key = "document_no";
            values = currentDocumentValues;
            break;
        case FIELD_EXPIRE:
            inputFields[a].setHintText(LocaleController.getString("PassportExpired", R.string.PassportExpired));
            key = "expiry_date";
            values = currentDocumentValues;
            break;
        default:
            continue;
        }
        setFieldValues(values, inputFields[a], key);
        inputFields[a].setSelection(inputFields[a].length());
        if (a == FIELD_NAME || a == FIELD_SURNAME || a == FIELD_MIDNAME) {
            inputFields[a].addTextChangedListener(new TextWatcher() {

                private boolean ignore;

                @Override
                public void beforeTextChanged(CharSequence s, int start, int count, int after) {

                }

                @Override
                public void onTextChanged(CharSequence s, int start, int before, int count) {

                }

                @Override
                public void afterTextChanged(Editable s) {
                    if (ignore) {
                        return;
                    }
                    int num = (Integer) field.getTag();
                    boolean error = false;
                    for (int a = 0; a < s.length(); a++) {
                        char ch = s.charAt(a);
                        if (!(ch >= '0' && ch <= '9' || ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z'
                                || ch == ' ' || ch == '\'' || ch == ',' || ch == '.' || ch == '&' || ch == '-'
                                || ch == '/')) {
                            error = true;
                            break;
                        }
                    }
                    if (error && !allowNonLatinName) {
                        field.setErrorText(LocaleController.getString("PassportUseLatinOnly",
                                R.string.PassportUseLatinOnly));
                    } else {
                        nonLatinNames[num] = error;
                        checkFieldForError(field, key, s, false);
                    }
                }
            });
        } else {
            inputFields[a].addTextChangedListener(new TextWatcher() {
                @Override
                public void beforeTextChanged(CharSequence s, int start, int count, int after) {

                }

                @Override
                public void onTextChanged(CharSequence s, int start, int before, int count) {

                }

                @Override
                public void afterTextChanged(Editable s) {
                    checkFieldForError(field, key, s, values == currentDocumentValues);
                    int field12 = (Integer) field.getTag();
                    final EditTextBoldCursor editText = inputFields[field12];
                    if (field12 == FIELD_RESIDENCE) {
                        checkNativeFields(true);
                    }
                }
            });
        }

        inputFields[a].setPadding(0, 0, 0, 0);
        inputFields[a]
                .setGravity((LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT) | Gravity.CENTER_VERTICAL);
        container.addView(inputFields[a], LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT,
                LayoutHelper.MATCH_PARENT, Gravity.LEFT | Gravity.TOP, 21, 0, 21, 0));

        inputFields[a].setOnEditorActionListener((textView, i, keyEvent) -> {
            if (i == EditorInfo.IME_ACTION_NEXT) {
                int num = (Integer) textView.getTag();
                num++;
                if (num < inputFields.length) {
                    if (inputFields[num].isFocusable()) {
                        inputFields[num].requestFocus();
                    } else {
                        inputFields[num]
                                .dispatchTouchEvent(MotionEvent.obtain(0, 0, MotionEvent.ACTION_UP, 0, 0, 0));
                        textView.clearFocus();
                        AndroidUtilities.hideKeyboard(textView);
                    }
                }
                return true;
            }
            return false;
        });
    }

    sectionCell2 = new ShadowSectionCell(context);
    linearLayout2.addView(sectionCell2,
            LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

    headerCell = new HeaderCell(context);
    headerCell.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
    linearLayout2.addView(headerCell,
            LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

    inputExtraFields = new EditTextBoldCursor[FIELD_NATIVE_COUNT];
    for (int a = 0; a < FIELD_NATIVE_COUNT; a++) {
        final EditTextBoldCursor field = new EditTextBoldCursor(context);
        inputExtraFields[a] = field;

        ViewGroup container = new FrameLayout(context) {

            private StaticLayout errorLayout;
            private float offsetX;

            @Override
            protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
                int width = MeasureSpec.getSize(widthMeasureSpec) - AndroidUtilities.dp(34);
                errorLayout = field.getErrorLayout(width);
                if (errorLayout != null) {
                    int lineCount = errorLayout.getLineCount();
                    if (lineCount > 1) {
                        int height = AndroidUtilities.dp(64)
                                + (errorLayout.getLineBottom(lineCount - 1) - errorLayout.getLineBottom(0));
                        heightMeasureSpec = MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY);
                    }
                    if (LocaleController.isRTL) {
                        float maxW = 0;
                        for (int a = 0; a < lineCount; a++) {
                            float l = errorLayout.getLineLeft(a);
                            if (l != 0) {
                                offsetX = 0;
                                break;
                            }
                            maxW = Math.max(maxW, errorLayout.getLineWidth(a));
                            if (a == lineCount - 1) {
                                offsetX = width - maxW;
                            }
                        }
                    }
                }
                super.onMeasure(widthMeasureSpec, heightMeasureSpec);
            }

            @Override
            protected void onDraw(Canvas canvas) {
                if (errorLayout != null) {
                    canvas.save();
                    canvas.translate(AndroidUtilities.dp(21) + offsetX,
                            field.getLineY() + AndroidUtilities.dp(3));
                    errorLayout.draw(canvas);
                    canvas.restore();
                }
            }
        };
        container.setWillNotDraw(false);
        linearLayout2.addView(container, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 64));
        container.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));

        if (a == FIELD_NATIVE_COUNT - 1) {
            extraBackgroundView2 = new View(context);
            extraBackgroundView2.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
            linearLayout2.addView(extraBackgroundView2,
                    LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 6));
        }

        inputExtraFields[a].setTag(a);
        inputExtraFields[a].setSupportRtlHint(true);
        inputExtraFields[a].setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
        inputExtraFields[a].setHintColor(Theme.getColor(Theme.key_windowBackgroundWhiteHintText));
        inputExtraFields[a].setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
        inputExtraFields[a].setHeaderHintColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlueHeader));
        inputExtraFields[a].setTransformHintToHeader(true);
        inputExtraFields[a].setBackgroundDrawable(null);
        inputExtraFields[a].setCursorColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
        inputExtraFields[a].setCursorSize(AndroidUtilities.dp(20));
        inputExtraFields[a].setCursorWidth(1.5f);
        inputExtraFields[a].setLineColors(Theme.getColor(Theme.key_windowBackgroundWhiteInputField),
                Theme.getColor(Theme.key_windowBackgroundWhiteInputFieldActivated),
                Theme.getColor(Theme.key_windowBackgroundWhiteRedText3));
        inputExtraFields[a].setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_CAP_SENTENCES);
        inputExtraFields[a].setImeOptions(EditorInfo.IME_ACTION_NEXT | EditorInfo.IME_FLAG_NO_EXTRACT_UI);

        String value;
        final String key;
        HashMap<String, String> values;
        switch (a) {
        case FIELD_NATIVE_NAME:
            key = "first_name_native";
            values = currentValues;
            break;
        case FIELD_NATIVE_MIDNAME:
            key = "middle_name_native";
            values = currentValues;
            break;
        case FIELD_NATIVE_SURNAME:
            key = "last_name_native";
            values = currentValues;
            break;
        default:
            continue;
        }
        setFieldValues(values, inputExtraFields[a], key);
        inputExtraFields[a].setSelection(inputExtraFields[a].length());
        if (a == FIELD_NATIVE_NAME || a == FIELD_NATIVE_SURNAME || a == FIELD_NATIVE_MIDNAME) {
            inputExtraFields[a].addTextChangedListener(new TextWatcher() {

                private boolean ignore;

                @Override
                public void beforeTextChanged(CharSequence s, int start, int count, int after) {

                }

                @Override
                public void onTextChanged(CharSequence s, int start, int before, int count) {

                }

                @Override
                public void afterTextChanged(Editable s) {
                    if (ignore) {
                        return;
                    }
                    checkFieldForError(field, key, s, false);
                }
            });
        }

        inputExtraFields[a].setPadding(0, 0, 0, 0);
        inputExtraFields[a]
                .setGravity((LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT) | Gravity.CENTER_VERTICAL);
        container.addView(inputExtraFields[a], LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT,
                LayoutHelper.MATCH_PARENT, Gravity.LEFT | Gravity.TOP, 21, 0, 21, 0));

        inputExtraFields[a].setOnEditorActionListener((textView, i, keyEvent) -> {
            if (i == EditorInfo.IME_ACTION_NEXT) {
                int num = (Integer) textView.getTag();
                num++;
                if (num < inputExtraFields.length) {
                    if (inputExtraFields[num].isFocusable()) {
                        inputExtraFields[num].requestFocus();
                    } else {
                        inputExtraFields[num]
                                .dispatchTouchEvent(MotionEvent.obtain(0, 0, MotionEvent.ACTION_UP, 0, 0, 0));
                        textView.clearFocus();
                        AndroidUtilities.hideKeyboard(textView);
                    }
                }
                return true;
            }
            return false;
        });
    }

    nativeInfoCell = new TextInfoPrivacyCell(context);
    linearLayout2.addView(nativeInfoCell,
            LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));

    if ((currentBotId != 0 || currentDocumentsType == null) && currentTypeValue != null && !documentOnly
            || currentDocumentsTypeValue != null) {
        if (currentDocumentsTypeValue != null) {
            addDocumentViews(currentDocumentsTypeValue.files);
            if (currentDocumentsTypeValue.front_side instanceof TLRPC.TL_secureFile) {
                addDocumentViewInternal((TLRPC.TL_secureFile) currentDocumentsTypeValue.front_side,
                        UPLOADING_TYPE_FRONT);
            }
            if (currentDocumentsTypeValue.reverse_side instanceof TLRPC.TL_secureFile) {
                addDocumentViewInternal((TLRPC.TL_secureFile) currentDocumentsTypeValue.reverse_side,
                        UPLOADING_TYPE_REVERSE);
            }
            if (currentDocumentsTypeValue.selfie instanceof TLRPC.TL_secureFile) {
                addDocumentViewInternal((TLRPC.TL_secureFile) currentDocumentsTypeValue.selfie,
                        UPLOADING_TYPE_SELFIE);
            }
            addTranslationDocumentViews(currentDocumentsTypeValue.translation);
        }

        TextSettingsCell settingsCell1 = new TextSettingsCell(context);
        settingsCell1.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteRedText3));
        settingsCell1.setBackgroundDrawable(Theme.getSelectorDrawable(true));
        if (currentDocumentsType == null) {
            settingsCell1.setText(LocaleController.getString("PassportDeleteInfo", R.string.PassportDeleteInfo),
                    false);
        } else {
            settingsCell1.setText(
                    LocaleController.getString("PassportDeleteDocument", R.string.PassportDeleteDocument),
                    false);
        }
        linearLayout2.addView(settingsCell1,
                LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
        settingsCell1.setOnClickListener(v -> createDocumentDeleteAlert());

        nativeInfoCell.setBackgroundDrawable(
                Theme.getThemedDrawable(context, R.drawable.greydivider, Theme.key_windowBackgroundGrayShadow));

        sectionCell = new ShadowSectionCell(context);
        sectionCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider_bottom,
                Theme.key_windowBackgroundGrayShadow));
        linearLayout2.addView(sectionCell,
                LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
    } else {
        nativeInfoCell.setBackgroundDrawable(Theme.getThemedDrawable(context, R.drawable.greydivider_bottom,
                Theme.key_windowBackgroundGrayShadow));
    }

    updateInterfaceStringsForDocumentType();
    checkNativeFields(false);
}