Ejemplo n.º 1
0
        protected override void OnCreate(Bundle bundle)
        {
            base.OnCreate (bundle);

            using (var db = new SQLiteConnection (dbPath)) {
                db.CreateTable<LogEntry> ();
            }

            // Set our view from the "main" layout resource
            SetContentView (Resource.Layout.Main);

            // Create our database if it does not already exist

            // Get our button from the layout resource,
            // and attach an event to it
            Button addFood = FindViewById<Button> (Resource.Id.AddFoodButton);

            addFood.Click += (object sender, EventArgs e) =>
            {
                AlertDialog.Builder addFoodDialogBuilder = new AlertDialog.Builder(this);
                addFoodDialogBuilder.SetTitle ("I had something to eat and it was:");
                addFoodDialogBuilder.SetSingleChoiceItems (choices, -1, clickFoodDialogList);

                addFoodDialog = addFoodDialogBuilder.Create();
                // Show the alert dialog to the user and wait for response.
                addFoodDialog.Show();
            };
        }
Ejemplo n.º 2
0
 public void Sort(List<WorkshopPreview> list)
 {
     AlertDialog.Builder builder = new AlertDialog.Builder(ctx);
     builder.SetTitle("Sort By");
     builder.SetSingleChoiceItems(items.Select(x => x.title).ToArray(), selected, new MultiClickListener(this));
     var clickListener = new ActionClickListener(listAdapter, listView, list, this, true, isWorkshop);
     builder.SetPositiveButton("Sort", clickListener);
     builder.SetNegativeButton("Cancel", clickListener);
     builder.Create().Show();
 }
        //This is deprecated in API level 8
        //protected override Dialog OnCreateDialog(int id)

        //This is deprecated in API level 13
        protected override Dialog OnCreateDialog(int id, Bundle args)
        {
            switch(id)
            {
                case AlertDialog:
                    {
                        var builder = new AlertDialog.Builder(this);
					    builder.SetIconAttribute(Android.Resource.Attribute.AlertDialogIcon);
                        builder.SetTitle(Resource.String.bomb_dialog_title);

                        builder.SetPositiveButton(Resource.String.dialog_signal, (s, e) => { /*Do something here!*/ });
                        builder.SetNegativeButton(Resource.String.dialog_main_screen, (s, e) => { });

					    return builder.Create();
                    }
                case ListDialog:
                    {
                        var builder = new AlertDialog.Builder(this);
					    builder.SetIconAttribute(Android.Resource.Attribute.AlertDialogIcon);
                        builder.SetTitle(Resource.String.list_dialog_title);
                        builder.SetSingleChoiceItems(Resource.Array.list_dialog_items, 0, ListClicked);

                        builder.SetPositiveButton(Resource.String.dialog_ok, OkClicked);
                        builder.SetNegativeButton(Resource.String.dialog_cancel, CancelClicked);

					    return builder.Create();
                    }
                case MultiChoiceDialog:
                    {
                        var builder = new AlertDialog.Builder(this, Android.App.AlertDialog.ThemeHoloLight);
					    builder.SetIcon(Resource.Drawable.Icon);
                        builder.SetTitle(Resource.String.multi_choice_dialog_title);
                        builder.SetMultiChoiceItems(Resource.Array.multilist_dialog_items, 
                            new[] { false, true, false, true }, MultiListClicked);

					    builder.SetPositiveButton(Resource.String.dialog_ok, OkClicked);
					    builder.SetNegativeButton(Resource.String.multi_dialog_cancel, CancelClicked);

					    return builder.Create();
                    }
                case CustomViewDialog:
                    {
						var customView = LayoutInflater.Inflate (Resource.Layout.CustomDialog, null);

						var builder = new AlertDialog.Builder (this);
                        builder.SetView(customView);
						builder.SetPositiveButton (Resource.String.dialog_ok, OkClicked);
						builder.SetNegativeButton (Resource.String.dialog_cancel, CancelClicked);

						return builder.Create ();
                    }
            }

            return base.OnCreateDialog(id, args);
        }
