Tworzenie tabeli przy użyciu textboxa – #1

Krótki opis całego programu który zostanie wykonany: Program do dynamicznego tworzenia tablicy z TextBox’ów o zadanej ilości komórek, wraz z możliwością zmiany niektórych właściwości wybranych komórek.

Co tym razem: Tworzenie tabeli z wykorzystaniem TextBoxa w głównym oknie tabeli o podanej ilości komórek i w podanej ilości kolumn.

Tym wpisem rozpoczynam minicykl – może 3-4 – wpisów który jest częścią całego działu dotyczącego programowania w C# w Visual Studio.

Dlaczego minicykl kilku wpisów o programowaniu w C# – a to dlatego, że będzie on dotyczył kilku, kilkunastu zagadnień które zostaną poruszane w programie, który zaraz wam opiszę.

Mam zamiar również opisać, w jaki sposób szukałem informacji, oraz sposobów rozwiązania danego problemu. Czy mi się uda – tego nie wiem. Okaże się po waszych komentarzach. Ostrzegam również, że mogą pojawić się jakieś błędy merytoryczne, oraz błędy dot. zasad programowania w C# – dlatego proszę o wyrozumiałość, oraz wskazywanie takich błędów, a jak będzie wyjaśnienie takiego błędu to będzie super. Ja coś wam daję, a i wy coś mi zaoferujecie 😉

Program, który wykonamy będzie umożliwiał utworzenie tablica o n komórkach i m wierszach – pokaże też jak zmienić to kod aby tworzył tabelę o x wierszach i z kolumnach. Dodatkowo będzie możliwość zmiany koloru danej komórki i tekstu w niej. Będzie również możliwość dodania inkrementacji wartości w wybranych komórkach. To z takich ważniejszych właściwości – będzie ich więcej, ale okaże się to podczas tego mini cyklu. W ostatnim poradniku, przedstawię dane funkcje tego programu, jak i cały kompletny program z kodem. Pod koniec każdego wpisu, również zostanie umieszczony cały program z kodem, aby można było z łatwością sprawdzić działanie kodu.

Pewnie nasuwa się wam myśl – po co to komu?! Program ten napisałem do testów – w programie który piszę, potrzebuję mieć możliwości takie jak tutaj przedstawiam. A również chciałem pokazać wam w jaki sposób można znaleźć rozwiązanie danego problemu, a i może ktoś będzie chciał utworzyć niestandardową tabelę z różna ilością komórek.

Jest to poradnik skierowany też dla początkujących, więc wszystko postaram się opisywać dokładnie – nawet proste rzeczy, szczególnie w pierwszej części


Na temat dynamicznego tworzenia kontrolek, umieszczałem już wpis, który znajduje się w tym miejscu. Wykorzystamy część kodu (prawie cały) w tej części, dot. powielania danej kontrolki, ale zacznijmy jeszcze wcześniej, czyli od utworzenia projektu i naniesienia odpowiednich komponentów na formatkę.

Tak więc tworzy nowy projekt Aplikacja Windows Form. W nowo utworzonym projekcie na formatce dodajemy 4 textboxy, 4 labele, oraz 3 przyciski. Na chwilę obecną tylko tyle – w tej części to nam będzie tylko potrzebne. Umieszczamy i opisujemy wszystko tak jak jest na przykładowym obrazku (no może rozmieszczenie zróbcie sobie dowolne). Ja od jakiegoś czasu mam zwyczaj, że zmieniam nazwy komponentów w ten sposób aby łatwo było je odnaleźć – czyli zostawiam oznaczenie, które określa jaki to jest komponent, np. Button, i dodaję opis, np. button_zamknij. Nazwy labeli przeważnie zostawiam domyślne, chyba że wykorzystuję je w programie. Pierwszy przycisk który oprogramowuję jest to przycisk zamykający aplikację. Tak więc, klikamy dwa razy na przycisk zamknij i program przeniesie nas do kodu obsługującego zdarzenie od wciśniętego przycisku. Wewnątrz kodu umieszczamy polecenie Close():

