public static void SetNavigationIcon(Toolbar toolbar, AppCompatActivity activity)
        {
            try
            {
                ConstantsAndTypes.ScreenSize screenSize = SystemHelper.GetScreenSize();

                switch (screenSize)
                {
                case ConstantsAndTypes.ScreenSize.Small:
                    toolbar.SetNavigationIcon(Resource.Drawable.ic_arrow_back_white_18dp);
                    break;

                case ConstantsAndTypes.ScreenSize.Normal:
                    toolbar.SetNavigationIcon(Resource.Drawable.ic_arrow_back_white_24dp);
                    break;

                case ConstantsAndTypes.ScreenSize.Large:
                    toolbar.SetNavigationIcon(Resource.Drawable.ic_arrow_back_white_36dp);
                    break;

                case ConstantsAndTypes.ScreenSize.ExtraLarge:
                    toolbar.SetNavigationIcon(Resource.Drawable.ic_arrow_back_white_48dp);
                    break;
                }
            }
            catch (Exception e)
            {
                Log.Error(TAG, "SetNavigationIcon: Exception - " + e.Message);
                if (GlobalData.ShowErrorDialog)
                {
                    ErrorDisplay.ShowErrorAlert(activity, e, "Setting Navigation Icon", "ToolbarHelper.SetNavigationIcon");
                }
            }
        }
        private void SetActionIcons(IMenu menu)
        {
            try
            {
                ConstantsAndTypes.ScreenSize screenSize = SystemHelper.GetScreenSize();

                //get references to each of the menu items
                var itemCancel = menu.FindItem(Resource.Id.situationActionCancel);
                var itemHelp   = menu.FindItem(Resource.Id.situationActionHelp);

                switch (screenSize)
                {
                case ConstantsAndTypes.ScreenSize.Normal:
                    if (itemCancel != null)
                    {
                        itemCancel.SetIcon(Resource.Drawable.ic_cancel_white_24dp);
                    }
                    if (itemHelp != null)
                    {
                        itemHelp.SetIcon(Resource.Drawable.ic_help_white_24dp);
                    }
                    break;

                case ConstantsAndTypes.ScreenSize.Large:
                    if (itemCancel != null)
                    {
                        itemCancel.SetIcon(Resource.Drawable.ic_cancel_white_36dp);
                    }
                    if (itemHelp != null)
                    {
                        itemHelp.SetIcon(Resource.Drawable.ic_help_white_36dp);
                    }
                    break;

                case ConstantsAndTypes.ScreenSize.ExtraLarge:
                    if (itemCancel != null)
                    {
                        itemCancel.SetIcon(Resource.Drawable.ic_cancel_white_48dp);
                    }
                    if (itemHelp != null)
                    {
                        itemHelp.SetIcon(Resource.Drawable.ic_help_white_48dp);
                    }
                    break;
                }
            }
            catch (Exception e)
            {
                Log.Error(TAG, "SetActionIcons: Exception - " + e.Message);
                if (GlobalData.ShowErrorDialog)
                {
                    ErrorDisplay.ShowErrorAlert(this, e, "Setting Action Icons", "ThoughtRecordWizardSituationStep.SetActionIcons");
                }
            }
        }
        private void SetActionIcons(IMenu menu)
        {
            try
            {
                ConstantsAndTypes.ScreenSize screenSize = SystemHelper.GetScreenSize();

                //get references to each of the menu items
                var itemAdd  = menu.FindItem(Resource.Id.StructuredPlanRelationshipsDialogActivityActionAdd);
                var itemHelp = menu.FindItem(Resource.Id.StructuredPlanRelationshipsDialogActivityActionHelp);

                switch (screenSize)
                {
                case ConstantsAndTypes.ScreenSize.Normal:
                    if (itemAdd != null)
                    {
                        itemAdd.SetIcon(Resource.Drawable.ic_add_circle_outline_white_24dp);
                    }
                    if (itemHelp != null)
                    {
                        itemHelp.SetIcon(Resource.Drawable.ic_help_white_24dp);
                    }
                    break;

                case ConstantsAndTypes.ScreenSize.Large:
                    if (itemAdd != null)
                    {
                        itemAdd.SetIcon(Resource.Drawable.ic_add_circle_outline_white_36dp);
                    }
                    if (itemHelp != null)
                    {
                        itemHelp.SetIcon(Resource.Drawable.ic_help_white_36dp);
                    }
                    break;

                case ConstantsAndTypes.ScreenSize.ExtraLarge:
                    if (itemAdd != null)
                    {
                        itemAdd.SetIcon(Resource.Drawable.ic_add_circle_outline_white_48dp);
                    }
                    if (itemHelp != null)
                    {
                        itemHelp.SetIcon(Resource.Drawable.ic_help_white_48dp);
                    }
                    break;
                }
            }
            catch (Exception e)
            {
                Log.Error(TAG, "SetActionIcons: Exception - " + e.Message);
                if (GlobalData.ShowErrorDialog)
                {
                    ErrorDisplay.ShowErrorAlert(this, e, "Setting Action Icons", "StructuredPlanRelationshipsDialogActivity.SetActionIcons");
                }
            }
        }
        private void SetActionIcons(IMenu menu)
        {
            try
            {
                ConstantsAndTypes.ScreenSize screenSize = SystemHelper.GetScreenSize();

                //get references to each of the menu items
                var itemDate = menu.FindItem(Resource.Id.viewthoughtsSelectDate);
                var itemHelp = menu.FindItem(Resource.Id.viewThoughtsActionHelp);

                switch (screenSize)
                {
                case ConstantsAndTypes.ScreenSize.Normal:
                    if (itemDate != null)
                    {
                        itemDate.SetIcon(Resource.Drawable.ic_date_range_white_24dp);
                    }
                    if (itemHelp != null)
                    {
                        itemHelp.SetIcon(Resource.Drawable.ic_help_white_24dp);
                    }
                    break;

                case ConstantsAndTypes.ScreenSize.Large:
                    if (itemDate != null)
                    {
                        itemDate.SetIcon(Resource.Drawable.ic_date_range_white_36dp);
                    }
                    if (itemHelp != null)
                    {
                        itemHelp.SetIcon(Resource.Drawable.ic_help_white_36dp);
                    }
                    break;

                case ConstantsAndTypes.ScreenSize.ExtraLarge:
                    if (itemDate != null)
                    {
                        itemDate.SetIcon(Resource.Drawable.ic_date_range_white_48dp);
                    }
                    if (itemHelp != null)
                    {
                        itemHelp.SetIcon(Resource.Drawable.ic_help_white_48dp);
                    }
                    break;
                }
            }
            catch (Exception e)
            {
                Log.Error(TAG, "SetActionIcons: Exception - " + e.Message);
                if (GlobalData.ShowErrorDialog)
                {
                    ErrorDisplay.ShowErrorAlert(this, e, "Setting Action Icons", "ViewThoughtsActivity.SetActionIcons");
                }
            }
        }
