<?xml version="1.0" encoding="utf-8"?>
<!--
  ~ Copyright (C) 2015 The Android Open Source Project
  ~
  ~ Licensed under the Apache License, Version 2.0 (the "License");
  ~ you may not use this file except in compliance with the License.
  ~ You may obtain a copy of the License at
  ~
  ~      http://www.apache.org/licenses/LICENSE-2.0
  ~
  ~ Unless required by applicable law or agreed to in writing, software
  ~ distributed under the License is distributed on an "AS IS" BASIS,
  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  ~ See the License for the specific language governing permissions and
  ~ limitations under the License.
  -->

<!-- Need to disable clipping for the shared element transition. -->
<FrameLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:clipChildren="false"
    android:clipToPadding="false"
    android:orientation="horizontal">
    <View
        android:id="@+id/setup_common_guidance_background"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_marginStart="@dimen/setup_common_guidance_background_margin_start"
        android:background="?attr/setupCommonGuidanceBackground" />
    <!-- Guided step fragment container must be at the left of the done button at least by 1 pixel
         for the focus navigation. If they overlap, the focus doesn't move from the button to the
         fragment container.-->
    <FrameLayout
        android:id="@+id/guided_step_fragment_container"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_marginEnd="1dp"
        android:clipChildren="false"
        android:clipToPadding="false" />
    <!-- TODO: Use button action list in GuidedStepFragment -->
    <LinearLayout
        android:id="@+id/done_button_container"
        android:layout_width="@dimen/setup_done_button_container_width"
        android:layout_height="match_parent"
        android:layout_gravity="end"
        android:orientation="vertical"
        android:paddingTop="190dp"
        style="?attr/doneButtonContainerStyle"
        android:transitionGroup="true"
        android:transitionName="buttonDoneTransition">
        <TextView
            android:id="@+id/button_done"
            android:layout_width="match_parent"
            android:layout_height="45dp"
            android:layout_marginStart="24dp"
            android:layout_marginEnd="40dp"
            android:elevation="0dp"
            android:focusable="true"
            android:fontFamily="sans-serif-condensed"
            android:paddingEnd="12dp"
            android:paddingStart="12dp"
            android:background="@drawable/setup_action_button_done"
            android:gravity="center_vertical|start"
            android:text="@string/action_text_done"
            android:textColor="#EEEEEE"
            android:textSize="14sp" />
        <TextView
            android:id="@+id/button_skip"
            android:layout_width="match_parent"
            android:layout_height="45dp"
            android:layout_marginStart="24dp"
            android:layout_marginEnd="40dp"
            android:layout_marginTop="8dp"
            android:elevation="0dp"
            android:focusable="true"
            android:fontFamily="sans-serif-condensed"
            android:paddingEnd="12dp"
            android:paddingStart="12dp"
            android:background="@drawable/setup_action_button_done"
            android:gravity="center_vertical|start"
            android:visibility="gone"
            android:text="@string/action_text_skip"
            android:textColor="#EEEEEE"
            android:textSize="14sp" />
    </LinearLayout>
</FrameLayout>
