Textovy Editor
//g_key_znak = ASCII kod znaku stlacenej klavesy (wParam spravy WM_CHAR),
//g_point_cursor.x/y = poloha kurzora mysi vramci klientskej oblasti okna
//g_mys_lave_tlacitko = stav laveho tlacidla mysi
//Premenna globalnej struktury TEXTEDITOR typu pointer pod nazvom "editor", obsahuje klucove...
//...polozky (premenne) pre fungovanie tohoto textoveho editora, ktorych hodnoty musia zostat zachovane.
void TextovyEditor(HWND hWnd, HDC* hdcMem, TEXTEDITOR* editor,
int x, int y, int sirka, int vyska,
int medzera_znakova, int medzera_riadkova, int zarovnanie)
{ int f,
dlzka_riadku,
poloha_kurzora,
test,
vyska_riadku = 0,
odstup_textu_x_left = 25,//7, // konstanta odstupu zaciatku textu od zaciatku okienka
odstup_textu_x_right = 25,// 7, // konstanta odstupu konca riadku od konca okienka
odstup_textu_y_up = 5, // konstanta odstupu textu od okraja okienka pri hornom zarovnani.
odstup_textu_y_down = 5, // konstanta odstupu textu od okraja okienka pri dolnom zarovnani.
x_text = x + odstup_textu_x_left, // odstup zaciatku textu od zaciatku okienka
y_text, //Napocitanie dalsieho riadku, ak je znak uz na konci riadku.
y_kurzor, //y poloha kurzora
vypinac_pamati = 1;
//x_text, y_text - fyzicke suradnice zaciatku textu
SIZE rozmery_znaku, rozmery_znaku_test;
////////////////////////////////////////////////////////////////////////////////////
//////////////////////// NAKRESLENIE OKIENKA PRE TEXT ///////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
//VyplnOkienka(*hdcMem, x, y, sirka, vyska);
RamOkienka(*hdcMem, x, y, sirka, vyska);
////////////////////////////////////////////////////////////////////////////////////////////
////////////////// DYNAMICKA ALOKACIA PAMATI PRE TEXTOVE POLE ////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
//Pamat sa realokuje len vtedy, ked nastane zmena v dlzke textu.
//Prvotne alokovanie pamati nastane vdaka tomu, ze pamat pre pole este nieje alokovana...
//...(tj. adresa pola ma este stale hodnotu NULL), coho vyuzijem pre prvotne umele vyvolanie...
//...rozdielu medzi starym a novym poctom znakov. Vdaka tomu sa vstupi potom do podmienky pre alokovanie pamate.
if(editor->ASCII_text_pole == NULL)
editor->pocet_znakov_old = 1;
//Dynamicka alokacia pamati pre textove pole, do ktoreho sa uklada text pisany z klavesnice.
//Fce realloc() realokuje pamat pre pole. Robi to len vtedy, ked sa zmenil pocet znakov v poli.
if(editor->pocet_znakov_old != editor->pocet_znakov)
{ //ziskanie adresy pre pole, a alokacia/realokacia velkosti pamati.
editor->ASCII_text_pole = (int*) realloc(editor->ASCII_text_pole, sizeof(int)*((editor->pocet_znakov)+10));
//vyrovna sa stary a novy pocet znakov, aby do podmienky alokacie sa vstupovalo len pri zmene
editor->pocet_znakov_old = editor->pocet_znakov;
//Testovanie spravnosti funkcie tejto casti programu pomocou
//PlaySound(MAKEINTRESOURCE(IDS_SOUND2), g_hInstance, SND_RESOURCE | SND_ASYNC);
}
//ak alokovanie pamati zlyha (napr pre nedostatok pamati), funkcia realloc vrati hodntu 0, a program skonci.
if(editor->ASCII_text_pole == NULL)
{ KillTimer(hWnd,_TimerSpeed);
MessageBox(hWnd,"Nepodarilo sa prideli pamä pre textový editor.","Zlyhanie!",MB_OK);
SendMessage(hWnd, WM_CLOSE, 0, 0);
}
////////////////////////////////////////////////////////////////////////////////////////////
///////////////////// NASTAVENIE VLASTNOSTIII ZOBRAZOVANEHO TEXTU /////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
//Vynulovanie sirky textoveho pola pred napocitanim aktualnej. (cyklus totiz tadialto prebieha uz cez Windows)
dlzka_riadku = 0;
poloha_kurzora = 0;
//Pozadie textu priehladne.
SetBkMode(*hdcMem, TRANSPARENT);
//Farba textu
SetTextColor(*hdcMem, RGB(0,0,0));
//Znak pre predbezne zistenie vysky aktualneho fontu. (pre zobrazenie kurzora este pred pisanim textu)
_stprintf(editor->znak, "a");
//Do premennej struktury SIZE sa ulozia rozmery aktualne napisaneho znaku s aktualnym fontom.
GetTextExtentPoint32(*hdcMem, editor->znak, lstrlen(editor->znak), &rozmery_znaku);
//zarovnanie textu na hor okienka (podla nastavenia)
if(zarovnanie == 1)
{ y_text = y + odstup_textu_y_up;
y_kurzor = y_text;
}
//vystredenie textu do stredu okienka na vysku (podla nastavenia)
if(zarovnanie == 2)
{ y_text = (y + vyska / 2) - (rozmery_znaku.cy / 2);
y_kurzor = y_text;
}
//zarovnanie textu na dol okienka (podla nastavenia)
if(zarovnanie == 3)
{ y_text = (y + vyska) - (rozmery_znaku.cy + odstup_textu_y_down);
y_kurzor = y_text;
}
////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////// OBSLUHA ZOBRAZENIA NA OBRAZOVKU //////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
//*** precitanie a zobrazenie celeho pola znakov od zaciatku do konca: ***
//Cyklus dookola prechadza cele pole znakov, a stale nanovo prepocitava po jedom znaku...
//...celú jeho sirku. (samozrejme plus zadané medzery)
for(f = 0; f < editor->pocet_znakov; f++)
{
////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////// ZOBRAZENIE TEXTOVEHO POLA NA OBRAZOVKU ///////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
//V cykle nacitava ASCII znaky z pola a prevadza ich na skutocny znak do premennej...
//...jednomiestneho CHAR retazcoveho pola.
_stprintf(editor->znak, "%c", editor->ASCII_text_pole[f]);
//Zisti rozmery aktualneho znaku s aktualnym fontom.
GetTextExtentPoint32(*hdcMem, editor->znak, lstrlen(editor->znak), &rozmery_znaku);
//Zobrazí znak na suradnicu X,Y monitora.
TextOut(*hdcMem, x_text + dlzka_riadku, y_text, editor->znak, lstrlen(editor->znak));
//pripocita sa potrebna dlzka pre buduce zobrazenie dalsieho znaku. (kazdy znak ma totiz...
//...svoju sirku) -Premenna "medzera_znakova", pripocita ku znaku este zadanu medzeru medzi znakmi.
//...Cela dlzka je potom dlzkou celeho retazca v pixeloch. (od zaciatku do konca)
dlzka_riadku = dlzka_riadku + (rozmery_znaku.cx + medzera_znakova);
poloha_kurzora = poloha_kurzora + (rozmery_znaku.cx + medzera_znakova);
//vyska riadku sa urci podla najvacsieho zo znakov v riadku (keby znaky boli rozdielne)
if(rozmery_znaku.cy > vyska_riadku)
vyska_riadku = rozmery_znaku.cy;
////////////////////////////////////////////////////////////////////////////////////////////
//////////// ZOBRAZENIE TEXTOVEHO KURZORA V TEXTE, PO KLIKU MYSOU V TEXTE ////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
//kurzor mysi v oblasti sirky okienka a vo vyske riadku s vyskou konkretneho znaku:
if((g_point_cursor.x >= x)
&& (g_point_cursor.x <= (x+sirka))
&& (g_point_cursor.y >= y_text)
&& (g_point_cursor.y <= (y_text + rozmery_znaku.cy)))
{ //Premenna "dlzka_riadku" sa tu stale po jednom znaku napocitava. (sme totiz v cykle for)
//...Ked presiahne aktualnu x-ovú suradnicu kurzora mysi v riadku,...
//...ulozi sa poradove cislo aktualneho znaku "f" (zastihnuteho v tej chvili)...
//...do pamatovej premennej a vypne sa vypinac, aby sa neukladali dalsie "f". ...
//...To sa deje nepretrzite, kym je kurzor mysi niekde na texte.
//Textovy kurzor sa presuva vlavo/vpravo od polovice znaku, ked je na nom kurzor mysi. (rozmery_znaku.cx/2)
if(vypinac_pamati == 1)
{ if((dlzka_riadku - medzera_znakova - rozmery_znaku.cx/2)
> (g_point_cursor.x - x_text))
{ //ulozi sa aktualne poradove cislo znaku do pamati.
editor->aktualny_znak_pamat = f;
//Premenna urcujuca zobrazenie textoveho kurzora na konci riadku sa prepina medzi 0 a 1...
//...v zavislosti, ci je kurzor mysi na texte riadku, alebo mimo text, tj. za riadkom...
//...v okienku. Ak vsak mimo ten text aj kliknem, premenna zmeni svoju hodnotu na 2. ...
//...Potom sa uz ale na 0 vrati len klikom na text. (nie iba prechodom mysou na text)
if(editor->kurzor_na_konci_riadku == 1)
editor->kurzor_na_konci_riadku = 0;
//vypne sa vypinac, aby sa neukladali do pamati znaku dalsie f, ktore su za polohou kurzora mysi
vypinac_pamati = 0;
}
}
//Po stlaceni laveho tlacidla mysi sa prenesie udaj aktualneho poradoveho cisla znaku...
//...z pamatovej premennej do skutocnej premennej pre aktualny znak, ktora urcuje...
//...polohu textoveho kurzora.
if(g_mys_lave_tlacitko == TLACITKO_DOLE)
{ editor->aktualny_znak = editor->aktualny_znak_pamat;
//pocas stlacenia laveho tlacitka mysi je kurzor trvalo zobrazeny.
g_blikanie_kurzora = 1;
//Premenna urcujuca zobrazenie textoveho kurzora na konci riadku sa prepina medzi 0 a 1...
//...v zavislosti, ci je kurzor mysi na texte riadku, alebo mimo text, tj. za riadkom...
//...v okienku. Ak vsak mimo ten text aj kliknem, premenna zmeni svoju hodnotu na 2. ...
//...Potom sa uz ale na 0 vrati len klikom na text. (nie iba prechodom mysou na text)...
//...To zabezpecuje tento riadok.
editor->kurzor_na_konci_riadku = 0;
}
}
////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////// ROZDELENIE NA RIADKY ////////////////////////////////////////////
//////////// + TEXTOVY KURZOR NA KONCI RIADKU, AK KLIK MYSOU ZA KONIEC RIADKU ///////////////
////////////////////////////////////////////////////////////////////////////////////////////
// Rozdelenie textu na riadky v okienku + kurzor mysi za koncom nejakeho riadku zobrazi...
//...textovy kurzor na konci toho riadku, a pise sa na zaciatok nasledujuceho riadku.
if(dlzka_riadku > (sirka - odstup_textu_x_left
- odstup_textu_x_right
- rozmery_znaku.cx
- medzera_znakova/2))
{ // Ak je kurzor mysi za koncom riadku, aktualne miesto na pisanie sa posunie do pamatovej...
//...premennej o jedno dalej, tj. na zaciatok noveho riadku. Zapne sa premenna pre...
//...zobrazenie textoveho kurzora na konci riadku, kde je kurzor mysi.
if((g_point_cursor.x >= (x_text+dlzka_riadku-medzera_znakova-rozmery_znaku.cx/2))
&& (g_point_cursor.x <= (x+sirka))
&& (g_point_cursor.y >= y_text)
&& (g_point_cursor.y <= (y_text + rozmery_znaku.cy)))
{ editor->aktualny_znak_pamat = f+1;
if(editor->kurzor_na_konci_riadku != 2)
editor->kurzor_na_konci_riadku = 1;
}
//Premenna urcujuca zobrazenie textoveho kurzora na konci riadku sa prepina medzi 0 a 1...
//...v zavislosti, ci je kurzor mysi na texte riadku, alebo mimo text, tj. za riadkom...
//...v okienku. Ak vsak mimo ten text aj kliknem, premenna zmeni svoju hodnotu na 2. ...
//...Potom sa uz ale na 0 vrati len klikom na text. (nie iba prechodom mysou na text)
if((g_mys_lave_tlacitko == TLACITKO_DOLE)&&(editor->kurzor_na_konci_riadku == 1))
{ //Aktivacia zobrazenia kurzora na konci riadku.
editor->kurzor_na_konci_riadku = 2;
//Prenasa sa aj udaj o skutocnej dlzke aktualneho riadku (bez ktoreho by sa kurzor...
//...na konci riadku nezobrazil)
editor->dlzka_riadku = dlzka_riadku;
}
// vynulovanie premennej napocitavania dlzky riadku, ak je znak uz na konci riadku,...
//...a napocital sa dalsi riadok.
dlzka_riadku = 0;
poloha_kurzora = 0;
//Napocitanie dalsieho riadku, ak je znak uz na konci riadku.
y_text += (vyska_riadku + medzera_riadkova);
y_kurzor += (rozmery_znaku.cy + medzera_riadkova);
vyska_riadku = 0;
}
//ooooo
if(g_key_funkc == VK_UP)
{
editor->aktualny_znak -= 6;
}
}
////////////////////////////////////////////////////////////////////////////////////////////
//////////////// ZOBRAZENIE TEXTOVEHO KURZORA NA KONCI TEXTU KLIKOM MYSI ////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
// Ak je kurzor mysi za koncom POSLEDNEHO riadku, aktualne miesto na pisanie...
//...sa presunie na koniec riadku (do pamatovej premennej), cize na koniec celeho textu.
//Kurzor sa tam presunie automaticky (netreba nic zvlast zabezpecovat)
if((g_point_cursor.x >= (x_text + dlzka_riadku - medzera_znakova - rozmery_znaku.cx/2))
&& (g_point_cursor.x <= (x+sirka))
&& (g_point_cursor.y >= y_text)
&& (g_point_cursor.y <= (y_text + rozmery_znaku.cy)))
editor->aktualny_znak_pamat = editor->pocet_znakov;
////////////////////////////////////////////////////////////////////////////////////////////
//////////////////// AKTIVACIA/DEAKTIVACIA OKIENKA KLIKOM MYSI ///////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
//kurzor a moznost pisania sa objavi v danom okienku len po kliknuti nan.
//kurzor mysi sa objavii na okienku po prichode mysou nan
if((g_point_cursor.x >= x) && (g_point_cursor.x <= x+sirka) && (g_point_cursor.y >= y) && (g_point_cursor.y <= (y+vyska)))
{ // kurzor mysi sa zmeni na palicku
SetClassLong(hWnd, GCL_HCURSOR,(LONG_PTR)LoadCursor(g_hInstance, MAKEINTRESOURCE(IDI_CURSOR3)));
// prepinac_kurzora_mysi zmeni po vstupe kurzora do oblasti okienka hodnotu na 2. Je to koli navratu...
//...zobrazenia kurzora spat na sipku, aby to fungovalo vzdy len pri jednom konkretnom okienku.
//Premenna "prepinac_kurzora_mysi" je totiz jedinecna pre kazde okienko, inak by dalsie okienka, ...
//...(keby ich bolo viac za sebou), vracali sustavne kurzor spat na sipku. Palicka by sa...
//...zobrazovala len na poslednom z nich. Vsetky textove editory totiz vyuzivaju spolocnu funkciu "TextovyEditor()".
if(editor->prepinac_kurzora_mysi == 1)
editor->prepinac_kurzora_mysi = 2;
//Stlacene tlacitko mysi sa po vstupe do funkcie vynuluje, inak by zostala visiet jeho
//...hodnota (stav) v premennej. Vynuluje sa vsak az po druhom vstupe, aby sa stihli...
//...deaktivovat dalsie okienka v poradi, pre ktore je pouzita tato funkcia. (preto ta podmienka, a jej prepnutie do 1 az ZA touto podmienkou)
if(editor->vypinac_aktivacie == 1)
g_mys_lave_tlacitko = 0;
//pri kliknuti na okienko sa aktivuje. (zapne sa globalny vypinac)
if(g_mys_lave_tlacitko == TLACITKO_DOLE)
{ //zapne sa vypinac pre aktivovanie okienka.
editor->vypinac_aktivacie = 1;
//Stlaceny znak na klavesnici, sa musi (okrem na konci funkcie) vynulovat aj tu,...
//...inak by sa po kliku mimo okienko a napisani nejakeho znaku na klavesnici, tento...
//...zobrazil po kliku spat na okienko do okienka.
g_key_znak = 0;
g_key_funkc = 0;
}
}
//Kliknutie inde deaktivuje moznost pisania do daneho okienka.
else
{ //kliknutie mimo oblast okienka (napr.aj na ine okienko) deaktivuje okienko. (vypne sa vypinac)
if(g_mys_lave_tlacitko == TLACITKO_DOLE)
editor->vypinac_aktivacie = 0;
//Vrati kurzor mysi na normal (sipku) len raz. (aby neaktivne textove editory...
//...nevracali kurzor aktivneho editora sustavne na sipku)
if(editor->prepinac_kurzora_mysi == 2)
SetClassLong(hWnd, GCL_HCURSOR,(LONG_PTR)LoadCursor(g_hInstance, MAKEINTRESOURCE(IDI_CURSOR)));
//nastavenie premennej kurzora mysi na referencnu hodnotu
editor->prepinac_kurzora_mysi = 1;
}
////////////////////////////////////////////////////////////////////////////////////////////
////////////////////// PISANIE ZNAKOV DO PAMATOVEHO POLA //////////////////////////////////////
/////////////////// + MANIPULACIA V POLI POMOCOU FUNKCNYCH KLAVES ///////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
//tato cast kodu je aktivna len po kliknuti na okienko
if(editor->vypinac_aktivacie == 1)
{ //Ked stlacim znakovu klavesu, tak sa v premennej g_key_znak objavi ASCII kod toho znaku
//...(cize cislo vacsie, ako nula). Len vtedy sa do pola umiestni tento novy znak.
if((g_key_znak > 0))
{ //Pred vlozenim znaku sa posunu (skopiruju) vsetky znaky od aktualnej pozicie smerom...
//...doprava. Kopirovanie sa zacina od konca po aktualnu poziciu. Tym sa uvolni jedno...
//...miesto v poli pre vlozenie toho aktualne napisaneho znaku. Ak je aktualna pozicia...
//...na konci, nic sa nekopiruje, lebo tam nic nieje.
for(f = editor->pocet_znakov; f >= editor->aktualny_znak; f--)
editor->ASCII_text_pole[f+1] = editor->ASCII_text_pole[f];
//vlozenie aktualne napisaneho znaku.
editor->ASCII_text_pole[editor->aktualny_znak] = g_key_znak;
//pripocita 1 do premennej sledovania poctu znakov od zaciatku po aktualnu poziciu pisania.
editor->aktualny_znak++;
//pripocita 1 do premennej sledovania poctu znakov od zaciatku po koniec textoveho retazca.
editor->pocet_znakov++;
//Akonahle nieco napisem, zobrazenie kurzora z konca riadku sa vrati do normalu
editor->kurzor_na_konci_riadku = 0;
g_blikanie_kurzora = 1;
}
//Ked stlacim funkcnu klavesu, tak v premennej g_key_funkc sa objavi interny kod tejto klavesy
//...(cize cislo vacsie, ako nula). Len vtedy sa zacne vyhodnocovat tato klavesa.
if(g_key_funkc > 0)
{ //...ak stlacim Backspace (mazanie znaku vlavo),...
if(g_key_funkc == VK_BACK)
{ //...a kurzor nieje uplne na zaciatku (tzn., ze su pred nim nejake znaky na mazanie),
if(editor->aktualny_znak > 0)
{ //...posunu (skopiruju) sa vsetky znaky od aktualnej pozicie smerom dolava.
//(zacina sa kopirovat od aktualnej pozicie do konca textoveho retazca). ...
//...Tym sa zmaze jeden znak.
for(f = editor->aktualny_znak; f < editor->pocet_znakov; f++)
editor->ASCII_text_pole[f-1] = editor->ASCII_text_pole[f];
//...Posledny znak by vsak zostal dvojmo, preto ho treba samostatne zmazat (nahradit nulou)
editor->ASCII_text_pole[f-1] = 0;
//odpocita 1 z premennej sledovania poctu znakov od zaciatku po aktualnu poziciu pisania.
editor->aktualny_znak--;
//odpocita 1 od premennej sledovania poctu znakov od zaciatku po koniec textoveho retazca.
editor->pocet_znakov--;
}
g_blikanie_kurzora = 1;
}
//mazanie znakov pomocou delete.
if((g_key_funkc == VK_DELETE))
{ //...ak kurzor nieje uplne na konci (tj., za nim su nejake znaky na mazanie),
if(editor->aktualny_znak < editor->pocet_znakov)
{ //...posunu (skopiruju) sa vsetky znaky od aktualnej pozicie do konca, po jednom smerom dolava.
//(zacina sa kopirovat od aktualnej pozicie do konca textoveho retazca). ...
//...Premaze sa tak jeden znak na aktualnej pozicii.
for(f = editor->aktualny_znak; f < editor->pocet_znakov; f++)
editor->ASCII_text_pole[f] = editor->ASCII_text_pole[f+1];
//odpocita 1 od premennej sledovania poctu znakov od zaciatku po koniec textoveho retazca.
editor->pocet_znakov--;
}
}
//...ak uzivatel stlacil sipku vlavo,...
if(g_key_funkc == VK_LEFT)
//...a kurzor nieje uplne na zaciatku (tj. pred nim uz niesu ziadne znaky na preskocenie),
if(editor->aktualny_znak > 0)
//...odpocita sa 1 z premennej sledovania aktualnej pozicie pisania do textoveho pola.
editor->aktualny_znak--;
//...ak uzivatel stlacil sipku vpravo,...
if(g_key_funkc == VK_RIGHT)
//...a kurzor nieje uplne na konci (tj. za nim uz niesu ziadne znaky na preskocenie)
if(editor->aktualny_znak < editor->pocet_znakov)
//...pripocita sa 1 do premennej sledovania aktualnej pozicie pisania do textoveho pola.
editor->aktualny_znak++;
//Akonahle stlacim nejaku funkcnu klavesu, zobrazenie kurzora z konca riadku sa vrati do normalu
editor->kurzor_na_konci_riadku = 0;
}
////////////////////////////////////////////////////////////////////////////////////////////
////////////////// VYPOCITANIE AKTUALNEJ POZICIE TEXTOVEHO KURZORA V TEXTE ///////////////////
////////////////////////////////////////////////////////////////////////////////////////////
/*
//Vynulovanie polohy kurzora, pred napocitanim aktualnej.
//(cyklus totiz tadialto prebieha uz cez Windows)
poloha_kurzora = 0;
//Cyklus for prejde cele pole znakov od zaciatku az po aktualne vybrany znak (vybrany napr. ...
//...pomocou kliknutia mysi v texte), a prepocita po jedom znaku celú tú šírku plus zadané medzery.
for(f = 0; f < editor->aktualny_znak; f++)
{ //nacita ASCII kod znaku z pola. (cyklus napocitava postupne po jednom pole az po...
//...aktualnu poziciu), a prevedie ho na realny znak do premennej jednomiestneho CHAR retazcoveho pola.
_stprintf(editor->znak, "%c", editor->ASCII_text_pole[f]);
//Zisti rozmery aktualneho znaku s aktualnym fontom. (tu potrebujeme hlavne sirku)
GetTextExtentPoint32(*hdcMem, editor->znak, lstrlen(editor->znak), &rozmery_znaku);
//Pripocita sa potrebna sirka. (kazdy znak ma totiz svoju sirku)
//-Premenna "medzera_znakova", pripocita ku nemu este zadanu medzeru medzi znakmi.
//...Cela sirka je potom sirkou useku retazca od zaciatku po aktualne vybrane miesto...
//...v retazci v pixeloch (...po miesto, kde sa ma zobrazit kurzor, a kde sa ma pisat/mazat).
poloha_kurzora = poloha_kurzora + (rozmery_znaku.cx + medzera_znakova);
//fiktivne znovu rozdelenie textu na riadky v okienku, pre vypocet aktualnej...
//...pozicie kurzora na osi y.
if(poloha_kurzora > (sirka - odstup_textu_x_left //okraje
- odstup_textu_x_right //okraje
- rozmery_znaku.cx //posledny znak sa napise este hore,...
- medzera_znakova/2)) //...ale kurzor uz preskoci o riadok dole.
{ poloha_kurzora = 0;
y_kurzor += (rozmery_znaku.cy + medzera_riadkova);
}
}
*/
////////////////////////////////////////////////////////////////////////////////////////////
/////////////////// ZOBRAZENIE TEXTOVEHO KURZORA NA KONCI RIADKU /////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
//Zobrazenie kurzora na konci riadku. (pri kliknuti za jeho koniec)
if(editor->kurzor_na_konci_riadku == 2)
{ poloha_kurzora = editor->dlzka_riadku;
y_kurzor -= (rozmery_znaku.cy + medzera_riadkova);
}
////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////// GRAFIKA TEXTOVEHO KURZORA ///////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
//Kurzor sa zobrazi len vtedy, ked globalna premenna "g_blikanie kurzora" = 1. ...
//...Striedave zapinanie a vypinanie tejto premennej je zariadene vo WM_TIMER pod "_TimerCursor")
//...Alebo ked sa pise na kalvesnici, kurzor neblikaa, ale je stale zobrazeny.
if(g_blikanie_kurzora == 1)
{ MoveToEx(*hdcMem, x_text + poloha_kurzora - medzera_znakova/2, y_kurzor, NULL);
LineTo(*hdcMem, x_text + poloha_kurzora - medzera_znakova/2, y_kurzor + rozmery_znaku.cy);
}
////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////// LADENIE: SLEDOVANIE PREMENNYCH //////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
//LADENIE:
// zobrazenie skutocnej polohy a sirky pisaneho textu v pixeloch.
//...(pre vytvorenie programu reakcie na mys)
_stprintf(g_chtest, "x=%d y=%d aktualny_znak_pamat=%d editor->aktualny_znak=%d", g_point_cursor.x, g_point_cursor.y, editor->aktualny_znak_pamat, editor->aktualny_znak);
TextOut(*hdcMem, 1, 1, g_chtest, lstrlen(g_chtest));
_stprintf(g_chtest, "poloha_kurzora=%d editor->prepinac_kurzora_mysi=%d editor->kurzor_na_konci_riadku=%d", poloha_kurzora, editor->prepinac_kurzora_mysi, editor->kurzor_na_konci_riadku);
TextOut(*hdcMem, 1, 20, g_chtest, lstrlen(g_chtest));
_stprintf(g_chtest, "vyska riadku = %d y_text = %d dlzka_riadku = %d editor->dlzka_riadku = %d editor->pocet_znakov=%d", vyska_riadku, y_text, dlzka_riadku, editor->dlzka_riadku, editor->pocet_znakov);
TextOut(*hdcMem, 1, 40, g_chtest, lstrlen(g_chtest));
//Stlaceny znak na klavesnici, sa po vstupe do funkcie a nacitani, vynuluje...
//...(inak by sa stale pisal stlaceny znak)
g_key_znak = 0;
g_key_funkc = 0;
}
}
