It depends on the type of focus you are after, `Logical` or `Keyboard`.

* **Keyboard focus** refers to the element that **currently** receives keyboard input. Only one element in the entire desktop can have keyboard focus.
* **Logical focus** refers to the element in a focus scope that **would** receive the keyboard input, **if** the focus scope was active. 

Usually the Logical Focus is the element which last received keyboard focus on that focus scope. A focus scope might be an app, a form, a top level window, a tab and so forth. In other words, logical focus is how a form or window remembers which control last had the keyboard focus. 

`FocusManager` gets the element with logical focus within the specified focus scope, in this case the Window (`this`):

    IInputElement focusedControl = FocusManager.GetFocusedElement(this);

`Keyboard` will return the element with the current keyboard input focus:

    IInputElement focusedControl =  Keyboard.FocusedElement;

How would I go about counting the words in a sentence? I&#39;m using Python.

For example, I might have the string: 

    string = &quot;I     am having  a   very  nice  23!@$      day. &quot;

That would be 7 words. I&#39;m having trouble with the random amount of spaces after/before each word as well as when numbers or symbols are involved. 

How to count the number of words in a sentence, ignoring numbers, punctuation and whitespace?

I am not able to clear the screen in the MySQL command line prompt. My screen is filled with tables, data and queries. How can I clear it up?





How can I clear the screen in the MySQL console?

How can I acquire the currently focused element/control in WPF from code that is part of neither a window nor an user control? 


Get currently focused element/control in a WPF window

<p>How can I acquire the currently focused element/control in WPF from code that is part of neither a window nor an user control?</p>


[This question][1] got me wondering about where the concrete implementaiton of a generic method actually comes into existence. I&#39;ve tried the google but am not coming up with the right search.

If we take this simple example:

    class Program
    {
        public static T GetDefault&lt;T&gt;()
        {
            return default(T);
        }
    
        static void Main(string[] args)
        {
            int i = GetDefault&lt;int&gt;();
            double d = GetDefault&lt;double&gt;();
            string s = GetDefault&lt;string&gt;();
        }
    }

in my head I&#39;ve always assumed that at some point it results in an implementation with the 3 necessary concrete implementations such that, in naive pseudo mangling, we would have this logical concrete implementaiton where the specific types used result in the correct stack allocations etc. 

    class Program
    {
        static void Main(string[] args)
        {
            int i = GetDefaultSystemInt32();
            double d = GetDefaultSystemFloat64();
            string s = GetDefaultSystemString();
        }
    
        static int GetDefaultSystemInt32()
        {
            int i = 0;
            return i;
        }
        static double GetDefaultSystemFloat64()
        {
            double d = 0.0;
            return d;
        }
        static string GetDefaultSystemString()
        {
            string s = null;
            return s;
        }
    }

Looking at the IL for the generic program it is still expressed in terms of generic types:

    .method public hidebysig static !!T  GetDefault&lt;T&gt;() cil managed
    {
      // Code size       15 (0xf)
      .maxstack  1
      .locals init ([0] !!T CS$1$0000,
               [1] !!T CS$0$0001)
      IL_0000:  nop
      IL_0001:  ldloca.s   CS$0$0001
      IL_0003:  initobj    !!T
      IL_0009:  ldloc.1
      IL_000a:  stloc.0
      IL_000b:  br.s       IL_000d
      IL_000d:  ldloc.0
      IL_000e:  ret
    } // end of method Program::GetDefault

So how and at what point is it decided that an int, and then a double and then a string have to be allocated on the stack and returned to the caller? Is this an operation of the JIT process? Am I looking at this in the completely wrong light?

  [1]: https://stackoverflow.com/questions/18257044/using-a-generic-type-argument-in-place-of-an-argument-of-type-system-type-is-it/19409760#19409760

How, when and where are generic methods made concrete?

I know it is considered generally a bad idea to use fire-and-forget `async void` methods to start tasks, because there is no track of the pending task and it is tricky to handle exceptions which might be thrown inside such a method.