Ejemplo n.º 4
0
		protected override void OnCreate (Bundle bundle)
		{
			base.OnCreate (bundle);

			SetContentView (Resource.Layout.OperatorActivity);

			ColorDrawable colorDrawable = new ColorDrawable (Color.ParseColor (Helpers.ColorHeader));
			ActionBar.SetBackgroundDrawable (colorDrawable); 

			BtnOperator = FindViewById<Button> (Resource.Id.BtnOperator);
			TxtOperator = FindViewById<TextView> (Resource.Id.TxtOperator);
			BntContinuar = FindViewById<Button> (Resource.Id.BntContinuar);

			TxtMobil= FindViewById<TextView> (Resource.Id.TxtMobil);

			BntContinuar.Click += ContinuarClick;
			BntContinuar.Enabled= false;
			BtnOperator.Click += (sender, e) => {


				List<string> Item = new List<string> ();


				Item.Add ("CLARO");
				Item.Add ("TIGO");
				Item.Add ("MOVISTAR");
				Item.Add ("UFF!");
				Item.Add ("AVANTEL");
				Item.Add ("VIRGIN");

				AlertDialog.Builder builder = new AlertDialog.Builder (this);
				builder.SetTitle ("LISTA  DE OPERADORES");
				builder.SetSingleChoiceItems (Item.ToArray (), -1, delegate(object  Sender, DialogClickEventArgs  E) {

					TxtOperator.Text = Item [E.Which];
					BntContinuar.Enabled= true;

				});

				builder.SetPositiveButton ("Ok", delegate { 

				

				});
				builder.Show ();


			};

		


		}
Ejemplo n.º 5
0
        public void Choose(Context context)
        {
            AlertDialog.Builder builder = new AlertDialog.Builder(context)
              .SetTitle("Select Theme")
              .SetPositiveButton(Android.Resource.String.Ok, delegate
            {
              Toast
                .MakeText(context, themes[selected], ToastLength.Short)
                .Show();

              Theme tmpTheme = (Theme)Activator.CreateInstance(Theme.ChartThemes[selected]);
              tmpTheme.Apply(chart);
            })
            .SetNegativeButton(Android.Resource.String.Cancel, CancelClicked);

              builder.SetSingleChoiceItems(themes, selected, (sender, args) =>
            {
              selected = args.Which;
            });

              builder.Create().Show();
        }
Ejemplo n.º 6
0
        protected override void OnCreate(Android.OS.Bundle savedInstanceState)
        {
            base.OnCreate(savedInstanceState);
            AlertDialog.Builder builder = new AlertDialog.Builder(this);
            builder.SetTitle(Resource.String.export_fileformats_title);
            builder.SetSingleChoiceItems(Resource.Array.export_fileformat_options, _fileFormatIndex,
                delegate(object sender, DialogClickEventArgs args) { _fileFormatIndex = args.Which; });
            builder.SetPositiveButton(Android.Resource.String.Ok, delegate
                {
                    Intent intent = new Intent(this, typeof(FileStorageSelectionActivity));
                    //intent.PutExtra(FileStorageSelectionActivity.AllowThirdPartyAppSend, true);

                    StartActivityForResult(intent, 0);
                });
            builder.SetNegativeButton(Resource.String.cancel, delegate {
                    Finish();
                });
            builder.Show();
        }
        private void chooseButtonClicked()
        {
            string[] items = { "Take Photo", "Choose Existing" };

            AlertDialog.Builder builder = new AlertDialog.Builder(this);
            AlertDialog alertDialog;

            builder.SetTitle("Select");
            builder.SetSingleChoiceItems(items, -1, (object sender, DialogClickEventArgs e) => {
                if ((int)e.Which == 0) {
                    Intent takePicture = new Intent(MediaStore.ActionImageCapture);
                    StartActivityForResult(takePicture, 0);
            //					StartActivityFromFragment(this.FragmentManager.GetFragment(), takePicture, 0);
            //					alertDialog.Dismiss();
                }
                else if ((int)e.Which == 1) {
                    Intent pickPhoto = new Intent(Intent.ActionPick, MediaStore.Images.Media.ExternalContentUri);
                    StartActivityForResult(pickPhoto, 1);
            //					StartActivityFromFragment(this.FragmentManager.GetFragment(), pickPhoto, 1);
            //					alertDialog.Dismiss();
                }
            });

            alertDialog = builder.Create();
            alertDialog.Show();
        }