private void button_zamknij_Click(object sender, EventArgs e)
{
	Close();
}

Następnie kompilujemy program i uruchamiamy aby sprawdzić czy nie zrobiliśmy jakiegoś błędu już na samym początku. Polecam i zachęcam aby po wpisaniu nawet najkrótszego kawałka kodu kompilować go, a jeżeli jest to uzasadnione uruchamiać nawet aplikację. Uchroni nas to w późniejszym czasie od szukania błędów w większej ilości kodu.

Jeżeli wszystko przebiegło pomyślnie, przechodzimy do utworzenia pierwszych komórek w sposób dynamiczny. Tak jak już wspomniałem, wykorzystamy kod z poprzedniego wpisu – nie będę go tutaj opisywał, jak już jest opisany ;).

Tworzenie tabeli będzie wykonywane dopiero po wciśnięciu przycisku Utwórz – klikamy więc na niego dwa razy aby utworzyć zdarzenie od niego. Uzupełniamy go kodem który umożliwia tworzenie kontrolek dynamicznie. Przed pętlą for umieszczamy jeszcze przepisanie ilości komórek do zmiennej (definicja jest umieszczona na początku klasy Form1, przed inicjalizacją tej formatki.

private void button_utworz_Click(object sender, EventArgs e)
{
	liczba_komorek = Convert.ToInt16(textBox_komorki.Text);
        for (int i = 0 ; i < liczba_komorek ; i++)
       {
            //tworzymy nową kontrolkę - textbox, button, oraz label
            TextBox ntextbox = new TextBox();
            //umieszczanie na ekranie danej kontrolki x, y
            ntextbox.Location = new System.Drawing.Point(12, 110 + 26 * i);
            //określenie rozmiarów kontrolki
            ntextbox.Size = new System.Drawing.Size(100, 20);
            //przypisanie nazwy danej kontrolce
            ntextbox.Name = "d_box_" + i.ToString();
            //konfiguracja danej kontrolki - wyswietlany tekst, ewentualne ustawienia
            //ustawienie zdarzenia 
            //dodanie kontrolek do formularza (do kolekcji - tablicy)
            Controls.Add(ntextbox);
       }
}

Liczba komórek będzie określała warunek zakończenia wykonywania pętli. Kompilujemy i uruchamiamy program. W oknie liczba komórek wpisujemy np. 3. Jeżeli wszystko zrobiliśmy tak jak trzeba pojawią nam się nowe textboxy w jednej kolumnie z przerwą. Aby ją usunąć w linijce z umieszczeniem kontrolki na ekranie zmieniamy wartość która obliczana jest w osi Y. Zmieniamy ją na wysokość tworzonej komórki na 20. Więc ta linijka zmienia się na:

//umieszczanie na ekranie danej kontrolki
ntextbox.Location = new System.Drawing.Point(12, 110 + 20 * i);

Teraz zmodyfikujmy tak kod, aby utworzyć zadaną ilość komórek w zadanych kolumnach. Modyfikacja będzie polegała na dodaniu jeszcze jednej pętli, odczytaniu ilości kolumn, oraz zmodyfikowaniu kodu odpowiedzialnego za umieszczanie kontrolki na ekranie. W pierwszej kolejności tworzymy zmienne dot ilości komórek i wpisujemy do niej wartość z kontrolki ilość komórek. Ciągle pracujemy na kodzie pod przyciskiem ustaw. Gdy już mamy odczytaną ilość kolumn dodajemy następną pętlę for która będzie miała za zadanie kontrolować ilość komórek w danym wierszu. W pętli tej będą dwa warunki – pierwszy będzie dotyczyć właśnie ilości komórek w wierszu, a drugi ilości wszystkich wyświetlonych już komórek. Kolejna zmiana dotyczy położenia danego obiektu – oprócz pozycji x (czyli wypisywanie wierszami), musimy jeszcze dodać zmianę położenia wg osi y (wypisywanie kolumnami). Szerokość komórki ustawiona jest na 100, więc do obecnej pozycji musimy dodać 100 pomnożone razy numer kolumny. Pamiętać należy, aby liczyć od 0, z tego względu, że jak policzymy od 1, to będziemy mieli przesunięta pozycję pierwszej kolumny o szerokość jednego obiektu. Cały kod wygląda następująco:

private void button_utworz_Click(object sender, EventArgs e)
{
	liczba_komorek = Convert.ToInt16(textBox_komorki.Text);
	liczba_kolumn = Convert.ToInt16(textBox_kolumny.Text);
	//pętla główna dla wszystkich komórek
	for (int i = 0, x = 1, y = 0; i < liczba_komorek; x++)
        {
		//pętla tworząca komórki w danym wierszu
		for(y =0; (y < liczba_kolumn) && (i < liczba_komorek) ; y++, i++)
		{
			//tworzymy nową kontrolkę - textbox, button, oraz label
			TextBox ntextbox = new TextBox();
			//umieszczanie na ekranie danej kontrolki
			ntextbox.Location = new System.Drawing.Point(12 + 100*y, 110 + 20 * x);
			//określenie rozmiarów kontrolki
			ntextbox.Size = new System.Drawing.Size(100, 20);
			//przypisanie nazwy danej kontrolce
			ntextbox.Name = "d_box_" + i.ToString();
			//konfiguracja danej kontrolki - wyswietlany tekst, ewentualne ustawienia
			//ustawienie zdarzenia 
			//dodanie kontrolek do formularza (do kolekcji - tablicy)
			Controls.Add(ntextbox);
		}
       }
} 

Po skompilowaniu i uruchomieniu programu wpisujemy w pole ilość komórek, oraz liczba kolumn żądane wartości. Nie wpisanie żadnej liczby, albo wpisanie inne znaku niż cyfr spowoduje wystąpienie błędu i wyłączenie programu. Po wpisaniu liczb i kliknięciu ustaw pojawi się nam tabela z określoną liczbą kolumn i komórek.

Kolejny element naszej tabeli, który może być zmieniany, to szerokość komórki/kolumny. W dotychczasowym programie ustawialiśmy statycznie szerokość komórki, zmienimy to na szerokość definiowaną przez nas. Najpierw tworzymy zmienną typu int o nazwie szerokosc_kolumn i przypisujemy do niej wartość z textboxa szerokość komórki. Przechodzimy do fragmentu kodu odpowiedzialnego za rysowanie tej kontrolki -> System.Drawing.Size. Jako parametry przekazujemy szerokość oraz wysokość elementu. Wartość 100 zmieniamy na utworzoną przed chwilą zmienną. Pamiętać należy jeszcze o metodzie, która określa początkowy punkt rysowania tej kontrolki -> System.Drawing.Point. Przyjmuje ona wartości x i y – wartość x jest uzależniona również od szerokości kolumny. Tak więc również i tutaj zmieniamy wartość 100 na zmienną szerokosc_kolumn. Tak zmodyfikowany kod kompilujemy i uruchamiamy.

private void button_utworz_Click(object sender, EventArgs e)
{
	liczba_komorek = Convert.ToInt16(textBox_komorki.Text);
	liczba_kolumn = Convert.ToInt16(textBox_kolumny.Text);
	szerokosc_kolumn = Convert.ToInt16(textBox_szer_komorki.Text);
	//pętla główna dla wszystkich komórek
	for (int i = 0, x = 1, y = 0; i < liczba_komorek; x++)
       {
		//pętla tworząca komórki w danym wierszu
		for(y =0; (y < liczba_kolumn) && (i < liczba_komorek) ; y++, i++)
		{
			//tworzymy nową kontrolkę - textbox, button, oraz label
			TextBox ntextbox = new TextBox();
			//umieszczanie na ekranie danej kontrolki
			ntextbox.Location = new System.Drawing.Point(12 + szerokosc_kolumn * y, 110 + 20 * x);
			//określenie rozmiarów kontrolki
			ntextbox.Size = new System.Drawing.Size(szerokosc_kolumn, 20);
			//przypisanie nazwy danej kontrolce
			ntextbox.Name = "d_box_" + i.ToString();
			//konfiguracja danej kontrolki - wyswietlany tekst, ewentualne ustawienia
			//ustawienie zdarzenia 
			//dodanie kontrolek do formularza (do kolekcji - tablicy)
			Controls.Add(ntextbox);
		}
 }
}

Jak już mamy utworzone komórki, to przydałoby się je skasować – wyczyścić pole formatki. Naciskamy LPM 2 razy na przycisk Wyczyść, aby utworzyć zdarzenia dla tego przycisku w którym wpisujemy komendę odpowiedzialną za wyczyszczenie utworzonych komórek. Skorzystamy teraz z dokumentacji .Net. Kontrolki tworzone są w klasie Controls, więc otwieramy stronę dokumentacji dot. tej klasy i przeszukujemy ją czy znajdują się tutaj jakieś metody umożliwiające usuwanie kontrolki. Znaleźć można kilka metod – wybierzemy jednak metodę która usuwa kontrolkę według indeksu, czyli remoweAt . Jak można z dokumentacji wyczytać, po usunięciu jednej pozycji, wszystkie indeksy się przesuwają, czyli będziemy przekazywać pozycję pierwszego elementu który utworzyliśmy. Będziemy tak długą ją wykonywać, aż usuniemy wszystkie pozycje, czyli ilość komórek. A jak odczytać pierwszy element kolekcji? Sprawdźmy jeszcze raz co oferuje nam dokumentacja. Na samym początku mamy właściwość Count, która zwraca liczbę elementów w kolekcji – czyli to czego szukamy. Pobierzemy więc tą wartość przed wykonaniem pętli umieszczających nasze kontrolki na formatce. Wartość tą przepiszemy do zmiennej int nr_pierwszy. Po kompilacji i uruchomieniu programu sprawdźmy działanie programu.

private void button_utworz_Click(object sender, EventArgs e)
{
	liczba_komorek = Convert.ToInt16(textBox_komorki.Text);
	liczba_kolumn = Convert.ToInt16(textBox_kolumny.Text);
	szerokosc_kolumn = Convert.ToInt16(textBox_szer_komorki.Text);
	nr_pierwszy = Controls.Count;
	//pętla główna dla wszystkich komórek
	for (int i = 0, x = 1, y = 0; i < liczba_komorek; x++)
        {
		//pętla tworząca komórki w danym wierszu
		for(y =0; (y < liczba_kolumn) && (i < liczba_komorek) ; y++, i++)
		{
			//tworzymy nową kontrolkę - textbox, button, oraz label
			TextBox ntextbox = new TextBox();
			//umieszczanie na ekranie danej kontrolki
			ntextbox.Location = new System.Drawing.Point(12 + szerokosc_kolumn * y, 110 + 20 * x);
			//określenie rozmiarów kontrolki
			ntextbox.Size = new System.Drawing.Size(szerokosc_kolumn, 20);
			//przypisanie nazwy danej kontrolce
			ntextbox.Name = "d_box_" + i.ToString();
			//konfiguracja danej kontrolki - wyswietlany tekst, ewentualne ustawienia
			//ustawienie zdarzenia 
			//dodanie kontrolek do formularza (do kolekcji - tablicy)
			Controls.Add(ntextbox);
		}
       }
} 
private void button_wyczysc_Click(object sender, EventArgs e)
{	
	for (int i= 0; i < liczba_komorek; i++)
	{
		Controls.RemoveAt(nr_pierwszy);
	}
}

W kodzie który już otrzymaliśmy, tworzymy tabelę z określoną ilością komórek i kolumn. Dokonajmy zmiany programu tak, żeby można było utworzyć tabelę podając liczbę wierszy i kolumn.

W pierwszej kolejności utworzymy warunek sprawdzający czy została wpisana ilość komórek do wyświetlenia czy nie. Jeżeli nie to w tedy program będzie brał pod uwagę liczbę wierszy. Warunek ten będzie miał następujący wygląd (znajduje się on w przycisku utwórz):

//sprawdzenie czy tworzymy tabelę od ilości komórek czy wierszy
if (textBox_komorki.Text == "")
{
	liczba_wierszy = Convert.ToInt16(textBox_wiersze.Text);
	liczba_komorek = liczba_kolumn * liczba_wierszy;
	textBox_komorki.Text = liczba_komorek.ToString();
}
else
{
	liczba_komorek = Convert.ToInt16(textBox_komorki.Text);
}

W warunku tym sprawdzamy czy zawartość pola textbox jest pusta – „” oznacza tekst bez żadnego znaku. Uwaga!! – jeżeli w polach tych będzie znajdował się jakiś znak, czy to liczba czy litera, bądź inny znak program będzie myślał, że jest tam cyfra i przejdzie do tworzenie od ilości kolumn. W pewnym momencie wyskoczy błąd z tego powodu, że nie znajdzie żadnej cyfry. Program nie jest zabezpieczony przed takimi sytuacjami.

 Cały program pod przyciskiem utwórz ma teraz następujący wygląd:

private void button_utworz_Click(object sender, EventArgs e)
{
	liczba_kolumn = Convert.ToInt16(textBox_kolumny.Text);
	szerokosc_kolumn = Convert.ToInt16(textBox_szer_komorki.Text);
	//sprawdzenie czy tworzymy tabelę od ilości komórek czy wierszy
	if (textBox_komorki.Text == "")
	{
		liczba_wierszy = Convert.ToInt16(textBox_wiersze.Text);
		liczba_komorek = liczba_kolumn * liczba_wierszy;
		textBox_komorki.Text = liczba_komorek.ToString();
	}
	else
	{
		liczba_komorek = Convert.ToInt16(textBox_komorki.Text);
	}
	nr_pierwszy = Controls.Count;
	//pętla główna dla wszystkich komórek
	for (int i = 0, x = 1, y = 0; i < liczba_komorek; x++)
        {
		//pętla tworząca komórki w danym wierszu
		for(y =0; (y < liczba_kolumn) && (i < liczba_komorek) ; y++, i++)
		{
			//tworzymy nową kontrolkę - textbox, button, oraz label
			TextBox ntextbox = new TextBox();
			//umieszczanie na ekranie danej kontrolki
			ntextbox.Location = new System.Drawing.Point(12 + szerokosc_kolumn * y, 110 + 20 * x);
			//określenie rozmiarów kontrolki
			ntextbox.Size = new System.Drawing.Size(szerokosc_kolumn, 20);
			//przypisanie nazwy danej kontrolce
			ntextbox.Name = "d_box_" + i.ToString();
			//konfiguracja danej kontrolki - wyswietlany tekst, ewentualne ustawienia
			//ustawienie zdarzenia 
			//dodanie kontrolek do formularza (do kolekcji - tablicy)
			Controls.Add(ntextbox);
		}
        }
}

Tak więc utworzyliśmy tabelę z kontrolek textbox ze zmienną szerokością.

Mam nadzieję, że udało mi się opisać w sposób zrozumiały to co się tutaj działa. Jeżeli macie jakieś pytania bądź uwagi do tego co napisałem, to umieszczajcie je w komentarzach. Za niedługo pojawi się dalsza część.

Poniżej znajduje się cały program do testowania:

Pobierz “CS19_N01_tabela_1.zip”

CS19_N01_tabela_1.zip – Pobrano 140 razy – 70,74 KB

Dodaj komentarz

Twój adres e-mail nie zostanie opublikowany. Wymagane pola są oznaczone *