*Should I generally avoid `async void` event handlers, as well?* For example, 

	private async void Form_Load(object sender, System.EventArgs e)
	{
            await Task.Delay(2000); // do async work
            // ...
	} 

I can rewrite it like this:

	Task onFormLoadTask = null; // track the task, can implement cancellation
	
	private void Form_Load(object sender, System.EventArgs e)
	{
            this.onFormLoadTask = OnFormLoadTaskAsync(sender, e);
	} 

	private async Task OnFormLoadTaskAsync(object sender, System.EventArgs e)
	{
            await Task.Delay(2000); // do async work
            // ...
	} 

*What are the underwater rocks for async event handlers, besides possible re-entrancy?*

Should I avoid &#39;async void&#39; event handlers?

I&#39;m trying to create an asynchronous console app that does a some work on a collection. I have one version which uses parallel for loop another version that uses async/await. I expected the async/await version to work similar to parallel version but it executes synchronously. What am I doing wrong?
```csharp
public class Program 
{
    public static void Main(string[] args) 
    {
        var worker = new Worker();
        worker.ParallelInit();
        var t = worker.Init();
        t.Wait();
        Console.ReadKey();
    }
}

public class Worker 
{
    public async Task&lt;bool&gt; Init() 
    {
        var series = Enumerable.Range(1, 5).ToList();
        foreach(var i in series) 
        {
          Console.WriteLine(&quot;Starting Process {0}&quot;, i);
          var result = await DoWorkAsync(i);
          
          if (result) 
          {
            Console.WriteLine(&quot;Ending Process {0}&quot;, i);
          }
        }

        return true;
    }

    public async Task&lt;bool&gt; DoWorkAsync(int i) 
    {
        Console.WriteLine(&quot;working..{0}&quot;, i);
        await Task.Delay(1000);
        
        return true;
    }

    public bool ParallelInit() 
    {
        var series = Enumerable.Range(1, 5).ToList();
        
        Parallel.ForEach(series, i =&gt; 
        {
            Console.WriteLine(&quot;Starting Process {0}&quot;, i);
            DoWorkAsync(i);
            Console.WriteLine(&quot;Ending Process {0}&quot;, i);
        });
        
        return true;
    }

}
```

How to use await in a loop

Trying to open a VS 2012 solution (SLN file) explicitly in VS 2013 succeeds. Simply double-clicking it in Windows Explorer still opens it in VS 2012 instead.

I&#39;ve read &quot;[Visual Studio 2012 doesn&#39;t convert vs2010 solution?][1]&quot; and followed the [suggestion to &quot;Save As...&quot; the solution file][2].

Still it opens in VS 2012 by default.

**My question:**

How to change a SLN file to force it being opened in Visual Studio 2013?


  [1]: https://stackoverflow.com/questions/12095339/visual-studio-2012-doesnt-convert-vs2010-solution
  [2]: https://stackoverflow.com/a/15776237/107625

How to force a Solution file (SLN) to be opened in Visual Studio 2013?

    int value=0;
   
    if (value == 0)
    {
        value = null;
    }

How can I set `value` to `null` above?

Any help will be appreciated.

How to set null value to int in c#?

*Warning: Very long and detailed post.*

Okay, validation in WPF when using MVVM. I’ve read many things now, looked at many SO questions, and tried *many* approaches, but everything feels somewhat hacky at some point and I’m really not sure how to do it *the right way*™.

