პითონის შესავალი კურსი, როგორც წესი სინტაქსის, ობიექტების ძირითადი ტიპების(კლასების), ოპერატორების და
სტანდარტული ბიბლიოთეკის ზოგიერთი მოდულის შესწავლას გულისხმობს. პითონის სტანდარტული ბიბლიოთეკის
ერთ-ერთი ყველაზე გავრცელებული მოდულია tkinter , რომელიც
საშუალებას იძლევა პროგრამას დაემატოს
გრაფიკული საშუალებები, რომლებსაც ინფორმაციის შეყვანა და გამოყვანა გრაფიკულ რეჟიმში გადაყავს. გრაფიკული
რეჟიმი გაცილებით თვალსაჩინოს ხდის ინფორმაციის გაცვლას პროგრამასთან, რის გამოც თანამედროვე პროგრამების
უმრავლესობას ახლავს მომხმარებლის გრაფიკული ინტერფეისი, რომელიც ინგლისური აბრევიატურით GUI
არის ცნობილი (Graphical User Interface).
ჩვენ უკვე გვქონდა ლაპარაკი GUI-ის შესახებ ამ კურსის დასაწყისში, როდესაც პითონის IDLE განვილეთ. ეს პროგრა,
რომლითაც მოსახერხებელია პითონზე პროგრამირების შესწავლა და რომელიც ამ კურსში გამოვიყენეთ tkinter-მოდულის
საშუალებით შეიქმნა.
გრაფიკული ინტერფეისის შექმნის ერთ-ერთი ყველაზე გავრცელებულ საშუალებას წარმოადგენს Tk პროგრამული პაკეტი,
(Tk GUI toolkit) რომელიც 1990 წლების დასაწყისში შეიქმნა. ეს პაკეტი აერთიანებს გრაფიკულ პროგრამებს, რომლებიც
ცნობილია როგორც widget-ები. Tk - სტანდარტული widget-ების საშუალებით გაცილებით იოლია GUI შექმნა.
შეიძლება ითქვას, რომ ეს widget-ები Tk კონსტრუქტორის ნაწილებია, რომელთა საშუალებით ხდება GUI-ის "აწყობა".
ეს გრაფიკული "კონსტრუქტორი" ისეთი პოპულარული გახდა, რომ პითონში შეიქმნა მოდული, რომელც Tk- გამოყენების საშუალებას
იძლევა. მოდულის სახელი tkinter, რომელიც პითონ-3 ში იხმარენა tk interface-ის შემოკლებას
წარმოადგენს (პითონ-2 ში მოდულის სახელია Tkinter).
პითონის tkinter-მოდული აერთიანებს კლასებს, რომლებიც დაკავშირებულია გრაფიკულ widget-ებთან და
რომლებიც პითონის პროგრამდან GUI-ის აგების საშუალებას იძლევა. გრაფიკული საშულებები
შეიძლება გამოყენებული იქნას როგორც ინფორმაციის გამოყვანისთვის კომპუტერის ეკრანზე, ასევე ინფორმაციის
შეყვანისთვის. tkinter-ში ჩართულია ასევე გრაგიკის შექმნის საშუალებები და პროგრამასთან ინტერაქტული
ურთიერთობის საშუალებები, რაც რთული გრაფიკული პროგრამების (მათ შორის კომპუტერული თამაშების)
შექმნის საშულებას იძლევა.
კომპუტერული გრაფიკის მნიშვნელოვანი გამოყენება დაკავშირებულია ფიზიკური პროცესების ვიზუალიზაციასთან,
რაც ხშირად ანიმაციის გამოყენებას გულისხმობს. პითონის tkinter ასეთი პროგრამების შექმნაც საშუალებასაც იძლევა.
პითონის tkinter-ის ყველა საშუალებების სრული აღწერა პროგრამირების საწყისი კურსის ერთ თავში
რა თქმა უნდა შეუძლებელია. ამ ნაწილის ძირითად დანიშნულებას წარმოადგენს tkinter-ის ძირითადი widget-ების
გაცნობა და მათი საშუალებით შედარებით მარტივი გრაფიკული ინტერფეისების აგება. ამ თავის ბოლოს ნაწილი
ეთმობა Canvas - კლასის აღწერას, რომელიც tkinter-ის გამოყენებით გრაფიკული ობოექტების და გამოსახულებების
აგების საშუალებას იძლევა.
პითონის tkinter-მოდულის განხილვის დაწყებამდე საჭიროა კომპუტერული გრაფიკის რამდენიმე ბაზური ცნებისა და
განმარტების შემოყვანა. ამ თავში ვგულისხმობთ, რომ გრაფიკის გამოსახვა კომპუტერის ეკრანზე (მონიტორზე, დისპლეიზე)
ხდება, შესაბამისად აუცილებელია დისპლეის პარამეტრების ცოდნა.
კომპუტერის მონიტორს, როგორც წესი მართკუთხედის ფორმა აქვს და თამამედროვე კომპუტერებში(2010 წლის შემდგომ),
ჰოროზონტალური და ვერტიკალური გვერდების ფარდობა შეადგენს 16:9. (წინა თაობის კომპუტერებში ეს ფარდობა იყო 4:3).
კომპუტერის მონიტორის ზომად ხშირად მისი დაგონალის სიდიდე იხმარება, რომლებიც ხშირად მოყვანილია დიუმებში.
თანამედროვე პერსონალურ კომპუტერების (ლაპტოპების, Laptop) მონიტორის ზომები 10 დიუმიდან იწყება და შეიძლენა
17 დიუმს აღემატებოდეს.
მონიტორის ერთ-ერთი მთავარი მახასიათებელია მისი გარჩევსუნარიანობა, რომელიც როგორც წესი იზომება
პიქსელებში(pixel), რომელიც გრაფიკული გამოსახულების მინიმალურ ელემენტს წარმოადგენს. (სიტყვა pixel -
სურათის (picture) და (element) სახელებს აერთიამებს). გრაფიკული ფანჯრების ზომები, რომლებიც
tkinter-ის მიიღება , როგორც წესი ამ ერთეულებში იზომება. კომპუტერის მონიტორების გარჩევისუნარიანობა,
როგორც წესი მითითებულია პიქსელებში (px). თანამედრონე კომპუტერების(ლაპტოპების) მონიტორის
გარევისუნარიანობა შეადგენს 1020 px ან მეტს ჰორიზონრალური მიმართულებით და 768px ან მეტს ვერტიკალური
მიმართულებით (1024 x 768). თვითოეულ pixel-თან დაკავშირებულია ასევე ფერი და ინტენსიობა. თუ რამდენი
ფერი შეიძლება პქონდეს ერთი პიქსელს, განისაზღვრება მასზე გამოყოფილი ბიტების (ორობითი თანრიგების)
რიცხვით bpp( bits per pixel). მაგალითად, თუ ფერზე გამოყოფილია
16 ბიტი, პიქსელის შეილება 216= 65536 ფერი ჰქომდეს, რაც მიიღება სამ ძირითადი ფერის
(წითელი, ლურჯი, მწვანე) შერევით. ფერის და მის გამოყენების შესახებ უფრო დაწვრილებით ან თავის
სხვა ნაწილში ვისაუბრებთ.
wraplength
გრაფიკული ინტერფეისის(გარემოს) შექმნა tkiner-ის საშუალებით რამდენიმე ნაბიჯისგან შედგება.
პირველი ნაბიჯი ძირითად(ძირეულ, მშობელ) გრაფიკული ობიექტს განსაზღვრავს. ასეთი ობიექტის
როლს ჩვენ პროგრამებში ასრულებს w1, რომელიც ძირითად გრაფიკულ ფანჯარას ქმნის.
ამ ობიექტის(w1) თვისებები, მაგალითად გრაფიკული ფანჯრის ფონური ფერი, შესაძლებელია
შეიცვალოს config მეთოდის გამოყენებით. მეორე ნაბიჯი გულისხმობს შესაბამისი widget-ების
არჩევას და მათი საშუალებით გარკვეული თვისებების მქონე გრაფიკული ობიექტების შექმნას.
გრაფიკული ობიექტების თვისებები (მაგალითად ზომა, ფერი, გამოყენებული ფონტი) განისაზღვრება
პარამეტრების საშუალებით, თუმცა აქაც შესაძლებელია config-მეთოდის გამოყენება.
ეს გრაფიკული ობიქტები, როფორც წესი შვილობილ ობიექტებს წარმოადგენენ.
მესამე ნაბიჯი შვილობილი გრაფიკული ობიექტები ძირითად(მშობელ) გრაფიკული ობიექტზე განლაგებას
გულისხმობს. თუ შვილობილი გრაფიკული ობიექტების რიცხვი ერთზე მეტია, ბუნებრივია საჭირო განისაზღვროს
მათი განლაგება.
გრაფიკული ობიექტების მშობელ ობიქტში განლაგებებისთვის tkinter-ის პროგრემში ძირითადათ
ორი მეთოდი grid და pack გამოიყენება.
პირველ tkinter-სკრიპტში, რომელიც ამ ნაწილში განვიხილეთ, საჭირო იყო მხოლოდ ერთი გრაფიკული
ობიექტის განთავსება. ამისათვის გამოვიყენეთ pack-მეთოდი პარამეტრების გარეშე, ე.ი. პარამეტრების
საწყისი(default) მნიშვნელობები გამოვიყენეთ. მომდევნო პროგრამაში ორი გრაფიკული ობიექტი განლაგება
ასევე pack-მეთოდი მეთოდით მოხდა, მაგრამ ამჯერად ობიექტების მდებარეობს side-პარამეტრის
საშულებით განისაზღვრა. პირველი ობიექტი ამ პარამეტრის საშუალებით მარჯვნივ(RIGHT) განთავსდა, მეორე ობიექტი
კი მარცხნივ(LEFT). side-პარამეტრს 4 მნიშვნელობის მიღება შეუძლია, აღნიშნული მნიშვნელობების გარდა ეს
მნიშვნელობება TOP (ზევით) და BOTTOM (ქვევით). ყურადღება მიაქციეთ, რომ ობიექტები BOTTOM, LEFT,
RIGHT და TOP წარმოადგენენ trkinter-ში განსაზღვრულ სტრინგის ტიპის ცვლადებს, რომელთა მნიშნელობები
შესაბამისად არის "bottom", "left", "right" და "top". პარამეტრის განსაზღვრისას შესაძლებელია ორივე
( მაგალითად BOTTOM ან "bottom" ) მნიშვნელობის ხმარება.
განვიხილოთ მაგალითი, როდესაც შვილობილი Label-ტიპის გრაფიკული ობიექტების რიცხვი არის 4 .
პითონის შესაბამისი სკრიპტი ქვევით არის მოყვანილი.
from tkinter import *
w1=Tk()
w1.config(bg="white")
BD, PX, PY =6, 5, 5
R=[FLAT, SUNKEN, RAISED, GROOVE, RIDGE]
L0=Label(w1, text=" obieqti 1 ", font=("LitNusx", 16, "bold"), relief=R[1], bd=BD, padx=PX, pady=PY , bg="Red", fg="Yellow")
L1=Label(w1, text=" obieqti 2 ", font=("LitNusx", 20, "bold"), relief=R[2], bd=BD, padx=PX, pady=PY, bg="Yellow", fg="Red")
L2=Label(w1, text=" obieqti 3 ", font=("LitNusx", 40, "bold"), relief=R[3], bd=BD, padx=PX, pady=PY, bg="Green", fg="White" )
L3=Label(w1, text=" obieqti 4 ", font=("LitNusx", 24, "bold"), relief=R[4], bd=BD, padx=PX, pady=PY, bg="Blue", fg="white" )
L0.pack()
L1.pack()
L2.pack()
L3.pack()
mainloop()
მაგალითის შესაბამისი გრაფიკული გამოსახულება მოყვანილია სურათზე , საიდანაც სჩანს, რომ
pack-მეთოდის გამოყენება პარამეტრების გარეშე იწვევს გრაფიკული ობიექტების ვერტიკალურ განლაგებას,
მიმათულებით ზევიდან(TOP) ქვევით(BOTTOM). მოყვანილი გრაფიკული ობიექტები, ერთმანეთისგან ფერით,
ფანჯრის რელიეფით (იხილე პარამეტრი relief) და ფონტის სიდიდით განსხვავდებიან. მიღებული გრაფიკული
გამოსახულების პორიზონტალური ზომაა განისაზღვრები ყველაზე დიდი ობიექტის ზომით.
მომდევნო სურათზე
იმავე ობიექტებს ჰორიზომტალური განლაგება უკავიათ. ამ განლაგების მისაღებად ყოველი ობიექტის pack-მეთოდს
დაემატა პარამეტრი side=LEFT.
სურათი ???
|
სურათი ???
|
გრაფიკული ობიექტების განლაგების შეცვლა pack-მეთოდის პარამეტრებით შეიძლება. მომდევნო ორ სურათეზე
ამის მაგალითია მოყვანილი. სურათი -ზე შენარუნებულია ვერტიკალური განლაგება, თუმცა პარამეტრ side-ის მნიშვნელობა
BOTTOM მიანიშნებს, რომ ობიექტების განლაგება დაიწყება ქვევიდან (განლაგების მიმართულება იქმება ქვევიდან ზევით).
პარამეტრი fill=X მიანიშნებს, რომ ობიექტი ჰორიზონტალური მიმართულებით(X) სივრცეს მთლიანად შეავსებს.
ამ პარამეტრს შეუძლია ასევე მიიღოს მნიშვნელობა Y (სივრცის შევსება ვერტიკალური მიმართულებით) და BOTH
(სივრცის შევსება ორივე მიმართულებით). ქვევით მოყვანილ მაგალითში ასევე გამოყენებულია პარამეტრები
padx და pady - რაც მიანიშნებს იბიექტის დაშორებაზე მოსაზღვრე ან მშობელი გრაფიკული ობიექტიდან
ჰორიზონტალური და ვერტიკალური მიმართულებით. პარამეტრი anchor - განსაზღვრავს მდებარეობას მშობელ
ობიქტში (ობიექტის ნაწილში). ამ პარამეტრი შესაძლო მნიშვნელობები widget-ში არსებული anchor პარამეტრის
მნიშვნელობების ანალოგიურია. პითონის სკრიპტის ნაწილი, რომლის მეშვეობით მიღებულია სურათი ?? მოყვანილია
ქვევით.
L0.pack(side=BOTTOM, fill=X)
L1.pack(side=BOTTOM, fill=BOTH, padx=5)
L2.pack(side=BOTTOM, pady=5)
L3.pack(side=BOTTOM, anchor=W, padx=5, pady=5)
შემდეგი სურათის მისაღებად პითონის სკრიპტის ქვევით მოყვანილი ნაწილი გამოვიყენეთ. ობიექტების
პორიზონტალური განლაგება უზრუნველყოფილია pack-მეთოდის side-პარამეტრის მნიშვნელობით RIGHT,
რაც ნიანიშნებს გრაფიკული ობიექტების განლაგების მიმართულებას მარჯვნიდან მარცხნისკენ.
L0.pack(side=RIGHT, anchor=S, padx=5, pady=5)
L1.pack(side=RIGHT, fill=BOTH, padx=5)
L2.pack(side=RIGHT, pady=5)
L3.pack(side=LEFT, anchor=N, padx=5, pady=5)
pack-მეთოდის პარამეტრების რიცხვი მოყვანილი მაგალირებით არ ამოიწურება. პარამეტრების სრული სიის ნახვა შესაძლებელია
ამ ნაწილის ბოლოს მოყვანილ tkinter-ის რესურსების გვერდებზე.
სურათი ???
|
სურათი ???
|
გრაფიკული ობიექტების გეომეტრიული განლაგების განსაზღვრის მეორე მეთოდს წარმოადგენს grid-მეთოდი.
როდესაც გრაფიკულ ფანჯარაში საჭიროა მრავალი ობიექტის განლაგება, უპირატესობას ამ მეთოდს ანიჭებენ. უნდა ავღნიშნოთ,
რომ პითონის სკრიპტში არ შეიძლება pack და grid მეთოდების არევა ე.ი. tkinter-ის ერთ პროგრამაში დაშვებულია მხოლოდ
ერთ-ერთი მათგანის გამოყენება. რა განსხვავებაა ამ მეთოდებს შორის ? grid-მეთოდი, როგორც სახელი მიუთითებს, ქმნის
ორ-განზომილებიან (2D) მესერს, რომლის თვითოეული უჯრა განისაზღვრება პარამეტრებით column და row.
პარამეტრების მნიშვნელობები მთელი დადებითი რიცხვებია. საწისი(default) მნიშვნელობები (b>colum=0,. row=0)
შეესაბამება მარცხენა ზედა კუთხეში მდებარე უჯრას. აღსანიშნავია, რომ გრაფიკულ ობიექტს შეუძლია მესერის რამდენიმე
უჯრის დაკავება. ეს ნიშნვს რომ grid-მეთოდით შესაძლებელია მესრის უჯრის შექმნა, რომელიც რამდენიმე
"ერთეულოვან" უჯრას გააერთიანებს. ჰორიზონტალური მიმართულებით უჯრების გაერთიაება შესაძლებელია
პარამეტრით columnspan, ხოლო ვერტიკალური მომართულებით rowspan.
ამ პარამეტრების საწყისი(default) მნიშვნელობებია (columnspan=1, rowspan=1) მესრის
ერთეულოვან უჯრას შეესაბამება. grid-უჯრის შიგნით გრაფიჯული ობიექტის განლაგება განისაზღვრება
stick-პარამეტრით. აქ ვგულისხმობთ, რომ grid-მესრის გრაფიკული უჯრის ზომები აღებატება
ობიექტის ზომებს. grid-ის გრაფიკული უჯრის ზომა თავის განისაზღვრება ყველაზე დიდი ზომის
გრაფიკული ობიექტით. grid მეთოდის stick პატამეტრი pack-მეთოდის anchor-პარამეტრის ანალოგიურია
და იგივე მნიშვნელობების მიღება შეუძლია. ქვევით მოყვანილია grid-მეთოდით გრაფიკული ობიექტების
განლაგების ორი მაგალითი.
L0.grid(padx=5, pady=5, sticky=W)
L1.grid(column=1, row=0, padx=5, pady=5)
L2.grid(column=0, row=1, padx=5, pady=5)
L3.grid(column=1, row=1, padx=5, pady=5)
პირველ მაგალიში 4 გრაფიკული ობიექტების განლაგენა ხდება რეგულარულ მესერზე, რომელიც grid-მეთოდი არის განსაზღვრული
და შედგება ერთეულოვანი სიდიდის მქონე 2 უჯრისგან როგორც ჰორიზონტალური ასევე ვერტიკალური მიმართულებით.
მეორე მაგალითში, რომელიც ქვევით არის მოყვანილი, მესერის პირველი უჯრის ზომა, რომელშიც ყველაზე დიდი ზომის
გრაფიკული ობიექტის მოთავსებული, როგორც ჰორიზონტალური ასევე ვერტიკალური მიმართულებით შეადგენს 2-ერთეულს.
მომდევნო სამი გრაფიკული ობიექტი, განლაგებულია ვერტიკალურად, რაც მესერის 2 უჯრას ( column=0, row=2) და
(column=1, row=2) ცარიელს ტოვემს. მოყვანილ მაგალითებში გამოყებებულია padx და pady პარამეტრები, რომლებსაც
grid-მეთოდში იგივე დანიშნულება აქვს, როგორც pack-მეთოდში.
L2.grid(column=0. row=0, columnspan=2, rowspan=2, padx=5, pady=5, sticky=N)
L0.grid(column=2, row=0, padx=5, pady=5, sticky=W)
L1.grid(column=2. row=1, padx=5, pady=5, sticky=E)
L3.grid(cplumn=2, row=2, padx=5, pady=5)
მოყვანილი მაგლითების შესაბამისი გრაფიკული გამოსახულებები მოყვანილია სურათებზე
სურათი ???
|
სურათი ???
|
პითონის tkinter-მოდულის widget-ის განხილვას ორი მსგავსი კლასის Frame და LabelFrame აღწერით გავაგრძელებთ.
მათი საშუალებით ხდება გრაფიკული ობიექტის(ფანჯრის) შექმნა, რომელიც სხვა widget-თვის მშობელ გრაფიკულ გამოსახულებას
წარმოადგენს. ამ ორ widget-ს მსგავსი პარამტრები აქვთ, რადგანავ განსხვავებას Frame და LabelFrame კლასებს შორის დიდი არ არის.
LabelFrame - ტიპის ობიეტს Frame-ისგან განასხვავებს სახელი, რომელიც Frame-ტიპის ობიექტებში განსაზღვრული არ არის.
ამ widget-ების განსაზღვრა შესაძლებელია შესაბამისად 18(Frame) და 24(Labelframe) პარამეტრით, რომელთა შორის დიდი ნაწილი უკვე
განხილულ პარამეტრებს წარმოადგენს. ქვევით მოყვანილია LabelFrame-ის გამოყენების მაგალითი.
.
from tkinter import *
w1=Tl()
W,H, BColor = 600, 400, 'yellow'
F = Frame(w1, width=W, height=H, bg=BColor)
F.pack()
BC, FC ="white", "red"
BC1, FC1 = "white", "Blue"
Lf1= LabelFrame(text=" LabelFrame 1 ", font=("Sylfaen",18), bg=BC, fg=FC, padx=5, pady=5)
Lf1.pack(padx=10, pady=10)
img1=PhotoImage(file="C:\\Users\\Rezo\\Desktop\\IOM_2\\IOM_Book\\web\\py5\\image\\Python_LOGO_200px.gif")
L0=Label(Lf1, image=img1, bg=BC)
L1=Label(Lf1, text=" programireba piTonze \n sawyisi kursi ", font=("LitNusx",22, "bold"), bg=BC, fg="Blue")
L2=Label(Lf1, text=" მოდული tkinter ", font=("Sylfaen",18), bg=BC, fg="Blue")
R1=400
Wgs=[ "Button ", "Checkbutton", "ListBox ", "Frame ", "Entry ",
"Label ", "LabelFrame ", "Menu ", "Message ", "Canvas ",
"Radiobutton ", "OptionMenu ", "Scaler ", "Scrollbar ", "SpinBox ",
"text " ]
Wgs.sort()
FS1=("Sylfaen",16)
M1 = Message(Lf1, text=Wgs[0], aspect=R1, font=FS1, bg=BC1, fg=FC)
M2 = Message(Lf1, text=Wgs[1], aspect=R1, font=FS1, bg=BC1, fg=FC)
M3 = Message(Lf1, text=Wgs[2], aspect=R1, font=FS1, bg=BC1, fg=FC)
M4 = Message(Lf1, text=Wgs[3], aspect=R1, font=FS1, bg=BC1, fg=FC)
M5 = Message(Lf1, text=Wgs[4], aspect=R1, font=FS1, bg=BC1, fg=FC)
M6 = Message(Lf1, text=Wgs[5], aspect=R1, font=FS1, bg=BC1, fg=FC)
M7 = Message(Lf1, text=Wgs[6], aspect=R1, font=FS1, bg=BC1, fg=FC)
M8 = Message(Lf1, text=Wgs[7], aspect=R1, font=FS1, bg=BC1, fg=FC)
M9 = Message(Lf1, text=Wgs[8], aspect=R1, font=FS1, bg=BC1, fg=FC)
M10=Message(Lf1, text=Wgs[9], aspect=R1, font=FS1, bg=BC1, fg=FC)
M11=Message(Lf1, text=Wgs[10], aspect=R1, font=FS1, bg=BC1, fg=FC)
M12=Message(Lf1, text=Wgs[11], aspect=R1, font=FS1, bg=BC1, fg=FC)
M13=Message(Lf1, text=Wgs[12], aspect=R1, font=FS1, bg=BC1, fg=FC)
M14=Message(Lf1, text=Wgs[13], aspect=R1, font=FS1, bg=BC1, fg=FC)
M15=Message(Lf1, text=Wgs[14], aspect=R1, font=FS1, bg=BC1, fg=FC)
M16=Message(Lf1, text=Wgs[15], aspect=R1, font=FS1, bg=BC1, fg=FC)
L0.grid(row=0, column=0, rowspan=3, columnspan=2, ipadx=5, ipady=5)
L1.grid(row=0, column=2, columnspan=2, padx=5, pady=5)
L2.grid(row=1, column=2, columnspan=2, padx=5, pady=5)
M1.grid(row=3, column=0, padx=5, pady=5)
M2.grid(row=3, column=1, padx=5, pady=5)
M3.grid(row=3, column=2, padx=5, pady=5)
M4.grid(row=3, column=3, padx=5, pady=5)
M5.grid(row=4, column=0, padx=5, pady=5)
M6.grid(row=4, column=1, padx=5, pady=5)
M7.grid(row=4, column=2, padx=5, pady=5)
M8.grid(row=4, column=3, padx=5, pady=5)
M9.grid( row=5, column=0, padx=5, pady=5)
M10.grid(row=5, column=1, padx=5, pady=5)
M11.grid(row=5, column=2, padx=5, pady=5)
M12.grid(row=5, column=3, padx=5, pady=5)
M13.grid(row=6, column=0, padx=5, pady=5)
M14.grid(row=6, column=1, padx=5, pady=5)
M15.grid(row=6, column=2, padx=5, pady=5)
M16.grid(row=6, column=3, padx=5, pady=5)
მოყვანილ მაგალითში LabelFrame ტიპის ობიექტი მშობელი ობიექტის როლს ასრულებს შვილობილი Label და Message ტიპის
ობიექტებისთვის. შვილობილი Label-ტიპის ობიექტებიდან ერთი გამოსახულებას შეიცავს, ხოლო Message-ტიპის ობიექტებს
tkinter-მოდულის widget-ების სახელები გრაფიკულ ფანჯარაში გამოყავს, სადაც მათი გეომეტრიული განლაგება განისაზღვება
grid-მეთოდით. მიღებული გრაფიკული გამოსახულება მოყვანილია შემდეგ სურათზე.
სურათი ???
აქამდე განხილული widget-ები ინფორმაციის გამოყვანასთან იყო დაკავშირებული.
მათ არ გააჩნიათ თვისებები, რომ რეაგირება მოახდინონ რაიმე შემთხვევაზე.
შემთხვევის (event) ქვეშ იგულისხმება რაიმე მოქმედება, მაგალითად კომპუტერის მაუსის მოძრაობა,
მაუსის ღილაკის დაჭერას ან კლავიატურიდან გარკვეული სიმბოლოს შეყვანა. პითონის tkinter-ში შესაძლებელია
ასეთი შემთხვევების განსაზღვრა და მათი დაკავშირება პროგრამის განსაზღვრულ ფუნქციასთან.
შემთხვევის განხორციელება იწვევს mainloop ციკლში მართვის გადაცემას ამ ფუნქციაზე.
შემთხვევებზე რეაგირება ინტერაქტული პროგრამების შექმნის (მაგალითად კომპუტერული თააშების)
საშუალებას იძლევა.
პითონის tkinter მოდულში ჩართულია Button კლასის widget, რომელიც გრაფიკული
ღილაკის დაპროგრამების საშუალებას იძლევა. კომპუტერის მაუსის კურსორის გრაფიკული ღილაკის ფანჯარაში
განლაგება და მაუსზე დაჭერა იწვევს მართვის გადაცემას წინასწარ განსაზღვრულ პითონის ფუნქციაზე. რომლის
მითითება command პარამეტრის საშუალებით ხდება. Button კლასი შეიძლება განვიხილოთ როგორც Label-ის
ანალოგიური კლასი, რომელსაც დამატებული აქვს შემთხვევაზე (მაუსის კლავიატურაზე დაჭერა) რეაგირების ფუნცია
და რამდენიმე დამატებითი პარამეტრი.
ქვემოთ მოყვანილია Button-ის გამოყენების მარტივი მაგალითი:
from tkinter import *
w1=Tk()
w1.config(bg="LightYellow")
ic=0
ivar, tvar =IntVar(), StringVar()
tvar.set(str(ic))
ivar.set(ic)
def callback():
ic=ivar.get()
ic +=1
ivar.set(ic)
s = str(ic)
tvar.set(s)
wl1=Label(w1, text=" Button widget ",
font=("Sylfaen",20,"bold"), bd=1, bg='lightyellow', fg='red',relief='flat', padx=30, pady=5)
wl2=Label(w1, text=" iTvlis mausze daWerebis ricxvs ",
font=("LitNusx",20,"bold"), bd=1, bg='lightyellow', fg='black',relief='flat', padx=30, pady=5)
wl3=Label(w1, textvariable=tvar,
font=("LitNusx",20,"bold"), bd=4, bg='white', fg='red',relief='ridge', padx=30, pady=5, width=20)
wb= Button(w1, text="Enter", font=("Sylfaen",12, "bold"), bd=10, bg='darkblue', fg='white',
relief='groove', overrelief="sunken", padx=5, pady=5,command=callback)
wl1.grid(padx=5, pady=5)
wl2.grid(column=1, row=0, padx=5, pady=5)
wl3.grid(column=1, row=1, padx=5, pady=5)
wb.grid(column=0, row=1, padx=10, pady=5 )
mainloop()
პირველ ინტერაქტულ მაგალითში, რომელსაც მოყვანილი პროგრამას წარმოადგენს, გამოყენებულია
ოთხი widget, რომელთგანაც სამი Label-ტიპის ობიექტია, ხოლო ერთი Button-ტიპის ობიექტი.
ამ პროგრამაში გამოყენებულია tkinter-კლასები IntVar და StringVar, რომელთა საშუალებით
ხდება იმ ცვლადების განსაზღვრა, რომლებიც widget-თან არის დაკავშირებული და mainloop-ციკლში იცვლებიან. მ
მათი საშუალებით ხდება გრაფიკული ობიექტების მოდიფიკაცია.
მათ შესახებ შემდეგ პარაგრაფში ვისაუბრებთ.
მოყვანილ მაგალითში wl3-გრაფიკული ობიექტის განსაზღვრაში გამოვიყენებულია პარამეტრი textvariable,
რომელიც განვსაზრცრეთ როგორც StringVar-ტიპის ობიექტი(tvar). მისი ცვლილება იწვევე wl3-გრაფიკული ობიექტის
ავტომატურ განახლებას. განახლება ხდება Button-ტიპის ობიექტთან დაკავშირებული შემთხვევის საშუალებით.
გრაფიკულ ღილაკზე ზემოქმედება (ე.ი. კომპუტერის მაუსის მის ფანჯარაში მოთავსება და მისი კლავიშის
დაჭერა) იწვევს მართვის გადაცემას პითონის callback-ფუნქციაზე, რომელიც ჩვენს მიერ არის განსაზღვრული.
ფუნქციას პითონის სინტაქსით დაშვებული ნებისმიერი სახელი შეიძლება ჰქონდეს.
ჩვენ მაგალითში IntVar-ტიპის ობიექტი, რომელიც ამ ფუნქციაში ცვლადია, გამოყენებულია როგორც მთვლელი.
მისი მნიშვნელობა tvar საშუალებით გადაევება Label ტიპის ობიექტს.
გრაფიკულ ღილაკზე ყოველი ზემოქმედება, ცვლის მთვლელის მნიშვნელობას, რომელიც თავის მხრივ
wl3-გრაფიკული ობიექტის გამოყვანილი სიდიდის ცვლილებას იწვევს.
მომდევნო სურათზე მოყვანილი ორი გრაფიკული გამოსახულება, რომელიც ამ პროგრამასთან არის დაკავშირებული.
მარცხენა გამოსახულებაში მაუსის კურსორი გრაფიკულ ღილაკის ფანჯარაშია მოთავსებული
(ყურადღება მიაქვიეთ ამ გრაფიკული ობიექტი რელიეფის ცვლილებას, რომელიც განისაზღვრება პარამეტრით
overrelief), ხოლო მეორე, მარჯვენა სურათზე, იგივე ფრაფიკული ობიექტი მაუსის კლავისაშე დაჭერის შემდეგ
არის ნაჩვენები. გრაფიკულ ღილაკზე ყოველი ყოველი დაჭერის შემდეგ wl3 ობიექტში მოთაცსებული მთვლელის
მნიშვნელობა ერთით იზრდება.
სურათი ???
|
სურათი ???
|
საჭიროა ორი მაგალითის მოყვანა ?
სკრიპტის მოყბანა
პითონის tkinter-მოდულში განსაზღვრულია კლასები BooleanVar, DoubleVar, IntVar და StringVar.
როგორც წინა მაგალითში ვნახეთ, ამ ტიპის ობიექტების საშუალებით ხდება widget-ის გამახლება გარკვეული შემთვევების
დროს. tkinter-მოდულში ეს კლასები გამოიყენება შესაბამისად ბულის, მცოცავი ფორმატის მქონე რიცხვის, მთელი რიცხვის
და სტრინგის ტიპის ცვლადებთან სამუშაოდ. ამ ტიპის ობიექტებისთვის მნიშვნელობის განსაზღვრა ხდება set-მეთოდით,
ხოლო get - მეთოდითც შესაძლებელია ამ მნიშვნელობის მიღება. ქვემოთ მოვანილია BooleanVar ტიპის
ობიექტის განსაზთვრის მაგალითი. ყურადღება მიაქციეთ, რომ ამ ტიპის ობიექტების განსაზღვრა და მათთან მუშაობას
შესაძლებელია tkinter-ის ძიროთადი Tk-კლასის ობიექტის განსაზღვრის შემდეგ.
>>>from tkinter import *
>>>w1=Tk()
>>>xb=BooleanVar()
>>>type(xb)
< class 'tkinter.BooleanVar' >
>>>print("xb value(default)=", xb.get())
xb value(default)= 0
>>>xb.set(True)
>>>print("xb new value =", xb.get())
xb new value = 1
ანალოგიურად ხდება DoubleVar() DoubleVar(), IntVar(), StringVar() კლასების გამოიყენება.
შემდეგ მაგალითში ნაჩვებებია ამ კლასის ობიექტების საწყისი მნიშვბელობები და ცვლადების
ტიპები, რომელსაც get-მეთოდი აბრუნებს.
>>>from tkinter import *
>>>w1=Tk()
>>> xd, xi, xs = DoubleVar(), IntVar(), StringVar()
>>>print( type(xd), type(xi), type(xs))
< class 'tkinter.DoubleVar' > < class 'tkinter.IntVar' > < class 'tkinter.StringVar' >
>>>print("default values: xd={0:}, xi={1:}, xs={2:}".format(xd.get(), xi.get(), xs.get()))
default values: xd=0.0, xi=0, xs=
>>>print(" type(xd.get())={0:}, type(xi.get())={1:}, type(xs.get())={2:}".format(type(xd.get()), type(xi.get()), type(xs.get())))
type(xd.get())= < class 'float' >, type(xi.get())= < class 'int' >, type(xs.get())= &kt class 'str' >
კომპუტერულ პროგრამებში ხშირად არის საჭირო გარკვეული სიმრავლიდან (მაგალითად მონაცემთა ბაზიდან)
ინფორმაციის არჩევა. პითონის tkinter-პროგრამებში ინფორმაციის არჩევასთანთან რამდენიმე widget დაკავშირებული,
მათ შორის Checkbutton და Radiobutton.
Radiobutton ტიპის ობიექტის იმ შემთხვევაში გამოიყენება, როდესაც რამდენიმე შესაძლებლობიდან ასარჩევია
მხოლოდ ერთი მნიშვნელობა. ამ ტიპის ობიექტის განსაზღვრისთვის გამოყენებული პარამეტრები ძირითადათ
Button-კლასში არსებული პარამეტრების ანალოგიურია. ახალი პარამეტრებს შორის, რომლებიც Radiobutton-კლასში
გამოიყენება, არის პარამეტრები value და variable. ერთ ჯგუფში გაერთიანებულ Radiobutton-ტიპის
ობიექტებს variable-პარამეტრს იგივე მნიშვნელობა უნდა უნდა ჰქონდეს (ეს პარამეტრი განსაზღვრავს ჯგუფს), ხოლო
value-პარამეტრი თვითოეული ობიექტისვის განსახვავებული (უნიკალური) უნდა იყოს.
ქვევით მოყვანილია Radiobutton-ის გამონების მარტივი მაგალითი.
from tkinter import *
w1=Tk()
Q = ["if a==b c=20.0", "def MyFunction:", "for i in range(10): ", "MyDict={'a'=1.2, 'b'=2.5, 'c'=4.9}" ]
def sel():
pass
def ButtonFunction():
w1.quit()
v, v1, v2, v3, v4 = IntVar(), IntVar(), IntVar(), IntVar(), IntVar()
f1=("LitNusx", 20)
f2=("Sylfaen", 20)
LText=" airCieT swori sintaqsuri Canaweri:"
L0 = Label(w1, anchor=W, text=LText, font=f1, bg='white', width=40)
BCol="LightYellow"
WR, PX = 35, 2
R1 = Radiobutton(w1, anchor=W, bg=BCol, text=Q[0], width=WR, variable=v, value=1, font=f2, padx=PX, command=sel)
R2 = Radiobutton(w1, anchor=W, bg=BCol, text=Q[1], width=WR, variable=v, value=2, font=f2, padx=PX, command=sel)
R3 = Radiobutton(w1, anchor=W, bg=BCol, text=Q[2], width=WR, variable=v, value=3, font=f2, padx=PX, command=sel)
R4 = Radiobutton(w1, anchor=W, bg=BCol, text=Q[3], width=WR, variable=v, value=4, font=f2, padx=PX, command=sel)
B0 = Button(w1, anchor=W, bg="PaleGreen", text="Enter", width=6, font=f2, padx=PX, command=ButtonFunction)
L0.pack(anchor = W)
R1.pack(anchor = W)
R2.pack(anchor = W)
R3.pack(anchor = W)
R4.pack(anchor = W)
B0.pack(anchor = W)
w1.mainloop()
w2=Tk()
A=v.get()
RR=3
LText1=" \n Tqveni arCevani: {} \n".format(A)
LText2=" \n swori debuleba: {} \n ".format(RR)
L1 = Label(w2, anchor=W, text=LText1, font=f1, bg='white', width=40)
L2 = Label(w2, anchor=W, text=LText2, font=f1, bg='white', width=40)
L2.pack()
L1.pack()
მოყვანილი მაგალითი, როგორც მისი გრაფიკული გამოსახულებიდან სჩანს (იხილე მომდევნო სურათი)
წარმოადგენს მარტივ ტესტ-პროგრამას, სადაც Radiobutton- ობიქტების საშუალებით წარმოდგენილია
პითონის ოთხი დებულება, რომელთაგან შეირჩეს ერთი სწორი სინტაქსურ ჩანაწერი.
არჩევა ხდება გრაფიკულ ობიექტთან დაკავშირებული წრიული არის მონიშვნით კომპუტერის მაუსის საშუალებით.
ყურადღება მიაქციეთ, რომ ამ widget-ით მხოლოდ ერთი დებულების მონიშვნა შეიძლება.
შერჩევის წინ ერთი ჯგუფში გაერთიანებული Radiobutton-ის ტიპის ობიექტების მნიშვნელობა (ჯგუფის მნიშვნელობა)
განსაზღვრულია ერთიანდებიან variable-პარამეტრის მნიშვნელობით, IntVar-ტიპის v-ცვლადია.
დებულების არჩევის შემდეგ v-ცვლადი იღებს შერეული გრაფიკული ობიექტის value-პარამეტრით
განსაზღვრულ მნიშვნელობას. მოყვანილ მაგალითში არჩევა გულისხმობს შესაბამისი Radiobutton ობიექტის
მონიშვნას და შემდეგ Button-ით შეყვანას (ეს ობიექტი აღნიშნულია სახელით Enter).
|
|
| სურათი | სურათი |
მომდევნო სურათი ?? მიღებულია მსგავსი სკრიპტის შესრულების შედეგად. წინა მაგალითისგან განსხვავევით
აქ დამატებულია ერთი Label-კლასის ობიექტი, რომელშიც ჩასმულია პითონის გრაფიკული ლოგო.
კიდევ ერთ განსხვავება დაკავშირებულია grid - გეომეტრიული მენეჯერების გამოყენებასთან. მოყვანილ
მაგალითებზე დაყრდნიბით ამ გამოსახულების შესაბამის სკრიპტის შედგენა რთულუ არ უნდა იყოს
და კარგ სავარჯიშოს წარმოადგენს.
Radiobutton-ის ტიპის ობიექტებში ტექსტის ნაცვლად შესაძლებელია ასევე გრაფიკული გამოსახულების ჩასმა.
გრაფიკის ხმარება აქაც სხვა widget-ების ანალოგიურად ხდება (იხილე მაგალირად Label). სურათების ხმარება
ხშირად უფრო თვალსაჩინოს ხდის ტესტებს, რომელთა შესადგენად Radiobutton-ტიპის ობიექტები ხშირად გამოიტენება.
ქვემოთ მოყვანილ 2 სურათში, მოყვანილია ცნობილი ფიზიკური ფორმულა და ოთხი ფიზიკოსის სურათი,
რომელთაგანაც ერთ-ერთმა ის ფიზიკური კანონი დაადგინა, რომელიც მოცემული ფორმულით აღიწერება.
ყურადღება მიაქვიეთ, რომ ამ მაგალითში Radiobutton-ტიპის ობიექტები ჰორიზინტალურად არის განლაგებული.
|
|
| სურათი | სურათი |
ამ პარაგრაფის მეორე, Checkbutton კლასის widget-ს ასევე ინფორმაციის შერჩევისთვის გამოიყენება.
Radiobutton-ისგან განსხვავებით, სადაც ჯგუფიდან ხდება ერთი ობიექტის არჩევა, Checkbutton-ტიპის
ობიექტები არ ერთიანდებია ჯგუფში და მათ ორი შესაძლო მნიშვნელობიდან (0 და 1) ერთ-ერთის მიღება შეუძლიათ.
checkbuton-თან დაკავშირებული გრაფიკული უჯრის მონიშვნის შემთხვევაში, ამ ობიექტთან დაკავშირებული ცვლადის
მნიშვმელობა ხდება 1, წინაამდეგ შემთხვევაში კი ეს მნიშვნელობა არის 0.
offvalue
The value corresponding to a non-checked button. The default is 0. (offValue/Value)
onvalue
The value corresponding to a checked button. The default is 1. (onValue/Value)
ქვევით მოყვანილია Checkbutton ტიპის ობიექტების გამოყენების მაგალითი. ამ მაგალითში
თოთიოეულ ობიექტთან დაკავშირებულია პროგრამირების ენა. რადგან ეს ობიექტები
Checkbutton-ტიპის ობიექტებს მიეკუთვნებიან, შესაძლებელია ნებისმიერი რაოდენობის
ობიექტი მოინიშნოს, მათ შორის არც-ერთი ან ყველა.
from tkinter import *
w1=Tk()
cv1, cv2, cv3, cv4, cv5 = IntVar(), IntVar(), IntVar(), IntVar(), IntVar()
CP=["C++", "Fortran", "Java", "PHP", "Python"]
def ButtonFunction():
Bset=(cv1.get(), cv2.get(), cv3.get(), cv4.get(), cv5.get())
w1.quit()
return Bset
f1=("LitNusx", 20)
f2=("Sylfaen", 20)
LText=" komputeruli programirebis ena:"
L0 = Label(w1, anchor=W, text=LText, font=f1, bg='white', width=40)
BCol="LightYellow"
WR, PX = 35, 2
CB1 = Checkbutton(w1, anchor=W, bg=BCol, text=CP[0], width=WR, variable=cv1, font=f2, padx=PX )
CB2 = Checkbutton(w1, anchor=W, bg=BCol, text=CP[1], width=WR, variable=cv2, font=f2, padx=PX )
CB3 = Checkbutton(w1, anchor=W, bg=BCol, text=CP[2], width=WR, variable=cv3, font=f2, padx=PX )
CB4 = Checkbutton(w1, anchor=W, bg=BCol, text=CP[3], width=WR, variable=cv4, font=f2, padx=PX )
CB5 = Checkbutton(w1, anchor=W, bg=BCol, text=CP[4], width=WR, variable=cv5, font=f2, padx=PX )
B0 = Button(w1, anchor=W, bg="PaleGreen", text="Enter", width=6, font=f2, padx=PX, command=ButtonFunction)
L0.pack(anchor = W)
CB1.pack(anchor = W)
CB2.pack(anchor = W)
CB3.pack(anchor = W)
CB4.pack(anchor = W)
CB5.pack(anchor = W)
B0.pack(anchor = W)
w1.mainloop()
print(" Selected values=", ButtonFunction())
გრაფიკული ფანჯარა, რომელიც ზემოთ მოყვანილი სკრიპტით შეიქმნა, ნაჩვენებია შემდეგ სურათზე:
|
|
| სურათი | სურათი |
ქვევით მოყვანილია მაგალითში Checkbutton-ტიპის ობიექტები ჰორიზონტალურად არიან განლაგებული. ამ გრაფიკული
გამოსახულების მიღება, ისევე როგორც Radiobutton-ის შემთვევაში შეიძლება განვიხილოთ როგორც სავარჯიშო.
მნიშვნელობის შერჩევა წინასწარ განსაზღვრული სიიდან შესაძლებელია ასევე OptionMenu-ს
ტიპის ობიექტების საშუალებით. მსგავსი ტიპის widget ხშირად გამოიყენება ინტერნეტის პროგრამებში,
მნიშვნელობის შერჩევა სიიდან. ასეთი სია შეიძლება იყოს ქვეყნების ჩამონათვალი, რიცხვითი
მნიშვნელობები და ა.შ.
მოყვანილია მაგალითში, სია წარმოადგენს სადაც ხდება დაბადების წლის შერჩევა სკოლის მოსწავლეებისათვის.
from tkinter import *
w1= Tk()
w1.config(bg="LightYellow")
Stext = StringVar()
Stext.set(" ")
def ScFunction1(x) :
Stext.set(str(x))
return x
Stitle = " Scale-ტიპის გრაფიკული ობიექტის გამოყენების მაგალითი"
L0 = Label(w1,font=("Sylfaen",18), bg="LightYellow", text=Stitle)
S1 = Scale(w1, from_=0, to=255, orient=HORIZONTAL, resolution=0.5, length=800, width=15,
bg="white", bd=3, font=("Sylfaen",10), tickinterval=15, command=ScFunction1)
L1 = Label(w1,font=("Sylfaen",18), bg="White", width=6, relief = SUNKEN, bd=4, textvariable=Stext)
L0.grid(row=0,column=0, columnspan=2, stick=N, padx=10, pady=10)
S1.grid(row=1,column=0, stick=W,padx=5,pady=5)
L1.grid(row=1,column=1, stick=E,padx=10)
mainloop()
სურათის აღწერა ?
|
|
| სურათი | სურათი |
მოყვანილი მაგალითის მოკლე აღწერა.
პითონის tkiner-ში არსებობს კიდევ ერთი widget-ი, რომელიც ინფორმაციის გრაფიკული შეყვანისთვის გამოიყენება და
რომელიც Scale ტიპის ობიექტით განისაზვრება. ამ widget-ს შეესაბამება გრაფიკული სკალა,
რომლის მნიშვნელობები განსაზღვრულია წინასწარ შერჩეულ ინტერვალში, მინიმალურიდან(from_) მაქსიმალურ
(to მნიშვნელობამდე. სკალის ორ მომდევნო მნიშვნელობა ერთმანეთისგან განსხვავდება სიდიდით, რომელსაც სკალის
გარჩევისუნარიანობა ეწოდება. სკალის გარჩევისუნარიანობა განასაზღვრება პარამეტრებით resolution. ობიექტის
სკალაზე დანაყოფების ინტერვალი განისაზღვრება პარამეტრით tickinterval. ამ ობიექტთან command პარამეტრის
საშუალებით დაკავშირებულია პითმის ფუნქცია, რომლის პარამეტრია შკალის მიმდეინარე მნიშვნელობის შესაბამისი
ტექსტური ცვლადი. მიმდინარე მნიშვნელობა (რიცხვი) სკალაზე შეირჩევა კურსორის შესაბამის პოზიცია მოთავსებით.
სკალის განლაგება (ორიენტაცია) განისაზღვრება პარამეტრი orient, რომელსაც ორი მნიშვნელობა (ჰორიზონტალური ან
ვერტიკალური) შეიძლება ჰქონდეს. საწყის (default) განლაგებას წარმოადგენს ვერტიკალური განლაგება.
ქვემოთ ნაჩვენებია ამ Scale-ტიპის ობიექტის გამოყენების მაგალითი.
from tkinter import *
w1= Tk()
w1.config(bg="LightYellow")
Stext = StringVar()
Stext.set(" ")
def ScFunction1(x) :
Stext.set(str(x))
Stitle = " Scale-ტიპის გრაფიკული ობიექტის გამოყენების მაგალითი"
L0 = Label(w1,font=("Sylfaen",18), bg="LightYellow", text=Stitle)
S1 = Scale(w1, from_=0, to=255, orient=HORIZONTAL, resolution=0.5, length=800, width=15,
bg="white", bd=3, font=("Sylfaen",10), tickinterval=15, command=ScFunction1)
L1 = Label(w1,font=("Sylfaen",18), bg="White", width=6, relief = SUNKEN, bd=4, textvariable=Stext)
L0.grid(row=0,column=0, columnspan=2, stick=N, padx=10, pady=10)
S1.grid(row=1,column=0, stick=W,padx=5,pady=5)
L1.grid(row=1,column=1, stick=E,padx=10)
mainloop()
მოყვნილ სკრიპტს შეესაბამება გამოსახულება, რომელიც მოცემულია მომდევნო სურათზე.
როგორც სურათიდან სჩანს, scale ობიექტის გრაფიკული სკალა განსაზღვრულია 0 და 255-მდე ინტერვალში.
იმ შემთხვევაში, როდესაც სკალის ინტერვალი მითითებული არ არის, გამოიყენება საწყისი მნიშვნელობები
რომლებიც 0-100 ინტერვალს შეესაბამება. მოცემული სკალის გარჩევისუბარიანობის მნიშვნელობაა 0.5, რაც ნიშნავს, რომ
შესაძლებელია რიცხვების შერჩევა 0.5 ბიჯით, ე.ი, 0.0, 0.5, 1.0, 1.5 და ა.შ. 255.0 -მდე.
ობიექტის მიმდინარე მნიშვნელობა, რომელიც შეესაბამება სკალაზე კურსორის პოზიციას, გრაფიკულ გამოსახულებაზე
გამოყვანილია Label-ტიპის ობიექტის საშუალებით. მაგალითში სკალის ორიენტაცია განსაზღვრულია, როგორც
ჰორიზონტალური.
პითონის tkinter-მოდულის გრაფიკული widget-ები Radiobutton, Checkbutton და Scale, რომლებიც
წინა პარაგრაფებში განვიხილეთ, ინფორმაციის შერჩევის საშუალებას იძლევა წინასაწარ განსაზღვრული
სიიდან ან რიცხვითი ინტერვალიდან. პითონის პროგრამაში ინფორმაციის შეყვანა, რა თქმა უნდა, არ ამოიწურება
მხოლოდ შერჩევით და ახალი ობიექტების შეყვანასაც გულისხმობს. Entry კლასის widget სწორედ ამისთვის
არი განკუთვნილი და პროგრამაში ტექსტური ინფორმაციის (სტრინგის) შეყვანის საშუალებას გვაძლევს.
ახალი ტექსტური ობიექტის შეყვანა კომპუტერის კლავიატურიდან ხდება. Entry-ტიპის გრაფიკული ობიექტები,
როგორც წესი, გამოიყენება დიალოგურ რეჟიმში, როდესაც საჭიროა გარკვეული ტიპის ინფორმაციის
შეყვანა. ხშირად დიალოგური პროგრამები გამოიყენება პერსონალური ინფორმაციის შესაყვანად.
ასეთი პროგრამის მარტივი მაგალითა წარმაოდეგენს ქვევით მოყვანილი პროგრამა.
from tkinter import *
w1=Tk()
w1.config(bg="LightGray") # Gray")
v1, v2, v3 = StringVar(), StringVar(), StringVar()
vr = StringVar()
def Do1():
v123=" " + v1.get()+" "+v2.get()
vr.set(v123)
v1.set("")
v2.set("")
v3.set("")
fsize1, fsize2=18, 16
LW, LW1, EW2 = 40, 12, 30
gText1 = " Tqveni monacemebi"
L0=Label(w1,text=gText1, bg="white", font=("LitNusx", fsize1), widt=LW, pady=1)
L1=Label(w1, text=" saxeli: ", anchor="w", font=("LitNusx", fsize2), bg="white", width=LW1, padx=5 )
L2=Label(w1, text=" gvari: ", anchor="w", font=("LitNusx", fsize2), bg="white", width=LW1, padx=5 )
L3=Label(w1, text=" el. fosta: ", anchor="w", font=("LitNusx", fsize2), bg="white", width=LW1, padx=5 )
L3=Label(w1, text=" el. fosta: ", anchor="w", font=("LitNusx", fsize2), bg="white", width=LW1, padx=5 )
L4=Label(w1, textvariable=vr, anchor="w", font=("Litnusx", (fsize2-2)), bg="white", width=LW, padx=1 )
E1 = Entry(w1, font=("Sylfaen", fsize2), width=EW2, textvariable=v1 )
E2 = Entry(w1, font=("Sylfaen", fsize2), width=EW2, textvariable=v2 )
E3 = Entry(w1, font=("Sylfaen", fsize2), width=EW2, show="*", textvariable=v3 )
B1 = Button(w1, bg="DarkBlue", text="Enter", bd=6, relief=RAISED, font=("Sylfaen", 10), fg="white", command=Do1)
L0.grid(row=0, column=0, columnspan=3,padx=2)
L1.grid(row=1, column=0, columnspan=2, sticky="w" )
L2.grid(row=2, column=0, columnspan=2, sticky="w" )
L3.grid(row=3, column=0, columnspan=2, sticky="w" )
E1.grid(row=1, column=2, sticky="e", padx=5, pady=2 )
E2.grid(row=2, column=2, sticky="e", padx=5, pady=2 )
E3.grid(row=3, column=2, sticky="e", padx=5, pady=2 )
B1.grid(row=4, sticky="w", padx=2, pady=2)
L4.grid(row=4, column=1, columnspan=2, padx=2)
mainloop()
მოყვანილ პროგრამაში Entry-ობიეტი ქმნის გრაფიკულ არეს, რომელშიც შეგვიძლია ავკრიბოთ ტექსტი კლავიატურიდან.
ამ არეს წინ უძღვის ინფორმაცია, თუ რა სახის ინფორმაცია უნდა ჩაიწერის მასში. ამ ინფორმაციის გამოყვანა
Label ტიპის ობიექტის საშულებით ხდება. პროგრამაშის 3 არეა, რომელიც Entry-ის საშუალებით შეიქმნა, შესაბამისად
მათ წინ 3 Label-ობიქტია განლაგებული. ამ პროგრამის შესრულების შედეგები ნაჩვენებია მომდევნო სურათზე.
მარცხენა სურათზე მოცემულიგრაფიკული გამოსახულენა შეესაბამება Button-ღილაკის დაჭერამდე შექვანილ
ინფორმაციას. ყურადღება მიაქციეთ, რომ ელექტრონული ფოსტის სახელი ფიფქისსიმბოლობით(*) არის
დაფარული. ამის საშუალებას იძლევა show პარამეტრში. ამ პარამეტრის საშუალებით შესაძლენელია
კლავიატურიდან შეყვანილი სიმბილოების დაფარვა.
მარჯვნივ მოყვანილი სურათი, შეესაბამება Button-ღილაკის დაჭერის შემდეგ მიღებულ გამოსახელებას.
ღილაკის დაჭერის შემდეგ ხდება Entry-ობიქტებში არსებული ტექსტის გადაწერა და შესაბამის ტექსტური
ცვლადების საწყის მდგომრეობაში დაბრუნება. შეყვანილი სახელი და გვარი იბეჭდება გრაფიკულ არეშიმ
რომელიც Label-ტიპის ობიექტს წარმოადგენს. მოცენული მდგომარეობიდან შესაძლებელია პროგრამაში
ახალი მონაცემების შეყვანა. Entry და Label ობიექტებს შორის კავშირი ხორციელდება
StringVar - ტიპის ობიექტების საშუალებით, რომლებიც tkintet-ში ტექსტური ცვლადებთან (სტრინგებთან)
სამუშაოდ გამოიყენება.
|
|
ინფორმაციის შეყვანის დროს, როგორც უკვე ავღნიშნეთ, შეიძლება სხვა widget-ების, მაგალითად OptionMenu-ტიპის
ობიქტის გამოყენება. როგორც ვნახეთ, ეს გრაფიკული ობიექტი დაკაშირებულია პითონის list ან tuple-ის ტიპის ცვლადთან
და საშუალებას იძლევა სიმრავლიდან ერთი ელემენტი შეირჩეს. ინფორმაციის შერჩევითი შეყვანა შეილება ასევე
spinbox-ტიპის ობიექტით ანუ widget-ით. ამ ტიპის ობიექტისთვისაც წინასწარ უნდა განისაზღვროს list ან tuple
ტიპის ცვლადი, რომელიც widget-ს პარამეტრ values საშულებით უკავშირდება. spinbox-ის ტიპის ობიექტის
გრაფიკული ფანჯარა Entry-ის ანალოგიურია, იმ განსახვავებით რომ მასში უკვე მოთავსებულია სიმრავლის
ერთი ელემენტი. სხვა ელემეტის არჩევა ხდება spinbox-გრაფიკულ ფანჯარასთან დაკავშირებული ისრებით, რომლებიც
მიმდევრობის ელემენტის არჩების საშუალებას იძლევა. ქვევით მოყვანილია ამ ობიექტის ხმარების მაგალითი:
from Tkinter import *
w1=Tk()
month=["იანვარი", "თებერვალი", "მარტი", "აპრილი", "მაისი", "ივნისი", "ივლისი", "აგვისტო", "სექტემბერი", "ოქტომბერი", "ნოემბერი", "დეკემბერი"]
year=list(range(1900,2015))
day=list(range(1,31))
SBD1=Spinbox(w1, values=day, font=("Sylfaen", 12), width= 3)
SBD2=Spinbox(w1, values=month, font=("Sylfaen", 12), width=12)
SBD3=Spinbox(w1, values=year, font=("Sylfaen", 12), width= 4)
მოყვანილი ფრაგნენტი გამოყენებულია პროგრამაში, რომის შესაბამისი გრაფიკული გამოსახულება მოყვანილია
სურათზე. პროგრამის დანიშნულებას ანკეტური მონაცემემების შეყვანა წარმოადგენს.
სურათი ???
პითონის tkinter მოდულში ინფორმაციის შეყვანის განხილულ საშუალებებთან ერთად არსებობს კიდევ ერთი, კეროდ
Listbox-კლასი, რომელიც ინფორმაციის შერჩევისთვის გამოიყენება. ამ ტიპის გრაფიკული ობიექტის ფუნქციები
გარკეულად წილად OptionMenu და Spinbox ფუნქციების ანალოგიურია, რის გამოც ამ widget-ის აღწერაზე აღარ შევჩერდებით.
ამ widget-ის შესახებ, რომელიც გამოიყენება სხვა გრაფიკილ კლასებში და ფანჯარაში ინფორმაციის
დინამიური განთავსების საშუალებას იძლევა. გამიყენება:
