Bildschirmtastatur als User Controll WPF Fenster hinzufügen

Alaiya · 18. Oktober 2013

Das alte Problem ist mittlerweile gelöst. Aber dafür habe ich ein anderes Problemchen :D Hier im Posting beschrieben!

Ich bin mal wieder am rumspielen mit meinem Touchlaptop.

Ich bin mittlerweile super unzufrieden mit der normalen Windows TipTap Bildschirmtastatur, weil mir die Buttons zu klein sind, und habe mir eine eigene Tastatur gebaut. Nun ist nur die Frage: Wie bekomme ich die Buchstaben in ein Textfeld?

Erst einmal probiere ich gerade so herum, dass ich eine RTF-Textbox in einem Fenster mit der Tastatur bearbeiten kann... Und ja... Ohne großes Drumherum: Meine Idee ist, dass die Klasse der Tastatur den public String inputtext besitzt, in den das ganze EIGENTLICH schreibt, der aber in der Textbox namens testbox angezeigt wird... Nur so ganz funktioniert das noch nicht.
Fehler gibt es nicht - aber er schreibt eben auch nicht.
Ideen?

(Habe das ganze erst einmal nur für einen Button als Beispiel gemacht... Wenn der funktioniert, dann kann man die anderen Buttons mit Buchstaben hinterherreichen.)

Form mit Textbox

C#

using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Windows.Forms;namespace TastaturTest{    public partial class Schreibformular : Form    {        public Schreibformular1()        {            InitializeComponent();        }        private void testbox_click(object sender, EventArgs e)        {            Tastatur tastatur = new Tastatur();            tastatur.Show();            if (testbox.Text != "")            {                tastatur.inputtext = (String)testbox.Text;            }            String addText = tastatur.inputtext;            testbox.AppendText(addText);        }    }}

C#

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;


namespace TastaturTest
{
    public partial class Tastatur : Form
    {
        public String inputtext = "";


        public Tastatur()
        {
            InitializeComponent();


        }




        private void btnA_Click(object sender, EventArgs e)
        {
            inputtext = inputtext + "A";
        }
    }
}

Alles anzeigen

(Und ja, ich weiß, dass mit dem Text, so wie er da steht, ich unendlich viel Bildschirmtastaturen aufrufen kann - aber das zu verhindern ist ja keine große Sache.)

Übrigens: Die nächste Frage wäre, wie ich es hinbekomme, wenn ich zum Beispiel ein "Formular" mit mehreren Textfeldern habe, dass die Tastatur immer ins Aktive schreibt...

Steampunk Mew · 18. Oktober 2013

Ich bin mir mit meinen Annahmen nicht ganz sicher, aber ich denke du hast ein paar Denkfehler drin. Es ist relativ logisch, dass es dir den Text nicht hinzufügt, wenn du's dem Programm nicht sagst ;)
Du fügst zwar den getippten Buchstaben in den String "inputtext" ein, aber er wird nirgends in deine textbox geschrieben (zumindest nicht, wenn sie leer ist). Ich würde dir empfehlen, das Programm ganz anders aufzubauen und den Text in der Button_Click-Methode direkt in das Textfeld UND den String eingegeben wird.
So wie du es momentan machst, wird in die Textbox nur etwas reingeschrieben, wenn hier das Click-Event aufgerufen wird, wodurch ja auch jedes Mal ein neues Tastatur-Objekt erstellt wird, zudem überschreibst du den inputtext, wenn die Textbox nicht leer ist, wodurch du höchstens ein Zeichen eintragen kannst.

Alaiya · 18. Oktober 2013

Zitat von Steampunk Mew

Ich würde dir empfehlen, das Programm ganz anders aufzubauen und den Text in der Button_Click-Methode direkt in das Textfeld UND den String eingegeben wird.

Aber wie. Mein Problem ist, dass ich Zustände und dergleichen übergeben kann - aber wie kann ich etwas, das einem Button oder anderen grafischen Element von dem Tastatur-Form an die Textbox des Textfenster-Form übergeben?

Steampunk Mew · 18. Oktober 2013

Property oder Methode für den Inhalt der Textbox schreiben und darauf zugreifen. Die Textbox sollte halt irgendwie von der Tastatur aus erreichbar sein, nicht umgekehrt. Das meinte ich mit anders aufbauen.

Alaiya · 18. Oktober 2013

Das es umgekehrt ideal wäre, ist mir auch klar (weil die Tastatur eigentlich ja mehr als für ein Programm funktionieren soll). Aber das Problem ist, die Methode so ansprechbar zu gestalten, dass sie sämtliche Buchstaben entgegennehmen kann.
Konkrete Ideen sind gerne gesehen.

Problem ist vor allem, dass letzten Endes IMMER der Frame, in den ich schreibe, die Tastatur aufruft - und damit die Instanz erzeugt - und nicht umgekehrt. Und ich gebe offen zu: Ich weiß nicht, wie ich auf den Parent zugreife, weil es eben kein klassischer Parent ist.

Steampunk Mew · 18. Oktober 2013

Wieso so schwierig? Ich weiß nicht, was dich davon abhält, es einfach umzudrehen oder gar beides in eins zu packen.

Alaiya · 18. Oktober 2013

Ich will die Tastatur für verschiedene Eingaben benutzen.

Ich bin aber für die Eingabe an sich auf eine Lösung gekommen: C# kann Keystrokes immitieren. Das Problem ist nur, dass die Tastatur nun wissen soll in welches Textfeld die Keystrokes sollen.
Denn sobald ich die Tastatur, die ein Fenster ist, benutzt wird, ist sie ja das aktuelle aktive Element und nicht mehr die Textbox, die aber aktiv sein müsste, damit die Keystrokes in ihr angezeigt werden.