Ideally, I want to have all validation happen in the view model using [`IDataErrorInfo`](http://msdn.microsoft.com/en-us/library/system.componentmodel.idataerrorinfo.aspx); so that’s what I did. There are however different aspects that make this solution be not a complete solution for the whole validation topic.

### The situation
Let’s take the following simple form. As you can see, it’s nothing fancy. We just have a two textboxes which bind to a `string` and `int` property in the view model each. Furthermore we have a button that is bound to an `ICommand`.

![Simple form with only a string and integer input][1]

So for the validation we now have a two choices:

1. We can run the validation automatically whenever the value of a text box changes. As such the user gets an instant response when he entered something invalid.
  * We can take this one step further to disable the button when there are any errors.
2. Or we can run the validation only explicitly when the button is pressed, then showing all errors if applicable. Obviously we can’t disable the button on errors here.

Ideally, I want to implement choice 1. For normal data bindings with activated [`ValidatesOnDataErrors`](http://msdn.microsoft.com/en-us/library/system.windows.data.binding.validatesondataerrors.aspx) this is default behavior. So when the text changes, the binding updates the source and triggers the `IDataErrorInfo` validation for that property; errors are reported back the view. So far so good.

### Validation status in the view model
The interesting bit is to let the view model, or the button in this case, know if there are any errors. The way `IDataErrorInfo` works, it is mainly there to report errors back to the view. So the view can easily see if there are any errors, display them and even show annotations using [`Validation.Errors`](http://msdn.microsoft.com/en-us/library/system.windows.controls.validation.errors.aspx). Furthermore, validation always happens looking at a single property.

So having the view model know when there are any errors, or if the validation succeeded, is tricky. A common solution is to simply trigger the `IDataErrorInfo` validation for all properties in the view model itself. This is often done using a separate `IsValid` property. The benefit is that this can also be easily used for disabling the command. The drawback is that this might run the validation on all properties a bit too often, but most validations should be simply enough to not hurt the performance. Another solution would be to remember which properties produced errors using the validation and only check those, but that seems a bit overcomplicated and unnecessary for most times.

The bottom line is that this could work fine. `IDataErrorInfo` provides the validation for all properties, and we can simply use that interface in the view model itself to run the validation there too for the whole object. Introducing the problem:

### Binding exceptions
The view model uses actual types for its properties. So in our example, the integer property is an actual `int`. The text box used in the view however natively only supports *text*. So when binding to the `int` in the view model, the data binding engine will automatically perform type conversions—or at least it will try. If you can enter text in a text box meant for numbers, the chances are high that there won’t always be valid numbers inside: So the data binding engine will fail to convert and throw a `FormatException`.

![Data binding engine throws an exception and that’s displayed in the view][2]

On the view side, we can easily see that. Exceptions from the binding engine are automatically caught by WPF and are displayed as errors—there isn’t even a need to enable [`Binding.ValidatesOnExceptions`](http://msdn.microsoft.com/en-us/library/system.windows.data.binding.validatesonexceptions.aspx) which would be required for exceptions thrown in the setter. The error messages do have a generic text though, so that could be a problem. I have solved this for myself by using a [`Binding.UpdateSourceExceptionFilter`](http://msdn.microsoft.com/en-us/library/system.windows.data.binding.updatesourceexceptionfilter.aspx) handler, inspecting the exception being thrown and looking at the source property and then generating a less generic error message instead. All that capsulated away into my own Binding markup extension, so I can have all the defaults I need.

So the view is fine. The user makes an error, sees some error feedback and can correct it. The view model however *is lost*. As the binding engine threw the exception, the source was never updated. So the view model is still on the old value, which isn’t what’s being displayed to the user, and the `IDataErrorInfo` validation obviously doesn’t apply.

What’s worse, there is no good way for the view model to know this. At least, I haven’t found a good solution for this yet. What would be possible is to have the view report back to the view model that there was an error. This could be done by data binding the [`Validation.HasError`](http://msdn.microsoft.com/en-us/library/system.windows.controls.validation.haserror.aspx) property back to the view model (which isn’t possible directly), so the view model could check the view’s state first.

Another option would be to relay the exception handled in `Binding.UpdateSourceExceptionFilter` to the view model, so it would be notified of it as well. The view model could even provide some interface for the binding to report these things, allowing for custom error messages instead of generic per-type ones. But that would create a stronger coupling from the view to the view model, which I generally want to avoid.

Another “solution” would be to get rid of all typed properties, use plain `string` properties and do the conversion in the view model instead. This obviously would move all validation to the view model, but also mean an incredible amount of duplication of things the data binding engine usually takes care of. Furthermore it would change the semantics of the view model. For me, a view is built for the view model and not the reverse—of course the design of the view model depends on what we imagine the view to do, but there’s still general freedom how the view does that. So the view model defines an `int` property because there is a number; the view can now use a text box (allowing all these problems), or use something that natively works with numbers. So no, changing the types of the properties to `string` is not an option for me.

In the end, this is a problem of the view. The view (and its data binding engine) is responsible for giving the view model proper values to work with. But in this case, there seems to be no good way to tell the view model that it should invalidate the old property value.

### BindingGroups
[Binding groups](http://msdn.microsoft.com/en-us/library/system.windows.data.bindinggroup.aspx) are one way I tried to tackle this. Binding groups have the ability to group all validations, including `IDataErrorInfo` and thrown exceptions. If available to the view model, they even have a mean to check the validation status for *all* of those validation sources, for example using [`CommitEdit`](http://msdn.microsoft.com/en-us/library/system.windows.data.bindinggroup.commitedit.aspx).

By default, binding groups implement choice 2 from above. They make the bindings update explicitly, essentially adding an additional *uncommitted* state. So when clicking the button, the command can *commit* those changes, trigger the source updates and all validations and get a single result if it succeeded. So the command’s action could be this:

     if (bindingGroup.CommitEdit())
         SaveEverything();

`CommitEdit` will only return true if *all* validations succeeded. It will take `IDataErrorInfo` into account and also check binding exceptions. This seems to be a perfect solution for choice 2. The only thing that is a bit of a hassle is managing the binding group with the bindings, but I’ve built myself something that mostly takes care of this ([related](https://stackoverflow.com/q/17596719/216074)).

If a binding group is present for a binding, the binding will default to an explicit [`UpdateSourceTrigger`](http://msdn.microsoft.com/en-us/library/system.windows.data.updatesourcetrigger.aspx). To implement choice 1 from above using binding groups, we basically have to change the trigger. As I have a custom binding extension anyway, this is rather simple, I just set it to `LostFocus` for all.

So now, the bindings will still update whenever a text field changes. If the source could be updated (binding engine throws no exception) then `IDataErrorInfo` will run as usual. If it couldn’t be updated the view is still able to see it. And if we click our button, the underlying command can call `CommitEdit` (although nothing needs to be committed) and get the total validation result to see if it can continue.

We might not be able to disable the button easily this way. At least not from the view model. Checking the validation over and over is not really a good idea just to update the command status, and the view model isn’t notified when a binding engine exception is thrown anyway (which should disable the button then)—or when it goes away to enable the button again. We could still add a trigger to disable the button in the view using the [`Validation.HasError`](http://msdn.microsoft.com/en-us/library/system.windows.controls.validation.haserror.aspx) so it’s not impossible.

### Solution?
So overall, this seems to be the perfect solution. What is my problem with it though? To be honest, I’m not entirely sure. Binding groups are a complex thing that seem to be usually used in smaller groups, possibly having multiple binding groups in a single view. By using one big binding group for the whole view just to ensure my validation, it feels as if I’m abusing it. And I just keep thinking, that there must be a better way to solve this whole situation, because surely I can’t be the only one having these problems. And so far I haven’t really seen many people use binding groups for validation with MVVM at all, so it just feels odd.

So, what exactly is the proper way to do validation in WPF with MVVM while being able to check for binding engine exceptions?

  [1]: http://i.stack.imgur.com/UqvT1.png
  [2]: http://i.stack.imgur.com/NK46t.png


----

## My solution (/hack)

First of all, thanks for your input! As I have written above, I’m using `IDataErrorInfo` already to do my data validation and I personally believe it’s the most comfortable utility to do the validation job. I’m using utilities similar to what Sheridan suggested in his answer below, so maintaining works fine too.

In the end, my problem boiled down to the binding exception issue, where the view model just wouldn’t know about when it happened. While I could handle this with binding groups as detailed above, I still decided against it, as I just didn’t feel all that comfortable with it. So what did I do instead?

As I mentioned above, I detect binding exceptions on the view-side by listening to a binding’s `UpdateSourceExceptionFilter`. In there, I can get a reference to the view model from the binding expression’s [`DataItem`](http://msdn.microsoft.com/en-us/library/system.windows.data.bindingexpression.dataitem.aspx). I then have an interface `IReceivesBindingErrorInformation` which registers the view model as a possible receiver for information about binding errors. I then use that to pass the binding path and the exception to the view model:

    object OnUpdateSourceExceptionFilter(object bindExpression, Exception exception)
    {
        BindingExpression expr = (bindExpression as BindingExpression);
        if (expr.DataItem is IReceivesBindingErrorInformation)
        {
            ((IReceivesBindingErrorInformation)expr.DataItem).ReceiveBindingErrorInformation(expr.ParentBinding.Path.Path, exception);
        }

        // check for FormatException and produce a nicer error
        // ...
     }

In the view model I then remember whenever I am notified about a path’s binding expression:

    HashSet&lt;string&gt; bindingErrors = new HashSet&lt;string&gt;();
    void IReceivesBindingErrorInformation.ReceiveBindingErrorInformation(string path, Exception exception)
    {
        bindingErrors.Add(path);
    }

And whenever the `IDataErrorInfo` revalidates a property, I know that the binding worked, and I can clear the property from the hash set.

In the view model I then can check if the hash set contains any items and abort any action that requires the data to be validated completely. It might not be the nicest solution due to the coupling from the view to the view model, but using that interface it’s at least somewhat less a problem.

Proper validation with MVVM

I have 3 TextBoxes (`Id1`,`Name` and `Salary`). `Id` and `Salary` should contain integers and `Name` should only contain characters. I need validations for my TextBox, it should show errors as I enter wrong characters or integers. Also can this be done only in Xaml without codebehind? Please help me with the required code

This is Xaml code:

    &lt;TextBox Name=&quot;tb1&quot; HorizontalAlignment=&quot;Left&quot; Height=&quot;20&quot; Margin=&quot;60,10,0,0&quot; TextWrapping=&quot;NoWrap&quot; Text=&quot;{Binding SelectedItem.Id,ElementName=dgsample}&quot; VerticalAlignment=&quot;Top&quot; Width=&quot;100&quot; /&gt;
    &lt;TextBox Name=&quot;tb2&quot; HorizontalAlignment=&quot;Left&quot; Height=&quot;20&quot; Margin=&quot;60,60,0,0&quot; TextWrapping=&quot;NoWrap&quot; Text=&quot;{Binding SelectedItem.Name, ElementName=dgsample}&quot; VerticalAlignment=&quot;Top&quot; Width=&quot;100&quot;/&gt;
    &lt;TextBox Name=&quot;tb3&quot; HorizontalAlignment=&quot;Left&quot; Height=&quot;20&quot; Margin=&quot;60,110,0,0&quot; TextWrapping=&quot;NoWrap&quot; Text=&quot;{Binding SelectedItem.Salary, ElementName=dgsample}&quot; VerticalAlignment=&quot;Top&quot; Width=&quot;100&quot;/&gt;

Implement Validation for WPF TextBoxes

I have a WPF application with multiple views. I want to switch from view 1 to view 2 and from there I can switch to multiple views. So I want a button on view 1 that loads view2 in the same window.

I tried those things, but can&#39;t get it to work.

 - https://stackoverflow.com/questions/9290269/mvvm-light-toolkit-galasoft-for-wpf-navigation-through-windows
 - https://galasoft.ch/posts/2011/01/navigation-in-a-wp7-application-with-mvvm-light

From the first link, the problem is that I don&#39;t understand the ViewModelLocator code. They call the `CreateMain();` function but where is this defined, and how can I switch to another view from inside a view.

WPF MVVM navigate views

**Why This?**

MainWindow.xaml:

    &lt;Window x:Class=&quot;MVVMProject.MainWindow&quot;
        xmlns=&quot;http://schemas.microsoft.com/winfx/2006/xaml/presentation&quot;
        xmlns:x=&quot;http://schemas.microsoft.com/winfx/2006/xaml&quot;&gt;
        &lt;Grid&gt;
            &lt;ContentControl Content=&quot;{Binding}&quot;/&gt;
        &lt;/Grid&gt;
    &lt;/Window&gt;

Have your ExampleView.xaml set up as:

    &lt;ResourceDictionary xmlns=&quot;http://schemas.microsoft.com/winfx/2006/xaml/presentation&quot;
        xmlns:x=&quot;http://schemas.microsoft.com/winfx/2006/xaml&quot;
        xmlns:vms=&quot;clr-namespace:MVVMProject.ViewModels&quot;&gt;
        &lt;DataTemplate DataType=&quot;{x:Type vms:ExampleVM}&quot; &gt;
            &lt;Grid&gt;
                &lt;ActualContent/&gt;
            &lt;/Grid&gt;
        &lt;/DataTemplate&gt;
    &lt;/ResourceDictionary&gt;

And create the window like this:

    public partial class App : Application {

        protected override void OnStartup(StartupEventArgs e) {

            base.OnStartup(e);

            MainWindow app = new MainWindow();
            ExampleVM context = new ExampleVM();
            app.DataContext = context;
            app.Show();
        }
    }

***

**When it can be done like this?**

App.xaml: (Set startup window/View)

    &lt;Application x:Class=&quot;MVVMProject.App&quot;
        xmlns=&quot;http://schemas.microsoft.com/winfx/2006/xaml/presentation&quot;
        xmlns:x=&quot;http://schemas.microsoft.com/winfx/2006/xaml&quot;
        StartupUri=&quot;ExampleView.xaml&quot;&gt;
    &lt;/Application&gt;

ExampleView.xaml: (a Window not a ResourceDictionary)

    &lt;Window x:Class=&quot;MVVMProject.ExampleView&quot;
        xmlns=&quot;http://schemas.microsoft.com/winfx/2006/xaml/presentation&quot;
        xmlns:x=&quot;http://schemas.microsoft.com/winfx/2006/xaml&quot;
        xmlns:vms=&quot;clr-namespace:MVVMProject.ViewModels&quot;&gt;
        &gt;
        &lt;Window.DataContext&gt;
            &lt;vms:ExampleVM /&gt;
        &lt;/Window.DataContext&gt;

        &lt;Grid&gt;
            &lt;ActualContent/&gt;
        &lt;/Grid&gt;
    &lt;/Window&gt;

***

Essentially it&#39;s **&quot;View as DataTemplate&quot; (VaD) vs. &quot;View as Window&quot; (VaW)**

Here is my understanding of the comparison: 

 - VaD: Lets you switch Views without closing the window. (This is not desirable for my project)
 - VaD: VM knows absolutely nothing about the View, whereas in VaW it (only) has to be able to instantiate it when opening another window
 - VaW: I can actually see my xaml rendered in the Designer (I can&#39;t
   with VaD, at least in my current setup)  
 - VaW: Works intuitively with
   opening and closing windows; each window has (is) a corresponding View
   (and ViewModel)
 - VaD: ViewModel can pass along initial window width, height, resizability etc. through properties (whereas in VaW they are directly set in the Window)
 - VaW: Can set FocusManager.FocusedElement (not sure how in VaD)
 - VaW: Less files, since my window types (e.g. Ribbon, Dialog) are incorporated into their Views

***

So what&#39;s going on here?  Can&#39;t I just build my windows in XAML, access their data cleanly through properties of the VM, and be done with it? The code-behind is the same (virtually nil). 

I&#39;m struggling to understand why I should shuffle all the View stuff into a ResourceDictionary.


WPF MVVM Why use ContentControl + DataTemplate Views rather than straight XAML Window Views?

Is it possible to make a window stay always on top even when other application is running on Fullscreen? I&#39;m using right now `TopMost = true` but when other application is running on fullscreen mine becomes invisible. It&#39;s `WindowStyle = None` window by the way.

**Edit**: And do not let other window minimalize ofcourse

WPF Always On Top

I am looking to achieve this:
http://getbootstrap.com/javascript/#popovers-examples - scroll to the &quot;live Demo&quot; and hit the red popover button, in Chrome on OS X.... It&#39;s perfect beautiful

Now go here (the problem child): http://yoyo.io/javascript/#popovers - it outlines blue, aaaargh.

If you inspect you will see a litany of CSS efforts from me to remove this!
It looks correct in Safari and Firefox but a no go in Chrome!

Anyone - what am I overlooking??

Many thanks in advance!

Bootstrap button - remove outline on Chrome OS X

I have a fairly complex (not really) xml layout file. One of the views is a LinearLayout (`v1`) with two children: an EditText(`v2`) and another LinearLayout(`v3`). The child LinearLayout in turn has an EditText(`v4`) and an ImageView(`v5`).

For EditText v2 I have imeOptions as
 
    android:imeOptions=&quot;actionNext&quot;

But when I run the app, the keyboard&#39;s `return` does not check to `next` and I want it to change to `next`. How do I fix this problem?

Also, when user clicks next, I want focus to go to EditText v4. I do I do this?


For those who really need to see some code:

    &lt;LinearLayout
			android:id=&quot;@+id/do_txt_view&quot;
			android:layout_width=&quot;match_parent&quot;
			android:layout_height=&quot;wrap_content&quot;
			android:background=&quot;@color/col6&quot;
			android:orientation=&quot;vertical&quot;
			android:visibility=&quot;gone&quot; &gt;

			&lt;EditText
				android:id=&quot;@+id/gm_title&quot;
				android:layout_width=&quot;match_parent&quot;
				android:layout_height=&quot;wrap_content&quot;
				android:layout_margin=&quot;5dp&quot;
				android:background=&quot;@drawable/coldo_text&quot;
				android:hint=&quot;@string/enter_title&quot;
				android:maxLines=&quot;1&quot;
				android:imeOptions=&quot;actionNext&quot;
				android:padding=&quot;5dp&quot;
				android:textColor=&quot;pigc7&quot;
				android:textSize=&quot;ads2&quot; /&gt;

			&lt;LinearLayout
				android:layout_width=&quot;match_parent&quot;
				android:layout_height=&quot;100dp&quot;
				android:orientation=&quot;horizontal&quot; &gt;

				&lt;EditText
					android:id=&quot;@+id/rev_text&quot;
					android:layout_width=&quot;0dp&quot;
					android:layout_height=&quot;match_parent&quot;
					android:layout_gravity=&quot;center_vertical&quot;
					android:layout_margin=&quot;5dp&quot;
					android:layout_weight=&quot;1&quot;
					android:background=&quot;@drawable/coldo_text&quot;
					android:hint=&quot;@string/enter_msg&quot;
					android:maxLines=&quot;2&quot;
					android:padding=&quot;5dp&quot;
					android:textColor=&quot;pigc7&quot;
					android:textSize=&quot;ads2&quot; /&gt;

				&lt;ImageView
					android:layout_width=&quot;wrap_content&quot;
					android:layout_height=&quot;match_parent&quot;
					android:layout_gravity=&quot;center_vertical&quot;
					android:background=&quot;@drawable/colbtn_r”
					android:clickable=&quot;true&quot;
					android:onClick=“clickAct”
					android:paddingLeft=&quot;5dp&quot;
					android:paddingRight=&quot;5dp&quot;
					android:src=&quot;@drawable/abcat” /&gt;
			&lt;/LinearLayout&gt;
		&lt;/LinearLayout&gt;

Setting EditText imeOptions to actionNext has no effect

I want to know the actual difference between them... When should each be used, how should each be used, and in which situations is each helpful?

Give some examples and explain them in detail.

Difference between focusable and focusableInTouchMode?

Let&#39;s say you have something like:

    &lt;div class=&quot;parent&quot;&gt;
        &lt;input class=&quot;childInput&quot; type=&quot;text&quot; /&gt;
        &lt;div class=&quot;sibling&quot;&gt;&lt;/div&gt;
    &lt;/div&gt;


I want to change the appearance of the parent/siblings when the child receives focus. Are there any CSS tricks for doing stuff like this?

&lt;b&gt;Edit:&lt;/b&gt;

The reason for my question is as follows:

I&#39;m creating an Angular app which needs editable text fields. It should look like a label until it is clicked, at which point it should look like a normal text input. I styled the text field based on :focus to achieve this effect, but the text is cut off by text input&#39;s boundaries. I also used ng-show, ng-hide, ng-blur, ng-keypress and ng-click to switch between the label and the text input based on blurs, key presses and clicks. This worked fine except for one thing: After the label&#39;s ng-click=&quot;setEdit(this, $event)&quot; changes the edit boolean used by ng-show and ng-hide to true, it uses a jQuery call to .select() the text input. However, it isn&#39;t until after the completion of the ng-click that everything is $digest&#39;d, so the text input loses focus again. Since the text input never actually receives focus, using ng-blur to revert back to showing the label is buggy: The user has to click in the text input and then click out of it again to revert back to showing the label.

&lt;b&gt;Edit:&lt;/b&gt;

Here&#39;s an example plunk of the issue: http://plnkr.co/edit/synSIP?p=preview

CSS: Change parent on focus of child

After looking for examples of how set focus elements with angular, I saw that most of them use some variable to watch for then set focus, and most of them use one different variable for each field they want to set focus. In a form, with a lot of fields, that implies in a lot of different variables.

With jquery way in mind, but wanting to do that in angular way, I made a solution that we set focus in any function using the element&#39;s id, so, as I am very new in angular, I&#39;d like to get some opinions if that way is right, have problems, whatever, anything that could help me do this the better way in angular.

Basically, I create a directive that watch a scope value defined by the user with directive, or the default&#39;s focusElement, and when that value is the same as the element&#39;s id, that element set focus itself.


    angular.module(&#39;appnamehere&#39;)
      .directive(&#39;myFocus&#39;, function () {
        return {
          restrict: &#39;A&#39;,
          link: function postLink(scope, element, attrs) {
            if (attrs.myFocus == &quot;&quot;) {
              attrs.myFocus = &quot;focusElement&quot;;
            }
            scope.$watch(attrs.myFocus, function(value) {
              if(value == attrs.id) {
                element[0].focus();
              }
            });
            element.on(&quot;blur&quot;, function() {
              scope[attrs.myFocus] = &quot;&quot;;
              scope.$apply();
            })        
          }
        };
      });

An input that needs to get focus by some reason, will do this way

    &lt;input my-focus id=&quot;input1&quot; type=&quot;text&quot; /&gt;

Here any element to set focus:

    &lt;a href=&quot;&quot; ng-click=&quot;clickButton()&quot; &gt;Set focus&lt;/a&gt;

And the example function that set focus:

    $scope.clickButton = function() {
        $scope.focusElement = &quot;input1&quot;;
    }

Is that a good solution in angular? Does it have problems that with my poor experience I don&#39;t see yet?

Content Type	Original Author	Original Content on Stackoverflow
Question	honzajscz	View Question on Stackoverflow
Solution 1 - .Net	sa_ddam213	View Answer on Stackoverflow

Get currently focused element/control in a WPF window

.Net Problem Overview

.Net Solutions

Solution 1 - .Net

How can I clear the screen in the MySQL console?

How to count the number of words in a sentence, ignoring numbers, punctuation and whitespace?

Attributions