Ejemplo n.º 8
0
        protected override void OnCreate(Bundle bundle)
        {
            base.OnCreate(bundle);

            var context = TaskScheduler.FromCurrentSynchronizationContext();

            // Set our view from the "main" layout resource
            SetContentView(Resource.Layout.Main);

            var send = FindViewById<Button>(Resource.Id.Send);
            var host = FindViewById<Button>(Resource.Id.Host);
            var connect = FindViewById<Button>(Resource.Id.Connect);
            var listView = FindViewById<ListView>(Resource.Id.dataList);
            var text = FindViewById<EditText>(Resource.Id.sendText);
            var adapter = new MessageAdapter();
            listView.Adapter = adapter;

            host.Click += (sender, e) =>
            {
                _progress = ProgressSpinner.Show(this, null, null, true, false);

                _service.Host(new MultiplayerGame
                {
                    Name = Build.Manufacturer.Trim() + " " + Build.Model.Trim(),
                })
                .ContinueWith(t =>
                {
                    if (t.IsFaulted)
                    {
                        ShowPopUp("Error", t.Exception.InnerExceptions.First().Message);
                    }
                    else
                    {
                        ShowPopUp("Success", "You have hosted a game.");
                    }

                }, context);
            };

            connect.Click += (sender, e) =>
            {
                _progress = ProgressSpinner.Show(this, null, null, true, false);
                _service.FindGames()
                    .ContinueWith(t =>
                    {
                        if (t.IsFaulted)
                        {
                            ShowPopUp("Error", t.Exception.InnerExceptions.First().Message);
                            return;
                        }

                        AlertDialog dialog = null;
                        var games = t.Result.Select(g => g.Name).ToArray();
                        var builder = new AlertDialog.Builder(this);
                        builder.SetTitle("Select Connection");
                        builder.SetSingleChoiceItems(games, -1, (s, o) =>
                        {
                            var game = t.Result.ElementAtOrDefault(o.Which);
                            if (game != null)
                            {
                                _progress = ProgressSpinner.Show(this, null, null, true, false);
                                dialog.Dismiss();
                                _service.Join(game).ContinueWith(c =>
                                {
                                    if (c.IsFaulted)
                                    {
                                        ShowPopUp("Error", c.Exception.InnerExceptions.First().Message);
                                    }
                                    else
                                    {
                                        ShowPopUp("Success", "You have connected to the game.");
                                    }
                                }, context);
                            }
                        });
                        dialog = builder.Create();
                        dialog.Show();
                        _progress.Dismiss();
                    }, context);
            };

            send.Click += (sender, e) =>
            {
                var message = new TestMessage
                {
                    Text = text.Text,
                    ShouldEcho = true,
                    TimeStamp = DateTime.Now
                };

                _service.Send("T", message).ContinueWith(t =>
                {
                    if (t.IsFaulted)
                    {
                        ShowPopUp("Error", t.Exception.InnerExceptions.First().Message);
                        return;
                    }

                }, context);
            };

            _service.Received += (sender, e) =>
            {
                var message = e.Message as TestMessage;
                if (message.ShouldEcho)
                {
                    adapter.Logs.Add("RECEIVED: " + message.Text);
                    adapter.NotifyDataSetChanged();
                    message.ShouldEcho = false;
                    _service.Send("T", message);
                }

                else
                {
                    adapter.Logs.Add("Send: " + message.Text + " Latency: " + message.RoundTripMillis);
                }
            };
        }
        protected override Dialog OnCreateDialog(int id)
        {
            switch (id) {
                case DIALOG_YES_NO_MESSAGE: {
                        var builder = new AlertDialog.Builder (this);
                        builder.SetIconAttribute (Android.Resource.Attribute.AlertDialogIcon);
                        builder.SetTitle (Resource.String.alert_dialog_two_buttons_title);
                        builder.SetPositiveButton (Resource.String.alert_dialog_ok, OkClicked);
                        builder.SetNegativeButton (Resource.String.alert_dialog_cancel, CancelClicked);

                        return builder.Create ();
                    }
                case DIALOG_YES_NO_OLD_SCHOOL_MESSAGE: {
                        var builder = new AlertDialog.Builder (this, Android.App.AlertDialog.ThemeTraditional);
                        builder.SetIconAttribute (Android.Resource.Attribute.AlertDialogIcon);
                        builder.SetTitle (Resource.String.alert_dialog_two_buttons_title);
                        builder.SetPositiveButton (Resource.String.alert_dialog_ok, OkClicked);
                        builder.SetNegativeButton (Resource.String.alert_dialog_cancel, CancelClicked);

                        return builder.Create ();
                    }
                case DIALOG_YES_NO_HOLO_LIGHT_MESSAGE: {
                        var builder = new AlertDialog.Builder (this, Android.App.AlertDialog.ThemeHoloLight);
                        builder.SetIconAttribute (Android.Resource.Attribute.AlertDialogIcon);
                        builder.SetTitle (Resource.String.alert_dialog_two_buttons_title);
                        builder.SetPositiveButton (Resource.String.alert_dialog_ok, OkClicked);
                        builder.SetNegativeButton (Resource.String.alert_dialog_cancel, CancelClicked);

                        return builder.Create ();
                    }
                case DIALOG_YES_NO_LONG_MESSAGE: {
                        var builder = new AlertDialog.Builder (this);
                        builder.SetIconAttribute (Android.Resource.Attribute.AlertDialogIcon);
                        builder.SetTitle (Resource.String.alert_dialog_two_buttons_msg);
                        builder.SetMessage (Resource.String.alert_dialog_two_buttons_msg);
                        builder.SetPositiveButton (Resource.String.alert_dialog_ok, OkClicked);
                        builder.SetNegativeButton (Resource.String.alert_dialog_cancel, CancelClicked);
                        builder.SetNeutralButton (Resource.String.alert_dialog_something, NeutralClicked);

                        return builder.Create ();
                    }
                case DIALOG_YES_NO_ULTRA_LONG_MESSAGE: {
                        var builder = new AlertDialog.Builder (this);
                        builder.SetIconAttribute (Android.Resource.Attribute.AlertDialogIcon);
                        builder.SetTitle (Resource.String.alert_dialog_two_buttons_msg);
                        builder.SetMessage (Resource.String.alert_dialog_two_buttons2ultra_msg);
                        builder.SetPositiveButton (Resource.String.alert_dialog_ok, OkClicked);
                        builder.SetNegativeButton (Resource.String.alert_dialog_cancel, CancelClicked);
                        builder.SetNeutralButton (Resource.String.alert_dialog_something, NeutralClicked);

                        return builder.Create ();
                    }
                case DIALOG_LIST: {
                        var builder = new AlertDialog.Builder (this);
                        builder.SetTitle (Resource.String.select_dialog);
                        builder.SetItems (Resource.Array.select_dialog_items, ListClicked);

                        return builder.Create ();
                    }
                case DIALOG_PROGRESS: {
                        progress_dialog = new ProgressDialog (this);
                        progress_dialog.SetIconAttribute (Android.Resource.Attribute.AlertDialogIcon);
                        progress_dialog.SetTitle (Resource.String.select_dialog);
                        progress_dialog.SetProgressStyle (ProgressDialogStyle.Horizontal);
                        progress_dialog.Max = MAX_PROGRESS;

                        progress_dialog.SetButton (Android.App.Dialog.InterfaceConsts.ButtonPositive, GetText (Resource.String.alert_dialog_ok), OkClicked);
                        progress_dialog.SetButton (Android.App.Dialog.InterfaceConsts.ButtonNegative, GetText (Resource.String.alert_dialog_cancel), CancelClicked);

                        return progress_dialog;
                    }
                case DIALOG_SINGLE_CHOICE: {
                        var builder = new AlertDialog.Builder (this);
                        builder.SetIconAttribute (Android.Resource.Attribute.AlertDialogIcon);
                        builder.SetTitle (Resource.String.alert_dialog_single_choice);
                        builder.SetSingleChoiceItems (Resource.Array.select_dialog_items2, 0, ListClicked);

                        builder.SetPositiveButton (Resource.String.alert_dialog_ok, OkClicked);
                        builder.SetNegativeButton (Resource.String.alert_dialog_cancel, CancelClicked);

                        return builder.Create ();
                    }
                case DIALOG_MULTIPLE_CHOICE: {
                        var builder = new AlertDialog.Builder (this);
                        builder.SetIcon (Resource.Drawable.ic_popup_reminder);
                        builder.SetTitle (Resource.String.alert_dialog_multi_choice);
                        builder.SetMultiChoiceItems (Resource.Array.select_dialog_items3, new bool[] { false, true, false, true, false, false, false }, MultiListClicked);

                        builder.SetPositiveButton (Resource.String.alert_dialog_ok, OkClicked);
                        builder.SetNegativeButton (Resource.String.alert_dialog_cancel, CancelClicked);

                        return builder.Create ();
                    }
                case DIALOG_MULTIPLE_CHOICE_CURSOR: {
                        var projection = new string[] { BaseColumns.Id, Contacts.PeopleColumns.DisplayName, Contacts.PeopleColumns.SendToVoicemail };
                        var cursor = ManagedQuery (ContactsContract.Contacts.ContentUri, projection, null, null, null);

                        var builder = new AlertDialog.Builder (this);
                        builder.SetIcon (Resource.Drawable.ic_popup_reminder);
                        builder.SetTitle (Resource.String.alert_dialog_multi_choice_cursor);
                        builder.SetMultiChoiceItems (cursor, Contacts.PeopleColumns.SendToVoicemail, Contacts.PeopleColumns.DisplayName, MultiListClicked);

                        return builder.Create ();
                    }
                case DIALOG_TEXT_ENTRY: {
                        // This example shows how to add a custom layout to an AlertDialog
                        var factory = LayoutInflater.From (this);
                        var text_entry_view = factory.Inflate (Resource.Layout.alert_dialog_text_entry, null);

                        var builder = new AlertDialog.Builder (this);
                        builder.SetIconAttribute (Android.Resource.Attribute.AlertDialogIcon);
                        builder.SetTitle (Resource.String.alert_dialog_text_entry);
                        builder.SetView (text_entry_view);
                        builder.SetPositiveButton (Resource.String.alert_dialog_ok, OkClicked);
                        builder.SetNegativeButton (Resource.String.alert_dialog_cancel, CancelClicked);

                        return builder.Create ();
                    }
            }
            return null;
        }