Beispiel #5
0
        private void SetNavigationIcon()
        {
            ConstantsAndTypes.ScreenSize screenSize = SystemHelper.GetScreenSize();

            switch (screenSize)
            {
            case ConstantsAndTypes.ScreenSize.Normal:
                _toolbar.SetNavigationIcon(Resource.Drawable.ic_arrow_back_white_24dp);
                break;

            case ConstantsAndTypes.ScreenSize.Large:
                _toolbar.SetNavigationIcon(Resource.Drawable.ic_arrow_back_white_36dp);
                break;

            case ConstantsAndTypes.ScreenSize.ExtraLarge:
                _toolbar.SetNavigationIcon(Resource.Drawable.ic_arrow_back_white_48dp);
                break;
            }
        }
        private void SetActionIcons(IMenu menu)
        {
            try
            {
                ConstantsAndTypes.ScreenSize screenSize = SystemHelper.GetScreenSize();

                //get references to each of the menu items
                var itemHome = menu.FindItem(Resource.Id.safetyPlanKeepCalmHelpActionHome);

                switch (screenSize)
                {
                case ConstantsAndTypes.ScreenSize.Normal:
                    if (itemHome != null)
                    {
                        itemHome.SetIcon(Resource.Drawable.ic_home_white_24dp);
                    }
                    break;

                case ConstantsAndTypes.ScreenSize.Large:
                    if (itemHome != null)
                    {
                        itemHome.SetIcon(Resource.Drawable.ic_home_white_36dp);
                    }
                    break;

                case ConstantsAndTypes.ScreenSize.ExtraLarge:
                    if (itemHome != null)
                    {
                        itemHome.SetIcon(Resource.Drawable.ic_home_white_48dp);
                    }
                    break;
                }
            }
            catch (Exception e)
            {
                Log.Error(TAG, "SetActionIcons: Exception - " + e.Message);
                if (GlobalData.ShowErrorDialog)
                {
                    ErrorDisplay.ShowErrorAlert(this, e, "Setting Action Icons", "SafetyPlanKeepCalmHelpActivity.SetActionIcons");
                }
            }
        }
