Microsoft MASM32

Microsoft Assembler
OBSAH
cyklus .While ........................................................... 13
OBSAH ........................................................................... 1
.Break....................................................................... 13
Předmluva: ...................................................................... 2
Cyklus .REPEAT..................................................... 14
Úvod:............................................................................... 2
8. Zase něco k Win32 programování............................. 14
1.
1. Něco ke kompileru a linkeru ....................................... 3
2. Nový Příkaz:................................................................ 3
Invoke ........................................................................ 3
Text v okně.................................................... 14
BeginPaint .......................................................... 14
GetClientRect ..................................................... 14
DrawText............................................................ 14
Menu........................................................................ 15
3. Něco k Assembleru – obecně ...................................... 4
9. Něco o makrech v MASM32 .................................... 16
Include ....................................................................... 4
Teorie k programu ................................................... 16
RGB_value ......................................................... 16
SetTextColor ...................................................... 16
SetBkColor ......................................................... 16
CreateFont .......................................................... 17
SetObject ............................................................ 17
TextOut............................................................... 17
Základní instrukce...................................................... 4
4. Základní informace o Win32 programování:............... 5
Kostra programu v Masm32....................................... 5
První program - varování ........................................... 6
Příklad 6................................................................... 17
5. Podmínky – příkazy .if, .elseif, .else, .endif ............. 7
.if................................................................................ 7
10.Ovládací prvky......................................................... 17
.endif .......................................................................... 7
Trocha teorie – zase – Tlačítka ................................ 17
.elseif.......................................................................... 7
Trocha teorie – zase – Combobox............................ 19
.else ............................................................................ 7
Trocha teorie – zase – Edit....................................... 19
Příklad 2 „neodbytné“ varování ................................ 8
Scroll bar ................................................................. 19
6. Další informace o Win32 programování – Okno:........ 8
11.Teorie a Teorie ......................................................... 19
GetModuleHandle................................................. 8
GetCommandLine................................................. 8
WinMain............................................................... 9
Makro – LOCAL .................................................. 9
WNDCLASSEX ................................................... 9
LoadIcon............................................................... 9
LoadCursor ........................................................... 9
RegisterClassEx.................................................. 10
CreateWindowEx................................................ 10
ShowWindow ..................................................... 10
UpdateWindow................................................... 10
GetMessage ........................................................ 10
TranslateMessage ............................................... 10
DispatchMessage ................................................ 10
CreateProcess ..................................................... 20
GetStartupInfo .................................................... 20
WinExec ............................................................. 20
SetCurrentDirectory ........................................... 20
Jak z programu zaškrtnout checkbox?, Jak
zkontrolovat stav checkboxu?............................. 20
GetCurrentDirectory........................................... 20
CreateFile ........................................................... 20
ReadFile ............................................................. 21
GetOpenFileName.............................................. 21
GlobalAlloc ........................................................ 22
GlobalLock......................................................... 22
GlobalUnlock ..................................................... 22
GlobalFree.......................................................... 22
MoveWindow..................................................... 22
GetFileSize ......................................................... 23
Obecně k msg........................................................... 11
WndProc (Window Procedure)........................... 11
PostQuitMessage ................................................ 11
DefWindowProc ................................................. 12
Doslov........................................................................... 23
Příklad č.3 - Okno .................................................... 12
Doslov k verzi 1.1 ......................................................... 23
7. Zase Masm ................................................................ 13
1
Předmluva:
Tuto knížku jsem sepsal když jsem se učil MASM32, tak že by zde všechno mělo být
popsáno srozumitelně, a zároveň poměrně amatérsky, ani to by nemuselo být na škodu.
Pokouším se v této knize vysvětlit programování alespoň aby jste byli schopní
naprogramovat něco – nějakou aplikaci, tak že zde vysvětlím vše co budu do programů psát a
co by se vám mohlo hodit. Koho to zaujme může pokračovat v učení se sám, časem třeba
napíši i nějaké pokračování pro pokročilé (asi to chvíli potrvá). Jo to jsem nezdůraznil – Tato
knížka je věnována začátečníkům s MASM a vůbec s assemblerem, ale kapitoly, které jsou
pro začátečníky s Assemblerem, popíši (že jsou pro ně).
Inspiroval jsem se vlastními poznáními a také helpem k MASM další zdroj a ten je asi
nejdůležitější je popis funkcí Win32 help od Borlandu je to jakoby nápověda, ale má to asi
11Mb je tam popsaný všechno (sežeňte si to na mojí stránce by měl být odkaz jinak to najdete
někde na stránkách Borlandu – někde u delfi), já nebudu vše z toho vypisovat, protože to bych
to psal několik let a asi by mě to i trochu nudilo – no trochu asi ne hodně by to nudilo, protože
v tý nápovědě je asi milión stránek, ještě další zdroj, i když ten jsem používal jen částečně mi
byly turtionaly k MASM32. Jo a poslední věc, která se móóc hodí – něco jako ten help od
borlandu – Microsoft Platform SDK – alespoň ty helpy z toho (má to drobnou nevýhodu, je to
moc dat..) ve výsledku je to to samý, co ten help od Borlandu, akorát aktualizovanější a
obsáhlejší. To by asi k předmluvě stačilo – jo skoro bych zapomněl na tu adresu mojí stránky
(sice nepředpokládám, že by jste se k tomuto materiálu dostali jinak než z mojí stránky, ale
pro jistotu) – je to home.worldonline.cz/~cz411646 nebo http://jvr.chytrak.cz/.
Jo ještě k tomu, že jde o produkt od společnosti Microsoft – no je to dalo by se říct
jeden z nejlepších produktů co Microsoft vyslal do oběhu a navíc je zadarmo což i mě udivuje
celého toho projektu MASM se chytlo pár programátorů c celého světa a celkem z toho dali
do hromady dobrý vývojový prostředí. Zahrnující editor tvořič základních projektů a další
věci. To je vše – k předmluvě samozřejmě.
Dodatek:
Toto píši, když už jsem se něco naučil, musím tu opravit jisté chyby co
se tu objevily a něco doplnit.
Dodatek2:
Druhá revize, teď už naprogramuju všechno a snad všemu i rozumim
tak opravim poslední chyby.
Úvod:
V MASM se dá programovat i pod Windows. MASM není až tak přímo nižší
programovací jazyk, je mírně podobné C – využívají se zde i tzv. high-syntaxové příkazy, ale
na rozdíl od c je menší výsledný strojový kód. Kdyby jste programovali pod Windows v C
určitě by jste psali velice podobné věci (to je také důvod, proč lze k MASM využívat HELP
určený pro C nebo Delfi). Složitostí se dá vlastně MASM srovnat s C od Borlandu.
Jo k organizaci mojí knihy – Stylů nadpisu jste si asi všichni všimli teď ještě ke kódu
(zdrojovému) ten se zapisuje Asi takhle
A popisy budou mít modrou barvu aby se ti lépe odlišilo Asi takovouhle
Celá kniha je rozčleněna do takových větších kapitol, které jsou označeny pořadovými
čísly a podkapitol ty jsou bez čísel.
To by asi stačilo k organizaci knihy, vrhneme se do práce.
2
1. Něco ke kompileru a linkeru
Asi než začneme pracovat a programovat měli bychom si povědět něco o programu –
jak to funguje. Takže nejdříve k verzím – já mám momentálně verzi 6.15 – rok 2000. Předtím
byly – jak už z čísla verze vyplývá i jiné a asi budou i další. Budu se tady zabývat typy
souborů a jejich zpracováním. Tak že co nás všecko může potkat?.
• Asm – tato přípona se používá pro hlavní soubor kde je zdrojový kód, ten se
pak převede (zkompiluje) programem ml.exe do objektového souboru obj.
• Rc – Template soubor (resource file) toto je takový soubor pro binární data
používá se pro tvorbu dialogových oken, pro vkládání obrázků do programů
atd. Tento soubor se také kompiluje do obj, ale takovou drobnou oklikou přes
soubor res – kompiluje se programem rc.exe nebo rc32.exe (starší) – také se dá
kompilovat programem brc32.exe to je bez té okliky přes res soubor.
• Res – tato přípona se používá pro soubor, který je binární převod rc souboru –
v tomto souboru se zdrojový kód převede na binární a vloží se tam obrázky
ikony atd. tento soubor se pomocí programu cvtres.exe kompiluje na obj.
• Obj – (Object file) toto je takový mezi stupeň kompilace v tomto souboru je už
částečně přeložený zdrojová kód tyto soubory se linkují pomocí programu
link.exe na strojový kód – exe soubor. Existence souborů obj se využívá hlavně
pro linkování asm a rc souborů, také se používá pro linkování více souborů
asm při odděleném překladu, aby jste nemuseli stále kompilovat velký soubor
(i když to většinou není v Assembleru tak velký problém), tak se udělá více
malých a kompiluje se jen ten co potřebujete.
• Inc – tato přípona se používá pro vkládané soubory. Tyto se využívají hlavně
pokud máte určitý text, který chcete použít ve více souborech příklad
Windows.inc.
2. Nový Příkaz:
Takový nový příkaz – ohromná výhoda oproti TASM.
Invoke
Příkaz je poměrně často používaný - Jedná se o takové makro(multi-push + call). Jde o
zjednodušení práce a to docela slušné. Udělá více instrukcí najednou a zapisuje se následovně.
invoke FunctionName, par1, par2, par3, par4
;provede
push par4
push par3
push par2
push par1
call FunctionName
Toto je značné zjednodušení, které vám usnadní mnoho práce.
Ještě bych se zmínil o nové – nevím jak často využívané věci, ale myslím že jinde se
nevyužívá – addr jedná se o jakousi adresu – nejčastěji nějakého nadpisu. Addr je v invoke
takovej offset – často využívaný pro vnitřní proměnné, lze využít i pro globání. Používá se
vždy, když po vás v invoke chtějí nějakou adresu, ale pokud se jedná o globální proměnný dá
se použít i offset, pokud se jedná o lokální – makro LOCAL musíte použít addr (offset by to
nesežralo).
3
3. Něco k Assembleru – obecně
Tady bych popsal něco co by pro začátek měli všichni začátečníci s MASM.
Include
Tento příkaz znají moc dobře všichni programátoři v C - používá se i v Assembleru.
Vloží to soubor ke kterému jste zadali cestu do zdrojového kódu.
include \masm32\include\windows.inc
vloží soubor Windows.inc do kódu programu – můžete pracovat se všemi
proměnnými které jsou v tomto souboru nadefinovány.
Dále ještě existuje INCLUDELIB jde o vložení knihoven, jinak je to stejné. Oproti C
to kde se knihovny vkládají z příkazové řádky je to fakt nářez… Už sem viděl dost lidí,
kterjem se to líbí tak, že to chtěj i do C… ☺
(pro začátečníky s Assemblerem)
Základní instrukce
Mov – toto je instrukce pro procesor – ne příkaz překladače jako ta předchozí tato
instrukce je vlastně takové rovná se jde o to že napíšete
mov neznámá,7
a vaše neznámá má hodnotu 7, ale je to pouze takhle první číslo může být pouze
neznámá, ukazatel na paměť či registr, nesmí to být konstanta – musí jí jít změnit hodnota – to
tedy znamená, že dát jako první argument třeba 7 je blbost.
Registr je taková neznámá, ale má tu výhodu, že je v procesoru, tak že k ní má procesor
nepoměrně rychlejší přístup než k proměnné v paměti, ale těchto proměnných je poměrně
málo a některé mají specifické využití, tak že dalo by se říci, že se využívají hodně tak akorát
čtyři a to EAX, EBX, ECX, EDX – jedná se o 32-bitové registry – jsou rozděleny na dva 16-ti
bitové a jeden z těchto 16-ti bitových je rozdělen na 2 8-bitové registry, tak že k názvům
registr EAX je rozdělen na E – dalo by se říct že tento registr vlastně neexistuje – není do něj
přístup přímo můžete do něj něco zapsat, když zapisujete něco přímo do EAX, nebo něco
napsat do druhého 16-ti bitového registru AX, do kterého už je přístup, a posunout to. Registr
ax je rozdělen na AL- low a AH – high do těchto máte přístup přímo. Poznámka: napleťte si
tyto registry procesoru s registry Windows – to je něco úplně jiného – tady je schématický
nákres registru EAX
EAX (AX+horních 16bitů) – obsahuje tedy AL,AH potžmo AX
a dalších 16 bitů, které nelze jinak než přes EAX adresovat.
MASM32 pracuje hlavně s EAX, proípadně s AL, tedy jen
s prvními osmi bity EAX.
AX (AH + AL) – 16bit
AH (8 Bit)
AL (8bit
No padlo nám tu slovo bit - jedná se o takovou základní jednotku informace – hodnoty
má 1 a 0 – jde o to jestli projde proud nebo neprojde. Vyšší jednotky jsou byte osm bitů.
word 16 bytů a dword 32 bitů a ještě existuje qword 64 bitů, ale to se moc na 32-bitových
počítačích nepoužívá a 64-bitových počítačů zatím moc neexistuje.
definování dat – není to nic složitého pouze napíšete název té proměnné, pak udáte typ
– db bytová, dw 2-bytová a dd 4 bytová – pak napíšete velikost – asi takhle
X
db
0
Řetězec se definuje podobně – asi takhle
Retezec db
„RRRRRAAASSS“
4
push – jde o příkaz,který uloží hodnotu – 16 nebo 32 bitů do zásobníku – určené místo
paměti RAM.
K call – jde o instrukci, která zavolá určitou proceduru (funkci), která se pak vykonává.
INC –je to instrukce, kterou zvýšíte argument o 1.
DEC- je to instrukce, kterou snížíte argument o 1.
ADD – sčítání 1. argument + 2. argument.
SUB – odčítání
SHR – posun bitů do prava.
SHL - posun bitů do leva.
No pro zbytek informací si asi stáhněte z mojí stránky nějakou učebnici Assembleru –
jsou tam dvě a dá se to z nich pochopit. I když ještě tady v tý učebnici něco co je také o
assembleru, ale k těmto tématům se už asi vracet nebudu.
Skoro bych zapomněl každý program je rozdělen do několika částí (segmentů) – data
segment a code segment. Data segment obsahuje data – proměnné a jejich hodnoty a má
stabilní velikost. Definuje se .data. Code segment – zde je kód programu, který tvoříte v Code
segmentu je uvozen začátek vašeho programování labelem start a končí nápisem end start.
Definuje se .code. A to už jsme se dostali k dalšímu vysvětlování – co je to label (návěští) –
jedná se o takový úchytný bod programu, kam se různě skáče atd. to asi ještě vysvětlím, jestli
to budu používat. Label se definuje tak že napíšete název a za ním dvojtečku – label1:. A ještě
se zmíním o offsetu – jedná se pointer na první znak v řetězci (vlastně je to adresa v paměti
RAM) –
mov eax,offset retezec
Tímto příkazem máte v eax ukazatel na 1. byte (word, dword) v řetězci.
Moc toho tu není a tak musim začátečníky odkázat na nějakou učebnici asembleru nebo
na ATHelp.
4. Základní informace o Win32 programování:
Tak že teď znáte velice často používané instrukce se kterými tedy můžete i pracovat tak
že si uděláme nějaký ten prográmek, ale před tím bychom si mohli ještě povědět, jak na to.
Každé okno ve Windows má svojí hlavičku (rukojeť) a parametry. Rukojeť je 32-bitové číslo,
které je jedinečné a pomocí kterého systém zjistí o jaké okno jde. Další parametry jsou na
ovládání okna. Každá aplikace udělá jen jedno hlavní okno, další jsou podřízená.
K tvoření „normálního“ okna se používají tyto příkazy CreateWindow nebo
CreateWindowEx o rozdílu se dočtete v Win32 Programmer´s Reference – dále jen
Win32Help. K tvoření neoken (dialogů a varování) se používá DialogBox, CreateDialog,
CreateDlgParam a MessageBox. Aplikace nemusí mít vlastní okno, může fungovat třeba
z příkazového řádku, nebo může mít ikonku v liště, případně to může být service.
Kostra programu v Masm32
Základní hlavička „každého“ souboru je
.386
specifikace procesoru. Asi by to sežralo i 486 možná i 586 a
dokonce i .286, jde o to jaké instrukce se budou používat –
Snad nemusím zdůrazňovat, že aplikace 586 na 486 nepůjde.
.model flat, stdcall
Tohle je jenom model no berte to tak jak to je – je to model
pro 32-bitovou aplikaci.
option casemap:none
Tak tohle je nastavení sensitivity, tímhle ji vypnete, tak že
ASM je to samé co aSm atd.
include \masm32\include\windows.inc
5
Vložení souboru – Windows.inc vkládáte vždycky, pokud
programujete windowsovskou aplikaci, jsou tam nadefinované
konstanty struktury apod.
.data
Tady jsou data - inicializovaná.
.data?
Tady jsou data – neinicializovaná – nejsou v programu jsou v
paměti.
.const
Sem můžete napsat nějaké ty konstanty, případně data, která
nechcete aby se měnily, třeba řetězce, zejistíte tím, že je
nepřemažete.
.code
start:
Tady je kód programu.
end start
A konec.
První program - varování
Tento program vyrobí box pro varování, kde v nadpisu napíše důležité sdělení a v textu napíše
„Win32 Assembler je dost dobrej!“ Box pro varování jde odklapnout jen nějakým tlačítek co
je uvnitř. Křížek v rohu, kterým jde každá aplikace je šedivý, tak že odklapnout přes křížek to
nejde. MessageBox, jak to Windows nazývají se zjeví vprostřed obrazovky – začínáme
s tímto oknem, protože je úplně nejjednodušší.
Tady se píše název programu a informace o autorovi napíšu tady jen název.
;####################################################
;Příklad 1.
;####################################################
386
model flat, stdcall
option casemap:none
Tohle je hlavička, bez který se asi neobejdete
include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
include \masm32\include\user32.inc
Tyhle .inc se vkládají asi do každýho programu, jsou v nich definice
procedur např. toho MessageBoxu.
includelib \masm32\lib\user32.lib
includelib \masm32\lib\kernel32.lib
Ke všem .inc kromě vašich a Windows.inc musíte použít knihovny – mají
příponu .lib a jsou v adresáři LIB a jsou v nich nadefinovány kódy těch
funkcí zase třeba ten MessageBox
.data
MsgPopis
db "Důležité sdělení",0
MsgText
db "Win32 Assembler je dost dobrej!",0
To je definování všech těch nápisů, jde to i jinak, ale o tom až dále.
.code
start:
invoke MessageBox,NULL,addr MsgText,addr MsgPopis,MB_OK
Procedura MessageBox má 4 parametry 1. Je parametr ovládající aplikace Tzv.
hlavička aplikace v našem případě nula, protože jinak není box vidět jinak
se používá hlavička aplikace, která to okno ovládá. 2. je addr nadpisu
(něco jako offset nadpisu). 3. addr Textu 4. je styl tlačítek může tam být
jako zde MB_OK to znamená že je tam jen tlačítko OK jinak ta může být
z těch důležitějších používaných i MB_OKCANCEL, MB_ABORTRETRYIGNORE,
MB_YESNOCANCEL, MB_YESNO, MB_RETRYCANCEL , MB_ICONHAND, MB_ICONQUESTION, MB_HELP
6
….. Je jich docela mnoho a jsou v Windows.inc pěkně pod sebou najděte si
MB_OK a oni jsou v okolí. A nebo o tom něco najdete i v Win32Help.
invoke ExitProcess,NULL
Tenhle příkaz ukončí vaší aplikaci měl by tam být pro správnou funkci, ale
tady funguje to i bez něj, ale pro pořádek ho tam raději vždy dejte.
end start
Tohle by snad stačilo k prvnímu příkladu, už umíte stvořit varování.
5. Podmínky – příkazy .if, .elseif, .else, .endif
U všech těchto příkazů – s tečkou se jedná o tzv. příkazy vysoké syntaxe – jsou to
příkazy pro překladač, který je předělá na instrukce, takovéto příkazy se používají ve vyšších
programovacích jazycích, proto tvrdím, že MASM není až tak nízký programovací jazyk.
Avšak se to skutečný gól MASM ušetří spoustu práce a času při programování, nikdo vás
však nenutí je používat.
.if
Obdoba if v C nebo Pascalu. Užití –
.if bx==0
Tady napíšete nějakej kód třeba.
invoke FunctionName, par1, par2, par3, par4
.endif
„přibližně“ provede:
dal:
konec:
cmp bx,cislo
jz dal
jmp konec
invoke FunctionName, par1, par2, par3, par4
No prostě pokud není bx rovno nule tak se nic neděje a pokud je tak se děje to co jste
napsali, že se má dít.
.endif
.Endif je příkaz, kterým se ukončuje cyklus, který započnete příkazem .if.
Z předchozího příkladu snad jeho užití vyplývá.
.elseif
Tento příkaz se píše mezi .if a .endif. se píše za .if jako další možnost, tam se už nepíše
.if, protože tím by jste otevírali další „cyklus“, ale je to jakoby další if (jestliže) v tom cyklu.
Těchto .elseif můžete do „cyklu“ dát nekonečné množství.
.else
Tento příkaz se také píše mezi .if a .endif jak už z jeho anglického překladu vyplývá
jedná se o takové jinak – pokud není splněna ani jedna podmínka tak udělá to co je pod nim.
Používá se samozřejmě jen jedno – více by jich stejně bylo na ….
.if var == 1
kód 1 (bude vykonán pokud se var bude rovnat jedné)
.elseif var == 2
kód 2 (bude vykonán pokud se var bude rovnat dvěma)
.else
kód 3 (bude vykonán pokud nebude vykonán ani jeden
předchozí – var se nerovná ani 1 ani 2.
.endif
7
Příklad 2 „neodbytné“ varování
Ten to prográmek udělá skoro to samé co ten první, ale místo tlačítka OK se objeví
hned dvě Ano a Ne. Pokud sdělení odsouhlasíte, tak se program ukončí, pokud však
program sdělení neodsouhlasíte tím, že zmáčknete Ne, tak vypíše další sdělení.
.386
.model flat, stdcall
option casemap:none
include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
include \masm32\include\user32.inc
includelib \masm32\lib\user32.lib
includelib \masm32\lib\kernel32.lib
.data
Popis
db "Důležité sdělení",0
Text
db "Win32 Assembler je dost dobrej, že jo",0
Popis1
db "Ty ptáku",0
Text1
db "Ty mi nevěříš!",0
Dat nám trochu přibylo.
.code
start:
invoke MessageBox,0,addr Text, addr Popis,MB_YESNO
První box
.if eax==IDNO
Hodnota zmáčknutého tlačítka se mi vrací v EAX – v čem
taky jiném v 32 bitovém Assembleru. Porovnám tedy hodnotu která
se mi vrací z Boxu s hodnotou Ne (IDNO) a pokud se to rovná tak
se zobrazí další box.
invoke MessageBox,0,addr Text1, addr Popis1,MB_OK
Druhý box
.endif
Musím ukončit cyklus
invoke ExitProcess,NULL
Konec
end start
Možná jste si všimli drobné chyby, a to, že v hlavičce jsem použil místo NULL 0, je to chyba
i když v tomto případě není nijak fatální, protože v MASM32 je zatím NULL rovno 0 tedy je
to to samé, ale raději rozlišujte NULL a nula.
6. Další informace o Win32 programování – Okno:
Tak že už umíme někoho varovat – to je celkem důležitý, ale ještě nám nejde udělat
obyčejné okno – to bych řek, že je asi to nejdůležitější a tak si o tom něco povíme.
K hlavním příkazům pro tvorbu okna patří:
GetModuleHandle
Tato funkce má jedem parametr – adresu jména modulu pro který chceme rukojeť, vrací
rukojeť požadavku pro specifikovaný modul. Jestliže zadáte adresu. Musím tady ale napsat
jednu velice důležitou věc – když zadáte parametr NULL tak vám to vrátí potřebnou rukojeť
pro stvoření vašeho okna. Nebo spíše rukojeť instance – no prostě hInstance.
Jo ještě – tu rukojeť to vrací v EAX. A jedná se vlastně o rukojeť požadavku – v našem
případě stvoření okna. Vono vůbec jakmile něco procedura prací vrací to v eax.
GetCommandLine
8
Tahle funkce, jak už vyplývá z názvu vrací hodnotu ukazatele na příkazový řádek pro
probíhající proces. Hodnota se zase vrací v EAX. Na co je to ale potřeba? No občas se to hodí
(v téhle naší proceduře zrovna ne ale už to nebudu vyndávat.
WinMain
Tohle je taková volná funkce, standardně má 4 parametry, ale vůbec nemusí, jedná se
prostě o vaší hlavní proceduru – ta většinou stvoří okno. Této proceduře se lze vyhnout a
ušetřit tak zbytečné vilání.
Makro – LOCAL
Toto makro definuje lokální proměnný, který se pak dají užít jen v proceduře ve které
jsou nadefinované. Toto není až zase tak nutný příkaz proměnné si můžete nadefinovat i
globálně, ale v případě, kdy užíváte proměnnou pouze v jedné funkci se hodí toto makro
využít, protože to ušetří místo, ale proměnný jsou lokální, tak že vám nevydrží do dalšího
volání funkce.
WNDCLASSEX
Jde o strukturu, která se definuje pro příkaz RegisterClassEx. V této struktuře je dvanáct
proměnných a to:
UINT - cbSize
tady se definuje kolik bytů bude mít struktura – nejčastěji
sizeof WINDOWCLASSEX tím docílíte, že bude mít standardní velikost.
UINT - style
styl struktury – jejich mnoho ve Win32Helpu, ale já zde
uvedu jen ty co budu používat.
WNDPROC - lpfnWndProc zde je ADDR procedury, která ovládá okno.
Int - cbClsExtra
nějaký extra byty pro strukturu – implicitně je tam nula.
Int - cbWndExtra
Další extra byty – to necháme pokročilým.
HANDLE - hInstance
Rukojeť požadavku na tvorbu okna.
HICON -hIcon
Rukojeť ikony okna – dá se tam dát i nula, ale my ji
nějak vyčarujem. – je na to takový příkaz.
HCURSOR - hCursor
Rukojeť kurzoru co se má používat tu taky
vyčarujem a samozřejmě, že tam může být taky nula.
HBRUSH - hbrBackground Identifer třídy štětce pozadí – no prostě barva pozadí. –
je tam mnoho možností a kouzel – nebudu uvádět je to ve Win32Helpu.
LPCTSTR - lpszMenuName specifikace názvu menu ve zdroji. – Až později.
LPCTSTR - lpszClassName Název třídy okna. Až později, i když něco tam musíme
napsat.
HICON - hIconSm
Rukojeť malé ikony – asi ikony v levém horním rohu
okna.
LoadIcon
A už jsme u toho jak se dá vyčarovat taková rukojeť ikony. Dělá se to tímto příkazem.
Příkaz má dva parametry – hlavičku aplikace a jméno ikony – pointer. Jako druhý příkaz
můžeme použít více příkazů – viz Win32Help, ale já zde uvedu jen IDI_APPLICATION Normální ikona. Jo a v EAX se mi vrátí rukojeť té ikony.
LoadCursor
A zase čarujme – teď rukojeť kurzoru. Tato funkce má dva parametry – rukojeť a
pointer – Za pointer můžeme dosadit zase více, ale to v Win32Helpu jinak standard je
IDC_ARROW – standardní šipka.
9
RegisterClassEx
Tato funkce nadefinovanou Class zaregistruje. Má jeden parametr a to je název Classu
samozřejmě ADDR Classu.Registrace Class struktury je nutná pro tvorbu okna.
CreateWindowEx
Tato funkce stvoří okno má dost parametrů tak vám je tady pěkně popíšu
DWORD dwExStyle,
Rozšířený styl okna viz Win32Help
LPCTSTR lpClassName, Adresa názvu Classu
LPCTSTR lpWindowName, Adresa názvu okna
DWORD dwStyle,
Styl
okna
viz
Win32Help
standard
je
WS_OVERLAPPEDWINDOW
int x,
Horizontální pozice okna
int y,
Vertikální pozice okna
int nWidth,
Šířka okna
int nHeight,
Výška okna u velikostí lze všude použít čísla, nebo
předdefinované CW_USEDEFAULT.
HWND hWndParent,
Rukojeť okna, které toto okno vlastní nejednodušeji
NULL
HMENU hMenu,
Rukojeť menu
HINSTANCE hInstance,
Rukojeť tvorby okna
LPVOID lpParam,
Adresa dat ke tvoření okna
Vráti v eax hwnd rukojeť nového okna.
ShowWindow
No to je k tomu, aby když už jsme to okno stvořili jsme ho taky viděli. Má to dva
parametry – rukojeť okna hwnd a jak se má okno ukázat - SW_SHOWNORMAL normálně
více v Win32Helpu. Vrací jen True nebo False. Zdařilo se nebo ne.
UpdateWindow
Aktualizuje okno – no specielně client areu (kde operuje uživatel) – Chce to rukojeť
okna – hwnd. A vrací True, False.
Ještě tu mám takový zbylý příkazy. – jsou na řízení zprávového systému, no prostě aby
se zpráva dostala do WndProc.
GetMessage
funkce dostává zpět varovné zprávy ze zprávové fronty a uloží je do specifikované
struktury. Parametry jsou čtyři První adresa struktury se zprávami. Druhá rukojeť okna Třetí
je první zpráva, čtvrtý je poslední zpráva.
TranslateMessage
Tato funkce přeloží varování tzv. virtuální klíč na varování v písmenech – prostě psaný
varování. Potřebuje k tomu znát jen adresu struktury se zprávami.
DispatchMessage
Tahle procedura pošle varování zpět oknu. Má zase pouze jeden parametr a to je adresa
struktury se zprávami.
Teď se asi ptáte co to je za blbosti tyhle zprávy vono si je to veme, přeloží je to a zase je
to pošle zpátky – je to potřeba pro funkci hlavní procedury okna – toto totiž posílá a překládá
zprávy co se s oknem momentálně děje. Asi to pochopíte během příkladu.
10
Obecně k msg
Celej Windows je založen na procedurách. Prostě a jednoduše se všude volaj procedury pouze
se mění parametry těchto procedur. Procedura okna se díky smyčce volá pořád dokola, dokud
se nepošle PostQuitMessage a tak se stále jakmile se něco semele – uživatel něco udělá (třeba
pohne myší) zavolá procedura okna se zprávou WM_MOUSEMOVE, a v parametrech jsou
souřadnice.
Msg je vlastně struktura a patří tam rukojeť okna pro které ty „zprávy“ jsou, pak je
zpráva – těch je neuvěřitelné množství – níže jich pár popíší, ale všechny to opravdu v mých
silách není. Dále je tam wParam – 1.parametr – takové pomocné hodnoty , lParam 2.parametr
podobné jako wParam pak je time – jede jen o čas, kdy byla zpráva poslána a pt pozice
kurzoru, v čase kdy byla poslána zpráva. Opravdu nedůležitější tedy je ta zpráva, která byla
poslána a ty dva parametry, samozřejmě je také důležité jakému oknu byla ta zpráva poslána
ostatní dva parametry zajišťuje systém.
Druhy zpráv – nejčastěji používané a pouze pro okno.
WM_CLOSE – jde vlastně o zprávu, která zavírá okno, když systém, dostane
WM_CLOSE tak pokud to nenadefinujete jinak tak pošle hned další zprávu – jinak tato
zpráva se pošle oknu tím, že zmáčknete křížek v rohu.
WM_DESTROY – tato zpráva opravdu zničí okno. – ani jedna z těchto zpráv nemá nic
ve wParam ani v lParam.
WM_COMMAND – tato zpráva má hned tři parametry, i když ve dvou – 1. je kód,
který udává jestli byl příkaz udán z menu či z nějakého jiného okna, nebo z akcelerační
klávesy – to vás – pokud jste začátečníci nemusí moc tíži, protože pčítám, že akcelrační
klávesy nebudete používat. Další je identifikační číslo toho „tlačítka“, kterým byl příkaz
vyslán a 3. je v lParam – pokud je vyslán tento příkaz nějakým kontrolním „tlačítkem – není
to příkaz z menu, tak se zde vrací rukojeť ovládacího prvku.
WM_CREATE . tento příkaz je vyslán, když je tvořeno okno, má pouze jednu hodnotu
a to v lParam je to ukazatel na data k tvoření.
WM_KEYUP – toto je „zpráva“, která se volá, když je zmáčknuta klávesa – v wParam
se vrací virtuální kód klávesy a v lParam se vracejí data klávesy.
WM_MOVE – toto je zpráva, která se volá, když je okno přesunuto, v lParam se vrací
xy v AX se vrací vertikální pozice – x a v „E“ – high-word se vrací horizontální pozice – y.
WM_PAINT – tato zpráva se vrací, když je dán příkaz UpdateWindow nebo
RepaintWindow (v Win32Helpuu mumlají něco i o DispatchMessage, ale to už je nějaký
složitější), nemá žádné parametry
To by asi stačilo – tato parametry jsou poměrně důležité v následující proceduře.
WndProc (Window Procedure)
Jedná se o proceduru, kterou adresujete jako ovládající. V našem případě má třeba
takovýto název – tato procedura je vlastně pro to aby jste něco naprogramovali velice
důležitá, protože kontroluje co se s oknem děje. Má (měla by mít) 4 parametry – hwnd
rukojeť okna,MSG uMsg – message identifer – zde se vrací vše co se s oknem celkově děje –
pracně jsme to překládali ve WinMain. wParam, - první message parametr tohle kontroluje co
dáváte oknu jako příkazy stejně jako LPARAM lParam druhý message parametr.
Teď nějaký ty funkce co používám v příkladu:
PostQuitMessage
Tato funkce ukončuje program má jeden parametr a to kód výstupu – ten vás nemusí
moc tížit to už je taková pokročilejší věc. Tato funkce se nejčastěji používá po Msg –
WM_DESTROY.
11
DefWindowProc
Toto je také poměrně důležitá funkce, pomáhá řešit problémy co neřeší vaše WndProc a
tyto problémy řeší standardním způsobem. Má čtyři parametry a jsou stejné jako u WndProc.
Tuto funkci je nutné použít, neřešíme-li všechny případy co se děje s oknem – to je
nepravděpodobné.
Dáme si asi nějakej příkládek ve které si uděláme okýnko, aby to bylo pochopitelnější.
No trocha teorie jen na pitomý wokno a vono to je skoro na čtyři stránky to nasere co?
To si představte, že by jste to museli psát.
Příklad č.3 - Okno
Naším úkolem je stvořit úplně obyčejné okno, které se dá zavřít a jmenuje se „Příklad
č.3“. To zní jednoduše co? Ale hůř se to dělá!
.386
.model flat,stdcall
option casemap:none
include \masm32\include\windows.inc
include \masm32\include\user32.inc
include \masm32\include\kernel32.inc
includelib \masm32\lib\user32.lib
includelib \masm32\lib\kernel32.lib
VytvorOkno proto :DWORD,:DWORD,:DWORD,:DWORD
;proceduru si musím nadefinovat předem protože je až za invoke
Takhle se definují všechny funkce – procedury takhle není třeba
definovat.
.data
ClassName db "A",0
AppName db "Příklad č.3",0
.data?
hInstance HINSTANCE ?
CommandLine LPSTR ?
;tohle jsou tzv. data nedata moc toho o tom nevim asi to ani
nebudu moc používat.
.code
start:
invoke GetModuleHandle, NULL
mov
hInstance,eax
invoke GetCommandLine
mov
CommandLine,eax
invoke VytvorOkno, hInstance,NULL,CommandLine,
SW_SHOWDEFAULT
invoke ExitProcess,eax
VytvorOkno proc
hInst:HINSTANCE,hPrevInst:HINSTANCE,CmdLine:LPSTR,CmdShow:DWORD
LOCAL wc:WNDCLASSEX
LOCAL msg:MSG
LOCAL hwnd:HWND
mov
wc.cbSize,SIZEOF WNDCLASSEX
mov
wc.style, CS_HREDRAW or CS_VREDRAW
mov
wc.lpfnWndProc, OFFSET HlavniProcedura
mov
wc.cbClsExtra,NULL
mov
wc.cbWndExtra,NULL
12
push hInstance
pop
wc.hInstance
mov
wc.hbrBackground,COLOR_WINDOW
mov
wc.lpszMenuName,NULL
mov
wc.lpszClassName,OFFSET ClassName
invoke LoadIcon,NULL,IDI_APPLICATION
mov
wc.hIcon,eax
mov
wc.hIconSm,eax
invoke LoadCursor,NULL,IDC_ARROW
mov
wc.hCursor,eax
invoke RegisterClassEx, addr wc
INVOKE CreateWindowEx,NULL,ADDR ClassName,ADDR AppName,\
WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,\
CW_USEDEFAULT,CW_USEDEFAULT,
CW_USEDEFAULT,NULL,NULL,hInst,NULL
mov
hwnd,eax
invoke ShowWindow, hwnd,SW_SHOWNORMAL
invoke UpdateWindow, hwnd
.WHILE TRUE
invoke GetMessage, ADDR msg,NULL,0,0
.BREAK .IF (!eax)
;Až později.
invoke TranslateMessage, ADDR msg
invoke DispatchMessage, ADDR msg
.ENDW
mov
eax,msg.wParam
ret
;tohle je návrat z procedury
VytvorOkno endp
HlavniProcedura proc hWnd:HWND, uMsg:UINT, wParam:WPARAM,
lParam:LPARAM
.IF uMsg==WM_DESTROY
invoke PostQuitMessage,NULL
.ELSE
invoke DefWindowProc,hWnd,uMsg,wParam,lParam
ret
.ENDIF
xor eax,eax
ret
HlavniProcedura endp
end start
Takhle příklad č3. prostě stvoříme okno které je celé šedé.
7. Zase Masm
cyklus .While
Jak už vyplývá z nadpisu .while je cyklus. No tedy .while není cyklus, ale cyklus se s
ním uvádí. Prostě napíšete .while za něj nějakou podmínku a pod to nějakej kód – na konec
kódu .endw. Pak se kód opakuje, dokud je splněna podmínka pokud podmínka není splněná
cyklus se ukončí a program pokračuje tím co je pod ním.
.Break
Přeruší nejbližší cyklus .WHILE nebo .REPEAT. Jestliže použiji .IF podmínka
přerušuje se pouze když je podmínka splněna.
13
Cyklus .REPEAT
Jedná se o podobnou věc jako je .While, ale podmínka je na konci za příkazem .UNTIL
a dokud je podmínka splněna probíhá kód co je mezi .Repeat a .Until. Existuje však také
specielní UNTIL - .UNTILCXZ – jde o to že cyklus probíhá dokud není cx=0.
8. Zase něco k Win32 programování
Tak teď sice stvoříme okno, ale to je nám celkem na .., protože je prázdný a vlastně nic
neumí. Tak že se naučíme pár věcí které to okýnko trošku změní.
1. Text v okně.
Jak napsat nějakej textík do okna? No nejde o složitou věj de jen o to jaký sled funkcí
použít, a kam je dát. Tak že k tomu sledu:
BeginPaint
Funkce připraví okno pro malování a naplní PAINTSTRUCT (struktura s informcemi o
malování). Má dva parametry 1 HWND hwnd, - rukojeť okna a LPPAINTSTRUCT lpPaint adresa struktury pro informace o kreslení. Funkce vrací rukojeť device context (DC) pro vaše
okno.
GetClientRect
Tato funkce vrací velikost klient arey – míst co je možný překreslit a co se mění a uloží
jí do proměnné. Má dva parametry – 1rukojeť okna, 2 adresu struktury pro tu velikost té arey.
Takhle jsme si pouze připravili okno pro nakreslení našeho textu. Tak teď by jsme ho
mohli napsat.
DrawText
Funkce napíše formátovaný text v určeném čtverci. Má 5 parametrů 1. HDC hDC,
rukojeť device context (DC), druhý je LPCTSTR lpString, - adresa textu k napsání. Třetí je
int nCount, - délka řetězce k vypsání v písmenech. Když dosadíme –1 zobrazí se všechny
znaky. Čtvrtý je LPRECT lpRect, - adresa struktury se čtvercem k vypsání. Pátý je formát
textu více Win32Helpu.
Tak že jsem to pěkně nadefinoval, jak teď bude vypadat naše WndProc? Následovně:
HlavniProcedura proc hWnd:HWND,
uMsg:UINT,
wParam:WPARAM,
lParam:LPARAM
LOCAL hdc:HDC
LOCAL ps:PAINTSTRUCT
LOCAL rect:RECT
;musím si nadefinovat pomocný proměnný, který mi pomohou uložit
výsledky.
.IF uMsg==WM_DESTROY
invoke PostQuitMessage,NULL
.ELSEIF uMsg==WM_PAINT
invoke BeginPaint,hWnd, ADDR ps
mov
hdc,eax
invoke GetClientRect,hWnd, ADDR rect
invoke DrawText, hdc,ADDR OurText,-1, ADDR rect,
DT_SINGLELINE or DT_CENTER or DT_VCENTER
invoke EndPaint,hWnd, ADDR ps
.ELSE
invoke DefWindowProc,hWnd,uMsg,wParam,lParam
ret
14
.ENDIF
xor
eax,eax
ret
HlavniProcedura endp
Asi takhle bude vypadat WndProc a ještě musíme nadefinovat do dat nějakej řetězec
s nápisem jako OurText. Viz příklad 4.
Menu
Tak že napsat už něco umíme, tak teďka by to chtělo asi udělat si, jak je v aplikacích zvykem
nějaký to menu. Není až zase tak složitý, ale úplně jednoduchý to taky není. Nejde o veliké
změny, ale musíte přidělat Resource file – toto je pomocný soubor, který se používá na
tykový věci jako je menu, definice ikony a jiné. V tomto resource souboru si musíme
nadefinovat název menu - PrvniMenu MENU, naše menu se bude jmenovat PrvniMenu.
Pak musíme napsat složenou závorku pak typ prvního tlačítka buď popup – rozbalovací
a nebo menuitem. Pak v uvozovkách název – v názvu bývá většinou nějaké písmeno
podtržené volá se nějakým písmene to se vám povede když před něj dáte znak &. Když
použijete popup musíte po nadefinování názvu napsat zase otevřenou závorko a pokračovat
v definování tlačítek, když už jich je dost uzavřete zase složenou závorku a definujete další
tlačítka, když je těch taky dostatek tak můžete uzavřít závorku a tím končíte. Za každé tlačítko
by jste měli napsat ID – jeho identifikátor pro program, toto číslo je ve wParam když tlačítko
zmáčknete. Jestliže chcete svoje menu zlepšit tak použijete předělovač tlačítek definujete ho
MENUITEM SEPARATOR. Tak teď jak bude naše menu vypadat v rsrc.rc:
PrvniMenu MENU
{
POPUP "&PopUp"
{
MENUITEM "&Řekni Ahoj",1000
MENUITEM "Řekni &Nazdar",1001
MENUITEM SEPARATOR
MENUITEM "V&en",1002
}
MENUITEM "Menuitem &Test",1003
}
Teď ale menu nebude vidět, protože ho okno nemá nadefinované to se udělá poměrně
jednoduše – přidáme do dat JmenoMenu db "PrvniMenu",0 a pak to už jen přidat do Classu – tam
kde je nápis lpszMenuName asi takhle mov wc.lpszMenuName,OFFSET JmenoMenu. Teď by se mělo
už menu celý zobrazit bez velkých problémů. Viz příklad 5.
Teď sice menu máme, ale je nám na … no prostě potřebujeme, aby to něco dělalo když
zmáčkneme tlačítko. Ani to není až zas tak těžká věc jde jen o drobnou úpravu WndProc.
Potřbujeme k tomu jen vědět pár věcí, když zmáčkneme tlačítko uMsg je rovno
WM_COMMAND a ve wParam (v prvním parametru) se mi vrací identifikační kód tlačítka –
ten jsem napsal za název na tlačítku. Tak že tedy naše WndProc bude vypadat následovně:
HlavniProcedura proc
hWnd:HWND,
uMsg:UINT,
wParam:WPARAM,
lParam:LPARAM
.IF uMsg==WM_DESTROY
invoke PostQuitMessage,NULL
.ELSEIF uMsg==WM_COMMAND
;mov eax,wParam
.IF wParam==1000
invoke MessageBox,NULL,ADDR Textik,OFFSET AppName,MB_OK
.ELSEIF wParam==1001
invoke MessageBox, NULL,ADDR Textik, OFFSET AppName,MB_OK
15
.ELSEIF wParam==1003
invoke MessageBox,NULL,ADDR Textik, OFFSET AppName, MB_OK
.ELSE
invoke DestroyWindow,hWnd
.ENDIF
.ELSE
invoke DefWindowProc,hWnd,uMsg,wParam,lParam
ret
.ENDIF
xor eax,eax
ret
HlavniProcedura endp
Celé je to tedy v příkladu 5.
9. Něco o makrech v MASM32
V MASM se velice často využívají makra nejde o moc složitou věc – je to něco
podobného jako procedura i když trochu jiné, ale jeho překlady rychlostmi a vůbec
vlastnostmi se nebudeme zabývat, nás zajímá pouze funkce a zápis. Tak že makro se zapisuje
za inckude – když už inkludujeme vše co jsme chtěli můžeme napsat makro definuje se asi
tekhle. Nějaké_makro macro param1, param2 – no prostě napíšete název a ze něj nápis macro
a pak parametry, kterých může být „neomezené množství“. Pak píšete kód makra a na konec
napíšete endm. V Masm se velice často užívají určitá makra a to m2m a szText.
Já bych zde uvedl jedno také občas používané makro jako příklad
RGB macro red,green,blue
xor
eax,eax
mov ah,blue
shl
eax,8
mov ah,green
mov al,red
endm
Toto makro nastaví barvu tak jak si zadáte.
Teď si dáme drobný příklad na použití maker. Bude to ale chtít trochu teorie – když
chcete něco naprogramovat a také tomu rozumět, bez teorie to nejde.
Teorie k programu
RGB_value
Toto je taková struktura jedná se o nastavení barvy má 4 parametry no spíše obsahuje 4
osmibitová čísla – to první se nepoužívá a je nula to druhé je červená třetí je zelená a čtvrté
modrá. Struktura vypadá asi takhle
RGB_value struct
unused
db 0
blue
db ?
green
db ?
red
db ?
RGB_value ends
SetTextColor
Tato funkce nastavuje barvu písma má dva parametry – DC – device context a
Rgb_value. A prostě a jednoduše to nastaví barvu písma.
SetBkColor
Tato funkce nastaví barvu pozadí a jinak má stejné parametry jako předchozí.
16
CreateFont
Tahle funkce nastaví font – má moc parametrů, tak že se na ně podívejte
nHeight:DWORD,\ - výška písmen 0 základní velikost
nWidth:DWORD,\ - šířka písmen 0 základní
nEscapement:DWORD,\ (nějaká orientace příštího znaku ) nevim o co go, ale prej to je
stejný jako orientace
nOrientation:DWORD,\ - tohle je orientace textu – o všem více ve Win32Helpu.
nWeight:DWORD,\ tlustost písma
cItalic:DWORD,\ snad nějaká kurzíva 0,1
cUnderline:DWORD,\ podtržení 0,1
cStrikeOut:DWORD,\ - nějaký přeškrtnutí či co.
cCharSet:DWORD,\ set písmen více ve Win32Helpu
cOutputPrecision:DWORD,\ nějakej zmatek.
cClipPrecision:DWORD,\podobnej zmatek
cQuality:DWORD,\ - no nějaká kvalita
cPitchAndFamily:DWORD,\ jakoby rodina fontu.
lpFacename:DWORD – nějakej název fontu.
Tahle funkce mi moc neříká, tak že pokud vás zajímá nebo si ji prostudujte sami – no
možná o ní bude více v učebnici pro pokročilejší.
Jo vrací to hlavičku fontu, která se používá hned v následující funkci.
SetObject
Tato funkce jakoby načte objekt a dá nám hlavičku starého. Potřebuje k tomu DC a
hlavičku objektu nového – vrací hlavičku předchozího objektu.
TextOut
Tato funkce nám vyčaruje textík. Má 5 parametrů DC, x,y začátku, Adresu textu počet
zobrazených znaků.
Příklad 6
V tomto příkladě si napíšeme takový textík – Win32 programovani me obcas pekne
sere. Nemůžeme používat háčky, protože je tam daná jiná sada znaků, ale nějak to jde taky
vyčarovat, hlavní je že tento text napíšeme jinou barvou než černou a každému písmenku
dáme taky nějaký to pozadí.Abychom si práci zjednodušili použijeme makro RGB, kterým si
nastavíme barvu. Příklad zde nebudu psát, je totiž celkem rozsáhlý a už by měla tato příručka
moc velikou velikost, ale teto příklad je v příloze.
10.Ovládací prvky
Trocha teorie – zase – Tlačítka
Tak že důležitý je asi co já řadím mezi ovládací prvky – jedná se o push button, radio
button, listbox, check box. No možná ještě něco.
Teďka je asi důležitý, jak něco takového vytvořit. No není to sice až zase tak
jednoduchý, ale zase to není přespříliš složitý dělá se to příkazem CerateWindwEx – což je
skoro stejné jako CerateWindow. Teďka bych vám měl asi vysvětlit jak to že se tímhle
příkazem nevytvoří další okno, ale něco v tom starém okně – jedná se o změnu ve stylu .- je
tam WS_CHILD a to definuje, že okno bude v okně, které ho vlastní, tlačítko se udělá tak, že
se tam vepíše – také do stylu okna, když je tam více věcí píše se mezi ně or,
BS_DEFPUSHBUTTON. No ale nejjednodušší bude, když tady dám příklad:
invoke CreateWindowEx,\
17
NULL,\ - rozšířený styl okna
ADDR ButtonClassName,\ - jméno registrované třídy
ADDR ButtonText,\ - jméno okna – nápis na tlačítku
WS_CHILD or WS_VISIBLE or - ;tohle nadefinuje tlačítko
BS_DEFPUSHBUTTON,\ - styl okna tohle jen centrování textu
5,\ - umístění v okně x
5,\ - taky y
540,\ - velikost x
505,\ - velikost y
hWnd,\ - okno, které to vlastní
1,\ - rukojeť menu – jedna- tady je to IDéčko – identifikační kód toho tlačítka
hInstance,\ - rukojeť tvorby okna
NULL – data na tvorbu okna
Jo a ještě je třeba nadefinovat do dat – v našem případě jako ButtonClassName db
„button“ jinak se tlačítko neobjeví.
Problém je však podobný jako minule – máme tlačítko, můžeme si ho sice mačkat jak
chceme, ale nic to neudělá. ID tlačítka se vrací, když ho zmáčkneme v wParam no není to až
zase tak jednoduchý, tak že sem hodím nějakej příklad:
HlavniProcedura proc hWnd:HWND, uMsg:UINT, wParam:WPARAM,
lParam:LPARAM
.IF uMsg==WM_DESTROY
invoke PostQuitMessage,NULL
Standard
.ELSEIF uMsg==WM_CREATE
invoke CreateWindowEx,NULL, ADDR ButtonClassName,\
ADDR ButtonText,WS_CHILD or WS_VISIBLE,5,5,750,520,\
hWnd,1,hInstance,NULL
.ELSEIF uMsg==WM_COMMAND
mov eax,wParam
.IF lParam!=0
.IF ax==1
shr eax,16
Tohle je posunutí u 16 bitů 32bitového čísla, abychom mohli
zhodnotit i druhou část
.IF ax==BN_CLICKED
invoke MessageBox,hWnd,ADDR Text,\
ADDR AppName,MB_OK
.ENDIF
.ENDIF
.ENDIF
.ELSE
invoke DefWindowProc,hWnd,uMsg,wParam,lParam
ret
.ENDIF
xor eax,eax
ret
HlavniProcedura endp
To je asi vše k ovládání, berte to asi tak jak to tady je – je to nejlepší způsob, kterej
prozatím znám.
Na a teď máme tlačítko, a tak si to trochu rozšíříme – těch tlačítek se totiž dá
naprogramovat více druhů.
Tyto druhy s píší za or do stylu okna.
BS_3STATE takový zaškrtávací políčko, ale nejde zaškrtnout. No vono je to
složitější až to pochopím, tak to sem napíšu.
18
BS_AUTO3STATE tohle je podobný, ale zaškrtnou to jde a získává to po druhym
kliknutí šedou barvu.
BS_AUTOCHECKBOX
stejný, ale nešediví a rovnou se odškrtne
BS_CHECKBOX
nevím proč, ale nejde mi zaškrtnout. Jinak stejný
BS_AUTORADIOBUTTON no takový přepínání – například při vypínání počítače
BS_DEFPUSHBUTTON
normální tlačítko
BS_GROUPBOX
no prostě skupiny
BS_RADIOBUTTON taky přeškrtávátko
No to by asi k těm důležitým stačilo více v Win32Helpu.
Tohle všechno si můžete vyzkoušet všichni sami nejde o nic moc těžkého k ovládání
těch ostatních tlačítek se dá také bez potíží zvládnout viz níže.
Trocha teorie – zase – Combobox
Podobně jako jsme stvořili různá tlačítka můžeme stvořit i různé Comboboxy. Akorát že
do ButtonClassName dáme Combobox jde o předdefinovaný styl (stejně jako u tlačítka) a dá
se měnit podobně jako tlačítko.
Combobox je vlastně na psaní textu – ale jen jednoho řádku.
CBS_AUTOHSCROLL
tento styl způsobí, že se bude text pohybovat, když
dojdete na konec bude se text psát dále, a ten starý text se bude posunovat.
CBS_DISABLENOSCROLL tady se text zase nebude posouvat na konci.
CBS_DROPDOWN tady to se většinou používá již s napsanými věcmi – na konci
boxu je tlačítko, kterým si rozbalíte nabídku – třeba již použitých nápisů.
Jo ještě jsem zapomněl napsat, že když bude velikost comboboxu větší než jeden řádek
zobrazí se pod ním listbox – něco na vybírání.
CBS_DROPDOWNLIST
tohle je podobné, jako ten předchozí, ale místo nabídky
se vám zobrazí list box, ve kterém můžete vybírat.
CBS_LOWERCASE tohle zase způsobí, že nejdou v boxu psát velký písmena.
CBS_UPPERCASE zase opak – nejdou psát malý písmenka.
No s tímhle bych si vystačil asi ke comboboxu – více zase ve Win32Help.
Trocha teorie – zase – Edit
Zase stejný – předdefinovaný styl „edit“ co se tam dá napsat:
ES_AUTOHSCROLL bude se posouvat do strany.
ES_MULTILINE
posunuje text po řádcích po Enteru
ES_AUTOVSCROLL tohle když zmáčknete enter na konci to posunuje dál
ES_READONLY
můžete si pouze číst.
No to by pro práci mohlo stačit
Scroll bar
Styl „scroolbar“
SBS_BOTTOMALIGN
scroll bar má standardní velikost.
SBS_LEFTALIGN
scrollbar má standardní velikost a je nahoře
SBS_RIGHTALIGN scrollbar má standardní velikost a je dole
SBS_VERT
scrollbar je vertikálně.
To by asi k tomuhle stačilo.
11.Teorie a Teorie
Teď se budeme asi hlavně zabývat teorií programování pod Windows, protože k tomuto
je potřeba toho vědět nejvíce a nejvíce se to využije.
19
Tady bude takovej zmatenej seznam všeho možnýho co se hodí – na co jsem narazil při
mém programování.
Process
Takže nejdříve k tomu co je to process – pomocí procesu jde spustit i vypnout exe
soubor, spustit jde i jinými způsoby, ale začneme tímto
CreateProcess
Tohle je příkaz na spuštění má pár parametrů : 1. adresa cesty k aplikaci, 2. adresa
příkazů do příkazové řádky, 3. nějaký atributy – NULL 4. to samý,5. nějaký vlajky 6. – tady
se nastavuje priorita procesu. 7 ukazatel na momentální adresář, 8.stratinfo 9.informace o
procesu.
GetStartupInfo
Tohle je docela dobrý ne to startinfo. – Jinak ho nedostanete 1. parametr a to je to
startinfo.
WinExec
No tohle je ten druhý způsob spuštění programu – není to tak složitý, ale zase to nejde
tak ovládat – tato funkce má dva parametry – adresu příkazu a styl okna – jak se má aplikace
zobrazit.
SetCurrentDirectory
No když už jsme u tý práce se soubory tohle se hodně hodí – má to jeden parametr a
nastaví to adresář. Chce to adresu s nápisem cesty k adresáři.
Jak z programu zaškrtnout checkbox?, Jak zkontrolovat stav checkboxu?
Tohle je problém, na kterej jsem stále narážel a nešel mi vyřešit vono to sice není až
zase tak složitý, ale přijít na to jen tak to je husarský kousek. No mně se to samozřejmě
povedlo, jinak bych to tu nemohl napsat – nikde v příkladech jsem to nemohl najít, ale Ve
Win32Helpu se mi to částečně podařilo, tak že jak se to dělá.Jde o to že musíte poslat zprávu
checkboxu, že je zaškrtlej a posílání zpráv se děje pomocí SendMessage:
invoke SendMessage,Hwnd (Hlavička checkboxu nebo
radiobuttonu),BM_SETCHECK,1,0
BM_SETCHECK má v lParam – 1. údaj hned za tím 0,1,2 nezaškrtnuto,zaškrtnuto,šedé
a v Wparam má vždy nulu.
Tak že takhle si můžete checkboxík zaškrtávat a vodškrtávat jak se vám líbí a z řídící
aplikace.
Stav checkboxu se kontroluje podobně akorát, že místo BM_SETCHECK napíšete
BM_GETCHECK pak se vám v EAX vrátí buď 0-nezaškrtnuté nebo chyba 1 zaškrtnuté,2
zšedivělé.
Při tomto zjišťování je lepší mít hlavičku nadefinovanou buď jako .data nebo jako
.data?, protože jako LOCAL se vztahuje jen na tu proceduru a nějak to funguje, ale dost blbě.
To jenom pro to, aby jste nedopadli jako já, že jsem asi 1h přemýšlel proč to nefunguje.
GetCurrentDirectory
No tohle je takovej poměrně důležitej příklad – jedná se o uložení cesty k adresáři, který
je právě nastavený. Má to dva parametry 1.velikost zásobníku v bytech a 2. je adresa
zásobníku. Funkce vám naplní zásobník cestou, když se to nepovede tak to vrátí 0.
Samozřejmě v EAX.
CreateFile
20
Vytvoří nebo otevře soubor pro čtení, psaní. Parametry : 1 adresa názvu souboru, 2.jestli
se tam má psát – GENERIC_WRITE nebo jestli se to má jen číst GENERIC_READ, 3.
nějakej share parametr FILE_SHARE_READ, FILE_SHARE_WRITE, 4 nějaký parametry
víc ve Win32Helpu, 5 parametr otevření CREATE_NEW atd. 6. vlajky a atributy
FILE_ATTRIBUTE_NORMAL atd., 7.rukojeť template souboru. Hlavně to vrací rukojeť
otevřeného souboru, když se to zkazí vrací ERROR_ALREADY_EXISTS nebo
INVALID_HANDLE_VALUE.
ReadFile
Čte soubor a potřebuje k tomu 1. rukojeť souboru, 2 adresu zásobníku pro data, 3. počet
bytů k přečtení, 4. adresu nějaké proměnné v té pak vrací kolik přečetl, 5.nějaká struktura pro
data k té více v Win32Helpu.Vrací TRUE,FALSE.
GetOpenFileName
Na tento příkaz jsem narazil spíše v jiném souboru než v mém, „ ale vzhledem k tomu,
že je potřeba znát všechny!!!“ – a je toho hodně. Tak sem píši co jde. Tato procedura otevírá
soubor má pouze jeden parametr a to adresu struktury a otevíraným souborem. No má sice
jedem parametr, ale je to celá struktura, tak že jsme si moc nepomohli. Teď teda ta struktura:
typedef struct tagOFN { // ofn
DWORD
lStructSize; v bytech délka struktury
HWND
hwndOwner; Rukojeť okna, které vlastní dialog – ve kterém
máte editovací okno.
HINSTANCE
hInstance; Rrukojeť stvoření - hInstance
LPCTSTR
lpstrFilter; OFFSET názvu filtru pro soubory k otevření.
LPTSTR
lpstrCustomFilter; nějakej specielní filtr – pokud vás zajímá
dočtete se o něm v Win32Helpu – pokud ne tak tam dosaďte NULL nebo to ani nepoužívejte.
DWORD
nMaxCustFilter; Tohle specifikuje velikost specielního filtru.
DWORD
nFilterIndex; Nějakej index filtru.
LPTSTR
lpstrFile; Offset bufferu pro přenos souboru
DWORD
nMaxFile; Specifikuje velikost bufferu v bytech..
LPTSTR
lpstrFileTitle; Nějakej název souboru co se hledá.
DWORD
nMaxFileTitle; Velikost bufferu s názvem souboru je
ignorována, když buffer není.
LPCTSTR
lpstrInitialDir; Specifikace adresáře ve kterém se zjevíte, když
napíšete NULL objevíte se v adresáři, ve kterém právě jste.
LPCTSTR
lpstrTitle; Název dialog boxu na otevírání nebo uzavírání
souborů.
DWORD
Flags; Vlajky (je jich moc, tak že se s nimi tady nebudu
rozepisovat, ale jsou důležitý).
WORD
nFileOffset; Nějakej zmatek – cesta k souboru, ale offset, ale
hodnota no nevim.
WORD
nFileExtension; To je stejný jako předchozí, akorát je to cesta
k příponě.
LPCTSTR
lpstrDefExt; Nějakej zmatek.
DWORD
lCustData; Nějakej parametr co se vrací v lParam, když je
v Msg WM_INITDIALOG.
LPOFNHOOKPROC lpfnHook; Nerozumim.
LPCTSTR
lpTemplateName; Kdyby jste chtěli používat template file. Tak
tohle je adresa názvu v resource souboru.
} OPENFILENAME;
21
No moc jsem toho o tom nenapsal, asi pro to že toho o tom moc nevím zkuste to
přeluštit a když se vám to povede pošlete mi to na e-mail uděláte mi radost a pomůžete tak
ostatním k vyššímu vědění, třeba zase oni pak pomůžou vám s něčím.
Kurva jsem sem nějak zapomněl svůj e-mail napsat co – tak je to: [email protected].
Jo nějak jsem zapomněl na tu funkci GetOpenFileName neřekl jsem totiž co vrací –
vrací jen TRUE nebo FALSE, když se nepovede a je někde nějaká chyba.
GlobalAlloc
Tato funkce alokuje (připraví na vše použití) specifikovaný počet bytů. Má dva
parametry Vlajky a Velikost – počet bytů paměti k uvolnění. – Vlajky, i když to normálně
nedělám tady popíši, protože mě zajímaly.
GMEM_FIXED
Alokuje upevněnou paměť. Tato vlajky se nesmí kombinovat s
GMEM_MOVEABLE nebo GMEM_DISCARDABLE vlajkou. Vrácená hodnota je ukazatel
na blok paměti.
GMEM_MOVEABLE Alokuje pohyblivou paměť. Vrácená hodnota je hodnota rukojeti
objektu paměti. Rukojeť je 32-bitové. K přeložení rukojeť na ukazatel, užijte funkci
GlobalLock .
GPTR Kombinuje GMEM_FIXED a GMEM_ZEROINIT vlajky.
GHND Kombinuje GMEM_MOVEABLE a GMEM_ZEROINIT vlajky.
GMEM_DDESHARE Alokuje paměť, která se užívá Dynamic data exchange (DDE)
funkcemi pro DDE domluvu. Nefunguje pod Windows 3. x. To je nějaká až moc složitá
paměť – nejde mi to přeluštit.
GMEM_DISCARDABLE
Alokuje odkládací paměť. Některé Win32-aplikace
mohou ignorovat tuto vlajku.
GMEM_LOWER
Tato vlajka je tady jen pro kompatibilitu s Windows 3. x.
GMEM_NOCOMPACT
Neupevňuj ani neodkládej paměť při alokaci
GMEM_NODISCARD
Neodkládej paměť při alokaci.
GMEM_NOT_BANKED
kompatibilita s Windows verze 3. x.
GMEM_NOTIFY
Tato vlajka je tady jen pro kompatibilitu s Windows 3. x.
GMEM_SHARE
Stejné jako GMEM_DDESHARE.
GMEM_ZEROINIT Inicializuje paměťový obsah na nulu (vynuluje alokovanou
paměť).
Funkce vrací hodnotu nové rukojeti alokovaného objektu – samozřejmě v EAX.
GlobalLock
Tato funkce nám dá pointer na první byte v paměťovém objektu – používá se nejčastěji
po o předchozím příkazu s vlajkou GMEM_MOVEABLE. Jinak snad ani není potřeba.
Potřebuje jen rukojeť toho paměťového objektu a vrátí v EAX ukazatel. A paměť je pak nějak
uzamčená.
GlobalUnlock
Tahle funkce nám zase „odemkne paměť používá se po předchozí, když už tu paměť
nepotřebujeme, protože jinak by zůstala paměť uzamčená a jiné aplikace by do ní neměly
přístup. Má jeden parametr - ten pointer na paměť a vrací TRUE, FALSE.
GlobalFree
Používá se po GlobalAlloc a má jeden parametr – vrácenou rukojeť touto funkcí. A při
chybě vrací NULL.
MoveWindow
22
Změní pozici a rozměry určeného okna má 6 parametrů – 1. je rukojeť okna, které se má
měnit, 2. je horizontální pozice, 3. vertikální pozice, 4. šířka, 5. výška, 6. je vlajka překreslení
hodnoty této vlajky jsou TRUE nebo FALSE, aby se to překreslilo používám TRUE, ale více
o tom v Win32Helpu.
GetFileSize
Jak už z názvu vyplývá jedná se o zjištění velikosti souboru má to dva parametry –
rukojeť souboru a nějaká adresa high-order wordu no nevim co to je, ale když tam dáte NULL
taky to funguje. Funkce vrací v eax velikost souboru v bytech.
Doslov
No je to sice taková útlejší příručka, ale mohla by vám pomoci v naučení se
programování v MASM a s trochou snahy, pokud jste to vše pochopili by jste se mohli začít
hlásit mezi ty mírně pokročilé. Pokud jste to nepochopili, napište mi přesně co a já vám s tím
poradím můj e-mail je někde v textu – i když nepochopíte něco co jsem tam nenapsal nic si
z toho nedělejte, prostě mi to pošlete je totiž možné, že jsem na to už narazil a už jsem to
zvládl, tak že vám poradím, pokud narazíte na něco co je tady už napsáno, ale je to
nepochopitelně napsané nebojte se a napište mi taky. Pokud pochopíte něco, co tady je
napsáno až příliš stručně, nebo je tam, že to já nechápu napište mi taky, ať se to dostane do
této příručky a ostatní včetně mě s tím nemají potíže. To je asi vše. Doufám, že se vám moje
dílo líbí.
Doslov k verzi 1.1
Nevěřte úplně všemu co je v této knize, protože jak už je řečeno v předmluvě psal jsem
to když jsem začínal a prostě a jednoduše psal jsem blbosti. Pokoušel jsem je tak trochu
opravit, ale ta knížka je fakt docela dlouhá a tak jsem neopravil vše. Ale stejně si myslím, že
do začátku je tato knížka celkem dobrá.
Doslov k verzi 1.2
Tak jsem zase udělal korekci a dalo by se říci, že to nejdůležitější je správně a je tedy
kniha relativně použitelná. Nějaké chyby se zde objevují, ale většinou se jedná pouze o
drobnosti, které nepůsobí velké chyby. Snad se vám líbila.
Datum 7.2.2004
23
Dopsáno 7.2.2004
Autor: Jaromír Veber
Verze 1.3
Typ : Pro začátečníky
Publikace této knihy je povolena autorem – je tedy volně šiřitelná a není tedy třeba
platit a stažením této knihy jste se nedopustily žádného trestného činu, ale je zakázáno tuto
knihu volně šířit bez zmínky o autorovi nebo si knihu přivlastňovat či ji za peníze vydávat ☺.
Poznámka k PDF vydání:
Toto je sice prenositelná forma, ale vzhledem k tomu, že se nejedná o výchozí formu je
nutné brát ji jak je i s vadami, které jsou zpusobeny prevodem a hlavne podle mne
zbytecnu velikosti.
24