Ejemplo n.º 10
0
        protected override void OnCreate(Bundle bundle)
        {
            base.OnCreate(bundle);

            SetContentView(Resource.Layout.Main);

            WritePadAPI.recoInit(BaseContext);
            WritePadAPI.initializeFlags(BaseContext);

            var button = FindViewById<Button>(Resource.Id.RecognizeButton);
            var inkView = FindViewById<InkView>(Resource.Id.ink_view);
            var readyText = FindViewById<TextView>(Resource.Id.ready_text);
            var readyTextTitle = FindViewById<TextView>(Resource.Id.ready_text_title);
            var languageBtn = FindViewById<Button>(Resource.Id.LanguageButton);
            var optionsBtn = FindViewById<Button>(Resource.Id.OptionsButton);

            readyText.MovementMethod = new ScrollingMovementMethod();
            readyTextTitle.Text = Resources.GetString(Resource.String.Title) + " (" + WritePadAPI.getLanguageName() + ")";

            button.Click += delegate
            {
                readyText.Text = inkView.Recognize( false );
            };

            optionsBtn.Click += delegate
            {
                // show options dialog
                StartActivity( typeof(WritePadOptions) );

            };

            languageBtn.Click += delegate
            {
                var builder = new AlertDialog.Builder(this);
                builder.SetTitle("Select language");
                var languages = new[]{"English", "English (UK)", "German", "French", "Spanish", "Portuguese",
                    "Portuguese (Brazilian)", "Dutch", "Italian", "Finnish", "Sweddish", "Norwegian",
                    "Danish", "Indonesian"};
                var selection = 0;
                switch (WritePadAPI.language)
                {
                    case WritePadAPI.LanguageType.en:
                        selection = 0;
                        break;
                    case WritePadAPI.LanguageType.en_uk:
                        selection = 1;
                        break;
                    case WritePadAPI.LanguageType.de:
                        selection = 2;
                        break;
                    case WritePadAPI.LanguageType.fr:
                        selection = 3;
                        break;
                    case WritePadAPI.LanguageType.es:
                        selection = 4;
                        break;
                    case WritePadAPI.LanguageType.pt_PT:
                        selection = 5;
                        break;
                    case WritePadAPI.LanguageType.pt_BR:
                        selection = 6;
                        break;
                    case WritePadAPI.LanguageType.nl:
                        selection = 7;
                        break;
                    case WritePadAPI.LanguageType.it:
                        selection = 8;
                        break;
                    case WritePadAPI.LanguageType.fi:
                        selection = 9;
                        break;
                    case WritePadAPI.LanguageType.sv:
                        selection = 10;
                        break;
                    case WritePadAPI.LanguageType.nb:
                        selection = 11;
                        break;
                    case WritePadAPI.LanguageType.da:
                        selection = 12;
                        break;
                    case WritePadAPI.LanguageType.id:
                        selection = 13;
                        break;
                }
                builder.SetSingleChoiceItems(languages, selection, (sender, args) =>
                {
                    WritePadAPI.recoFree();
                    switch (args.Which)
                    {
                        case 0:
                            WritePadAPI.language = WritePadAPI.LanguageType.en;
                            break;
                        case 1:
                            WritePadAPI.language = WritePadAPI.LanguageType.en_uk;
                            break;
                        case 2:
                            WritePadAPI.language = WritePadAPI.LanguageType.de;
                            break;
                        case 3:
                            WritePadAPI.language = WritePadAPI.LanguageType.fr;
                            break;
                        case 4:
                            WritePadAPI.language = WritePadAPI.LanguageType.es;
                            break;
                        case 5:
                            WritePadAPI.language = WritePadAPI.LanguageType.pt_PT;
                            break;
                        case 6:
                            WritePadAPI.language = WritePadAPI.LanguageType.pt_BR;
                            break;
                        case 7:
                            WritePadAPI.language = WritePadAPI.LanguageType.nl;
                            break;
                        case 8:
                            WritePadAPI.language = WritePadAPI.LanguageType.it;
                            break;
                        case 9:
                            WritePadAPI.language = WritePadAPI.LanguageType.fi;
                            break;
                        case 10:
                            WritePadAPI.language = WritePadAPI.LanguageType.sv;
                            break;
                        case 11:
                            WritePadAPI.language = WritePadAPI.LanguageType.nb;
                            break;
                        case 12:
                            WritePadAPI.language = WritePadAPI.LanguageType.da;
                            break;
                        case 13:
                            WritePadAPI.language = WritePadAPI.LanguageType.id;
                            break;
                    }
                    WritePadAPI.recoInit(BaseContext);
                    WritePadAPI.initializeFlags(BaseContext);
                    inkView.cleanView(true);
                    readyTextTitle.Text = Resources.GetString(Resource.String.Title) + " (" + WritePadAPI.getLanguageName() + ")";
                });
                var alert = builder.Create();
                alert.Show();
            };
            inkView.OnReturnGesture += () => readyText.Text = inkView.Recognize( true );
            inkView.OnReturnGesture += () => inkView.cleanView(true);
            inkView.OnCutGesture += () => inkView.cleanView(true);
            var clearbtn = FindViewById<Button>(Resource.Id.ClearButton);
            clearbtn.Click += delegate
            {
                readyText.Text = "";
                inkView.cleanView(true);
            };
        }
Ejemplo n.º 11
0
        public void GmailPermissions()
        {
            if (!gmailBox.Checked)
                return;

            ISharedPreferences prefs = GetSharedPreferences (Global.PREFS_NAME, 0);
            string AccountName = prefs.GetString ("GmailName", "");

            if (AccountName == "")
            {
                // Pulls all on-phone accounts that resemble emails
                // and makes an array of the names
                Java.Util.Regex.Pattern emailPattern = Patterns.EmailAddress;
                Account[] accounts = AccountManager.Get (this).GetAccounts ();
                List<string> accountNames = new List<string> ();
                foreach (Account account in accounts)
                {
                    if (emailPattern.Matcher (account.Name).Matches ())
                        accountNames.Add (account.Name);
                }

                // If we have any account names
                if (accountNames.Count > 0)
                {
                    if (accountNames.Count == 1)
                    {
                        // If we only have one name available, just use it
                        AccountName = accountNames [0];
                        return;
                    }

                    // Otherwise, ask the user which account they would like to use
                    AlertDialog.Builder ad = new AlertDialog.Builder (this);

                    ad.SetTitle ("Choose an account to use with FlyoverChic.");

                    ad.SetCancelable (false);

                    int choice = 0;

                    ad.SetSingleChoiceItems (accountNames.ToArray (), 0, delegate(object sender, DialogClickEventArgs e) {
                        choice = e.Which;
                    })
                    .SetPositiveButton ("Got it!", delegate(object sender, DialogClickEventArgs e) {
                        AccountName = accountNames [choice];
                        Log.Debug (TAG, AccountName);
                    })
                    .SetNegativeButton ("Never mind.", delegate(object sender, DialogClickEventArgs e) {
                        AccountName = "";
                        gmailBox.Checked = false;
                    });
                    ad.Show ();
                }
                else
                {
                    gmailBox.Checked = false;
                }
                // If we get here, it means there were no available accounts on the phone.
                // Turn to alternatives - like having the user register one or some shit
            }
        }
Ejemplo n.º 12
0
        public Dialog TranslateLanguageDialog(Context context, bool fromReader = false)
        {
            // All downloaded languages
            string[] languages = DownloadedLanguages.ToArray();

            var builder = new AlertDialog.Builder(context);

            // No downloaded languages
            if (languages == null || languages.Length < 1)
            {
                builder.SetIcon(Resource.Drawable.Icon);
                builder.SetTitle("REMINDER");
                builder.SetMessage("No Language Packs are downloaded. Please download a Language Pack.");
                builder.SetPositiveButton("Ok", (sender, e) => { });
            }
            else
            {
                // The current selected language
                int index = Array.IndexOf(languages, Language);
                int selected = index;

                builder.SetIcon(Resource.Drawable.Icon);
                builder.SetTitle("Translate Language");
                builder.SetCancelable(false);
                builder.SetSingleChoiceItems(languages, index, (sender, e) =>
                {
                    selected = e.Which;
                });
                builder.SetPositiveButton("Ok", (sender, e) =>
                {
                    this.Language = languages[selected];

                    if (fromReader)
                    {
                        if (ReaderKind == NWTBible.ReaderKind.PublicationReader)
                        {
                            if (!allPublications.Any(x => x.Image == selectedPublication.Image))
                            {
                                return;
                            }
                        }

                        Activity act = context as Activity;
                        act.Finish();

                        Intent intent = new Intent(context, MainReader.Class);
                        context.StartActivity(intent);
                    }
                });
                builder.SetNegativeButton("Cancel", (sender, e) =>
                {
                    selected = index;
                });
            }

            return builder.Create();
        }