Beispiel #7
0
        private void SetTextItem(TextView textView, string itemText)
        {
            ConstantsAndTypes.ScreenSize screenSize = SystemHelper.GetScreenSize();

            textView.Text = itemText;

            switch (screenSize)
            {
            case ConstantsAndTypes.ScreenSize.Normal:
                textView.SetTextSize(ComplexUnitType.Dip, 14);
                break;

            case ConstantsAndTypes.ScreenSize.Large:
                textView.SetTextSize(ComplexUnitType.Dip, 18);
                break;

            case ConstantsAndTypes.ScreenSize.ExtraLarge:
                textView.SetTextSize(ComplexUnitType.Dip, 22);
                break;
            }
        }
Beispiel #8
0
        private void SetActionIcons(IMenu menu)
        {
            try
            {
                ConstantsAndTypes.ScreenSize screenSize = SystemHelper.GetScreenSize();

                //get references to each of the menu items
                var itemAddText  = menu.FindItem(Resource.Id.tellmyselfActionAddText);
                var itemAddVoice = menu.FindItem(Resource.Id.tellmyselfActionAddVoice);
                var itemRemove   = menu.FindItem(Resource.Id.tellmyselfActionRemove);
                var itemHelp     = menu.FindItem(Resource.Id.tellmyselfActionHelp);

                switch (screenSize)
                {
                case ConstantsAndTypes.ScreenSize.Normal:
                    if (itemAddText != null)
                    {
                        itemAddText.SetIcon(Resource.Drawable.ic_text_fields_white_24dp);
                    }
                    if (itemAddVoice != null)
                    {
                        itemAddVoice.SetIcon(Resource.Drawable.ic_keyboard_voice_white_24dp);
                    }
                    if (itemRemove != null)
                    {
                        itemRemove.SetIcon(Resource.Drawable.ic_delete_white_24dp);
                    }
                    if (itemHelp != null)
                    {
                        itemHelp.SetIcon(Resource.Drawable.ic_help_white_24dp);
                    }
                    break;

                case ConstantsAndTypes.ScreenSize.Large:
                    if (itemAddText != null)
                    {
                        itemAddText.SetIcon(Resource.Drawable.ic_text_fields_white_36dp);
                    }
                    if (itemAddVoice != null)
                    {
                        itemAddVoice.SetIcon(Resource.Drawable.ic_keyboard_voice_white_36dp);
                    }
                    if (itemRemove != null)
                    {
                        itemRemove.SetIcon(Resource.Drawable.ic_delete_white_36dp);
                    }
                    if (itemHelp != null)
                    {
                        itemHelp.SetIcon(Resource.Drawable.ic_help_white_36dp);
                    }
                    break;

                case ConstantsAndTypes.ScreenSize.ExtraLarge:
                    if (itemAddText != null)
                    {
                        itemAddText.SetIcon(Resource.Drawable.ic_text_fields_white_48dp);
                    }
                    if (itemAddVoice != null)
                    {
                        itemAddVoice.SetIcon(Resource.Drawable.ic_keyboard_voice_white_48dp);
                    }
                    if (itemRemove != null)
                    {
                        itemRemove.SetIcon(Resource.Drawable.ic_delete_white_48dp);
                    }
                    if (itemHelp != null)
                    {
                        itemHelp.SetIcon(Resource.Drawable.ic_help_white_48dp);
                    }
                    break;
                }
            }
            catch (Exception e)
            {
                Log.Error(TAG, "SetActionIcons: Exception - " + e.Message);
                if (GlobalData.ShowErrorDialog)
                {
                    ErrorDisplay.ShowErrorAlert(this, e, "Setting Action Icons", "TellMyselfActivity.SetActionIcons");
                }
            }
        }
Beispiel #9
0
        private void SetActionIcons(IMenu menu)
        {
            try
            {
                ConstantsAndTypes.ScreenSize screenSize = SystemHelper.GetScreenSize();

                //get references to each of the menu items
                var itemAdd    = menu.FindItem(Resource.Id.automaticthoughtsActionAdd);
                var itemRemove = menu.FindItem(Resource.Id.automaticthoughtsActionRemove);
                var itemHot    = menu.FindItem(Resource.Id.automaticthoughtsActionHotThought);
                var itemCancel = menu.FindItem(Resource.Id.automaticthoughtsActionCancel);
                var itemHelp   = menu.FindItem(Resource.Id.automaticThoughtsActionHelp);

                switch (screenSize)
                {
                case ConstantsAndTypes.ScreenSize.Normal:
                    if (itemAdd != null)
                    {
                        itemAdd.SetIcon(Resource.Drawable.ic_add_circle_outline_white_24dp);
                    }
                    if (itemRemove != null)
                    {
                        itemRemove.SetIcon(Resource.Drawable.ic_delete_white_24dp);
                    }
                    if (itemHot != null)
                    {
                        itemHot.SetIcon(Resource.Drawable.ic_flash_on_white_24dp);
                    }
                    if (itemCancel != null)
                    {
                        itemCancel.SetIcon(Resource.Drawable.ic_cancel_white_24dp);
                    }
                    if (itemHelp != null)
                    {
                        itemHelp.SetIcon(Resource.Drawable.ic_help_white_24dp);
                    }
                    break;

                case ConstantsAndTypes.ScreenSize.Large:
                    if (itemAdd != null)
                    {
                        itemAdd.SetIcon(Resource.Drawable.ic_add_circle_outline_white_36dp);
                    }
                    if (itemRemove != null)
                    {
                        itemRemove.SetIcon(Resource.Drawable.ic_delete_white_36dp);
                    }
                    if (itemHot != null)
                    {
                        itemHot.SetIcon(Resource.Drawable.ic_flash_on_white_36dp);
                    }
                    if (itemCancel != null)
                    {
                        itemCancel.SetIcon(Resource.Drawable.ic_cancel_white_36dp);
                    }
                    if (itemHelp != null)
                    {
                        itemHelp.SetIcon(Resource.Drawable.ic_help_white_36dp);
                    }
                    break;

                case ConstantsAndTypes.ScreenSize.ExtraLarge:
                    if (itemAdd != null)
                    {
                        itemAdd.SetIcon(Resource.Drawable.ic_add_circle_outline_white_48dp);
                    }
                    if (itemRemove != null)
                    {
                        itemRemove.SetIcon(Resource.Drawable.ic_delete_white_48dp);
                    }
                    if (itemHot != null)
                    {
                        itemHot.SetIcon(Resource.Drawable.ic_flash_on_white_48dp);
                    }
                    if (itemCancel != null)
                    {
                        itemCancel.SetIcon(Resource.Drawable.ic_cancel_white_48dp);
                    }
                    if (itemHelp != null)
                    {
                        itemHelp.SetIcon(Resource.Drawable.ic_help_white_48dp);
                    }
                    break;
                }
            }
            catch (Exception e)
            {
                Log.Error(TAG, "SetActionIcons: Exception - " + e.Message);
                if (GlobalData.ShowErrorDialog)
                {
                    ErrorDisplay.ShowErrorAlert(this, e, "Setting Action Icons", "ThoughtRecordWizardAutomaticThoughtsStep.SetActionIcons");
                }
            }
        }
        public static Toolbar SetupToolbar(AppCompatActivity activity, int toolbarId, int toolbarTitle, int textColour)
        {
            Toolbar toolbar = null;

            ConstantsAndTypes.ScreenSize screenSize = SystemHelper.GetScreenSize();

            try
            {
                toolbar = activity.FindViewById <Toolbar>(toolbarId);

                if (toolbar != null)
                {
                    activity.SetSupportActionBar(toolbar);
                    if (toolbar.Id != Resource.Id.my_toolbar)
                    {
                        activity.SupportActionBar.SetDisplayHomeAsUpEnabled(true);
                        activity.SupportActionBar.SetDisplayShowHomeEnabled(true);
                    }

                    if (toolbarTitle != -1)
                    {
                        activity.SupportActionBar.SetTitle(toolbarTitle);
                        toolbar.SetTitleTextColor(textColour);

                        switch (screenSize)
                        {
                        case ConstantsAndTypes.ScreenSize.Normal:
                            toolbar.SetTitleTextAppearance(activity, Resource.Style.MindYourMood_ActivityTheme_TitleTextAppearanceNormal);
                            break;

                        case ConstantsAndTypes.ScreenSize.Large:
                            toolbar.SetTitleTextAppearance(activity, Resource.Style.MindYourMood_ActivityTheme_TitleTextAppearanceLarge);
                            break;

                        case ConstantsAndTypes.ScreenSize.ExtraLarge:
                            toolbar.SetTitleTextAppearance(activity, Resource.Style.MindYourMood_ActivityTheme_TitleTextAppearanceExtraLarge);
                            break;
                        }
                    }
                    else
                    {
                        activity.SupportActionBar.SetDisplayShowTitleEnabled(false);
                    }

                    activity.SupportActionBar.Elevation = 1.0f;

                    if (toolbar.Id != Resource.Id.my_toolbar)
                    {
                        SetNavigationIcon(toolbar, activity);
                    }

                    toolbar.SetContentInsetsAbsolute(0, 0);
                    toolbar.SetContentInsetsRelative(0, 0);
                }
                return(toolbar);
            }
            catch (Exception e)
            {
                Log.Error(TAG, "SetupToolbar: Exception - " + e.Message);
                if (GlobalData.ShowErrorDialog)
                {
                    ErrorDisplay.ShowErrorAlert(activity, e, "Setting up toolbar", "ToolbarHelper.SetupToolbar");
                }

                return(null);
            }
        }