Steampunk Mew · 19. Oktober 2013

Deswegen sage ich, du sollst es zusammenfassen, in ein Fenster. Aktiv kriegst du sie dadurch zwar nicht, aber du kannst direkt darauf zugreifen und die Keystrokes oder was-auch-immer direkt zu ihr weiterleiten.
Die Textbox könntest du übrigens in der Button-Click-Methode aktiv werden lassen, bevor du den Keystroke simulierst, wenn du das unbedingt möchtest, aber ich glaube nicht, dass das wirklich nötig ist.

Alaiya · 19. Oktober 2013

Wie gesagt: In einem Fenster ist nicht das, was ich haben will. Ich möchte eine ECHTE Bildschirmtastatur bauen. Die ich aufrufen kann und damit dann beliebig in anderen Fenstern schreiben kann. Sei es in einem selbstgeschriebenen Programm oder hier im Browser.

immu · 19. Oktober 2013

Das ganze ist eigentlich sehr einfach. Du kannst die System.Windows.Forms.SendKeys.Send(string)-Methode verwenden, um einen Tastendruck zu simulieren. Und dann musst du nur noch verhindern, dass dein eigenen Programm des Fokus von dem Programm, in welchem du schreibst, wegnimmt. Das machst du, indem du die CreateParams des Fensters überschreibst.

Kleines Beispiel:

OnScreenKeyboard.Designer.cs:

Code

partial class OnScreenKeyboard{    /// <summary>    /// Required designer variable.    /// </summary>    private System.ComponentModel.IContainer components = null;    /// <summary>    /// Clean up any resources being used.    /// </summary>    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>    protected override void Dispose(bool disposing)    {        if (disposing && (components != null))        {            components.Dispose();        }        base.Dispose(disposing);    }    #region Windows Form Designer generated code    /// <summary>    /// Required method for Designer support - do not modify    /// the contents of this method with the code editor.    /// </summary>    private void InitializeComponent()    {        this.btnA = new System.Windows.Forms.Button();        this.SuspendLayout();        //         // btnA        //         this.btnA.Location = new System.Drawing.Point(12, 12);        this.btnA.Name = "btnA";        this.btnA.Size = new System.Drawing.Size(75, 23);        this.btnA.TabIndex = 0;        this.btnA.Text = "A";        this.btnA.UseVisualStyleBackColor = true;        this.btnA.Click += new System.EventHandler(this.btnA_Click);        //         // Form1        //         this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;        this.ClientSize = new System.Drawing.Size(284, 262);        this.Controls.Add(this.btnA);        this.Name = "Form1";        this.Text = "Form1";        this.ResumeLayout(false);    }    #endregion    private System.Windows.Forms.Button btnA;}

OnScreenKeyboard.cs:

Code

public partial class OnScreenKeyboard : Form
{
    const int WS_EX_NOACTIVATE = 0x08000000;
    const int WS_EX_TOPMOST = 0x00000008;


    public OnScreenKeyboard()
    {
        InitializeComponent();
    }


    protected override CreateParams CreateParams
    {
        get
        {
            var b = base.CreateParams;
            b.ExStyle |= WS_EX_NOACTIVATE;  //Damit die aktive Applikation den Fokus nicht verliert.
            b.ExStyle |= WS_EX_TOPMOST;     //Damit deine Tastatur immer im Vordergrund bleibt.
            return b;
        }
    }


    private void btnA_Click(object sender, EventArgs e)
    {
        SendKeys.Send("A");
    }
}

Alles anzeigen

Alaiya · 7. November 2013

Das funktioniert wunderbar :D Nutze die Tastatur, wenn ich über den Bildschirm schreiben muss nun immer.

So, nun habe ich aber eine Frage:

Ich habe die Tastatur noch einmal als ein gesondertes UserControll-Element geschrieben - in WPF. Das Ding sollte so funktionieren und alles - weil der Code bezüglich der Replys ist ja auch gleich.

Nur habe ich nun ein anderes Problem. Und zwar, wie ich das User-Controll anzeigen soll. Weil eigene UserControlls in WPF anzeigen mir irgenwie spanisch vorkommt.

Was ich machen möchte ist folgendes: Ich habe ein Notizbrettchen (ja, mein Notiz-Brettchen App geht in die WPF Version) und damit möchte ich nun zwei Dinge mit der Tastatur machen.
1) Wenn ich auf eine Stelle Doppel Tappe, dann soll da ein neuer Notizzettel (natürlich auch ein eigenes User-Controll) erscheinen und direkt unter dem Notizzettel erst einmal die Tastatur (es sei denn ich klicke sie weg) mit der ich DIESEN Notizzettel bearbeiten kann - aber nur diesen einen.

2) Wenn ich auf das Textfeld im Notizzettel tappe möchte ich, dass die Tastatur - sofern sie noch nicht offen ist - neu inizialisiert wird.

Es ist kein Problem, dass der Notizzettel weiß, ob er eine offene Tastatur hat (das habe ich schon in WinForms durchgespielt und der CS ist ja dasselbe). Also das ist es nicht.
Was mein Problem ist: Woher weiß die Tastatur, zu welchem Zettel sie gehört?
Und ja, allgemein: Wie bekomme ich die Sachen dazu irgendwie im WPF-Fenster angezeigt zu werden?! Die Abfrage des Tap-Punktes ist ja nicht schwer und ich weiß denke ich auch, wie ich dass dann auf die Inizialisierung haue. Aber ich habe nach drei Tutorials immer noch keinen wirklichen Plan davon, wie ich das ganze dazu bekomme im WPF Fenster zu erscheinen.

Benutzer online in diesem Thema