Sunday, July 8, 2012

5. ചിത്രപ്രദര്‍ശനം

ജി.ടി.കെ. ഇമേജ് കൊണ്ടുള്ള ഒരുദാഹരണം:

#! /usr/bin/env python
import gtk

wnd=gtk.Window()
img=gtk.Image()
wnd.set_title("GTK Image Example 1")
wnd.set_size_request(400,250)
wnd.connect("destroy",gtk.main_quit)
img.set_from_file("/usr/share/pixmaps/gdm-foot-logo.png")
wnd.add(img)
wnd.show_all()

gtk.main()

Sunday, July 1, 2012

4. മെസ്സേജ് ഡയലോഗുകള്‍

മെസ്സേജ് ഡയലോഗുകളെ പരിചയപ്പെടാനുള്ള പ്രോഗ്രാം നല്‍കുന്നു. ഈ പ്രോഗ്രാം ടെര്‍മിനലില്‍ത്തന്നെ റണ്‍ ചെയ്യിയ്ക്കുക. എങ്കില്‍ ഏത് ബട്ടണ്‍ ഞക്കിയെന്ന വിവരം പ്രിന്റ് ചെയ്ത് കിട്ടും. gtk.BUTTONS_OK_CANCEL എന്നതിന് പകരം gtk.BUTTONS_NONE, gtk.BUTTONS_OK എന്നിവ പരീക്ഷിയ്ക്കുക. gtk.MESSAGE_INFO എന്നതിന് പകരം gtk.MESSAGE_WARNING, gtk.MESSAGE_QUESTION, gtk.MESSAGE_ERROR എന്നിവ പരീക്ഷിയ്ക്കുക.

#! /usr/bin/env python
import gtk

def show_msg(widget):
 md=gtk.MessageDialog(parent=wnd,type=gtk.MESSAGE_INFO,buttons=gtk.BUTTONS_OK_CANCEL)
 md.set_title("Message")
 md.set_markup("This is a <i>simple</i> <b>message box</b>.")
 returnval=md.run()
 md.destroy()
 print returnval

wnd=gtk.Window()
btn=gtk.Button("Message Dialog")
wnd.set_title("Message Dialogs")
wnd.connect("destroy",gtk.main_quit)
btn.connect("clicked",show_msg)
wnd.add(btn)
wnd.show_all()

gtk.main()

Sunday, June 24, 2012

3. ബട്ടണ്‍ ഞക്കിക്കളിയ്ക്കാം 2

വളാഞ്ചേരി ഉണ്ണിക്കൃഷ്ണന്‍ മാഷിന്റെ ഇ-മെയില്‍ നോക്കൂ:
നന്ദകുമാര്‍ ,
ഞാന്‍  ഉണ്ടാക്കിയ ഗെയിം ജിട്ടികെ യില്‍ എങ്ങനെ ചെയ്യും?
ബട്ടനുകള്‍ ഉണ്ടാക്കണം. പിന്നെ ഒരു ബട്ടണ്‍ ക്ലിക്ക് ചെയ്യുമ്പോല്‍ അതിലെ ലേബലിന്റെ വില എങ്ങനെ ഒരു ഫ്ങഷനിലേക്ക് അയയ്ക്കും? അതായത്  കാല്‍കുലേറ്ററില്‍ 1 ക്ലിക്ക് ചെയ്യുമ്പോള്‍ ആദ്യം ഉള്ള വില+ഇപ്പോള്‍ ക്ലിക്ക് ചെയ്ത ബട്ടനിന്റെ ലേബലിന്റെ വില.  അപ്പോള്‍ എല്ലാ ബട്ടണിനും ഒരു ഫങ്ഷ്ന്‍ മതിയല്ലോ.
മാഷ് ചോദിച്ചത് ഇതാണ്: ഓരോ അക്കത്തിനും ഓരോ ബട്ടണും ഓരോ ഫങ്ഷനും കൊടുത്താല്‍ ഒരു കാല്‍ക്കുലേറ്റര്‍ എളുപ്പമുണ്ടാക്കാം. എന്നാല്‍ ഒരൊറ്റ ഫങ്ഷന്‍ എഴുതണം. ഏല്ലാ ബട്ടണും അങ്ങോട്ട് കണക്ഷന്‍ കൊടുക്കണം. ബട്ടന്റെ വിലയ്ക്കനുസരിച്ച് ഫങ്ഷന്‍ പെരുമാറണം.
നമുക്ക് നോക്കാം.
കഴിഞ്ഞ പാഠത്തിലെ ബട്ടണ്‍ ക്ലിക്കിന്റെ ഫങ്ഷന്‍ ശ്രദ്ധിച്ചുകാണുമല്ലോ:
def run_calc(widget):
ഇതിലെ widget എന്നത് ക്ലിക്ക് ചെയ്യപ്പെട്ട ബട്ടണാണ്. എല്ലാ ബട്ടണും കണക്ഷന്‍ def btn_clicked(widget) എന്ന ഫങ്ഷനിലേയ്ക്ക് കൊടുത്തുവെന്ന് വയ്ക്കുക. btn1 എന്ന ബട്ടണ്‍ ക്ലിക്ക് ചെയ്താല്‍ ഈ ഫങ്ഷന്‍ സജീവമാകും. widgetന്റെ വില btn1 എന്നാകും. btn2 എന്ന ബട്ടണ്‍ ക്ലിക്ക് ചെയ്താല്‍ ഈ ഫങ്ഷന്‍ സജീവമാകും. widgetന്റെ വില btn2 എന്നാകും. അങ്ങനെയങ്ങനെ.
ഇനി ഇതുവച്ചൊരു പ്രോഗ്രാം (കാല്ക്കുലേറ്റര്‍ പിന്നെ):

#! /usr/bin/env python

import gtk

def btn_clicked(widget):
    lbl.set_label("Value = "+widget.get_label())

w=gtk.Window()
vbox=gtk.VBox()
btn1=gtk.Button("1")
btn2=gtk.Button("2")
lbl=gtk.Label()

w.connect("destroy",gtk.main_quit)
btn1.connect("clicked",btn_clicked)
btn2.connect("clicked",btn_clicked)

vbox.add(btn1)
vbox.add(btn2)
vbox.add(lbl)
w.add(vbox)

w.show_all()
gtk.main()

Sunday, June 17, 2012

3. ബട്ടണ്‍ ഞക്കിക്കളിയ്ക്കാം 1

3. ബട്ടണ്‍ ഞക്കിക്കളിയ്ക്കാം 1
ഒരു ബട്ടണ്‍ അമര്‍ത്തുമ്പോള്‍ കാല്‍ക്കുലേറ്റര്‍ തുറന്നുവരാനുള്ള പ്രോഗ്രാമാണ് ഇത്തവണ. ബട്ടണ്‍ നിര്‍മ്മാണം, കണക്ഷന്‍, കമാന്റൂകള്‍ പ്രവര്‍ത്തിപ്പിയ്ക്കല്‍ എന്നീ കഴിവുകള്‍ ലളിതമായ ഈ ഉദാഹരണത്തിലൂടെ നാം നേടിയെടുക്കുന്നു.

#! /usr/bin/env python

import gtk,os

def run_calc(widget):
    os.system("gcalctool") # execute the shell command 'gcalctool'

w=gtk.Window()
btn=gtk.Button("Run GCalctool by executing shell command")

w.set_title("GTK Button and Run Calculator")
w.connect("destroy",gtk.main_quit)
btn.connect("clicked",run_calc)
w.add(btn)

w.show_all()
gtk.main()

Wednesday, June 13, 2012

2.2. ജാലകം തുറക്കാം... വിഡ്ജറ്റുകള്‍ ചേര്‍ക്കാം! 2

കഴിഞ്ഞ അദ്ധ്യായത്തില്‍ നാം ഒരു ലേബല്‍ ഉണ്ടാക്കിയപ്പോള്‍ വളാഞ്ചേരി ഉണ്ണിക്കൃഷ്ണന്‍മാഷ് രണ്ട് ലേബലുണ്ടാക്കി നോക്കി. പക്ഷേ ജാലകം ഒരു സമയം ഒരു ലേബലേ അനുവദിച്ചുള്ളൂ. അത്രയേ അനുവദിയ്ക്കൂ. ഒരു ജാലകത്തില്‍ ഒന്നിലധികം വിഡ്ജറ്റ് ചേര്‍ക്കാന്‍ ഒന്നിലധികം വിഡ്ജറ്റുകളെ ഉള്‍ക്കൊള്ളാന്‍ സാധിയ്ക്കുന്ന കണ്ടെയ്നറുകളുടെ സഹായം വേണം. GTKVBox, GTKHBox, GTKLayout, GTKFixed എന്നിവയാണ് ഈ ആവശ്യത്തിനുള്ള പ്രധാന കണ്ടെയ്നറുകള്‍. അടിസ്ഥാനപരമായി ഇവയും വിഡ്ജറ്റുകള്‍ തന്നെ.

GTKVBox

വിഡ്ജറ്റുകളെ കുത്തനെ ക്രമീകരിയ്ക്കാന്‍. ഇതിന്റെ വലിപ്പം മാറിയാല്‍(ഉദാ: ജാലകം റീസൈസ് ചെയ്താല്‍) ഇതിനുള്ളിലെ വിഡ്ജറ്റുകളുടെ വലിപ്പവും തന്നത്താന്‍ മാറും. മാറണ്ടെങ്കില്‍ അങ്ങനെ കൊടുക്കുകയുമാവാം.

GTKHBox
വിഡ്ജറ്റുകളെ വിലങ്ങനെ ക്രമീകരിയ്ക്കാന്‍. ഇതിന്റെയും വലിപ്പം മാറിയാല്‍(ഉദാ: ജാലകം റീസൈസ് ചെയ്താല്‍) ഇതിനുള്ളിലെ വിഡ്ജറ്റുകളുടെ വലിപ്പവും തന്നത്താന്‍ മാറും. മാറണ്ടെങ്കില്‍ അങ്ങനെ കൊടുക്കുകയുമാവാം.

GTKLayout, GTKFixed
ഇവയില്‍ x,y,width,height എന്നിവ വച്ച് വിഡ്ജറ്റുകള്‍ ചേര്‍ക്കാം. വലിപ്പം തന്നത്താന്‍ മാറില്ല(മൈക്രോസോഫ്റ്റ് വിഷ്വല്‍ ബേസിക്കിലേതുപോലെ).

നാം ഇത്തവണ രണ്ട് ലേബലുണ്ടാക്കുന്നു. അവയെ ഒരു VBoxലേയ്ക്കിട്ട ശേഷം നെ ജാലകത്തിലുള്‍പ്പെടുത്തുന്നു.

2.2.1. VBox:


#! /usr/bin/env python

import gtk

w=gtk.Window()
vbox=gtk.VBox()
l1=gtk.Label()
l2=gtk.Label()

w.set_title("Adding Multiple Widgets in GTKVBox")
w.set_size_request(400,100)
l1.set_label("This is the 1st Label Inside GTKVBox")
l2.set_label("This is the 2nd Label Inside GTKVBox")
w.connect("destroy",gtk.main_quit)

vbox.add(l1) # Add Label1 to the VBox
vbox.add(l2) # Add Label2 to the VBox under Label1
w.add(vbox) # Add VBox to the Window
w.show_all()

gtk.main()


2.2.2. VBoxഉം HBoxഉം ചേര്‍ത്തുപയോഗിയ്ക്കാം:


#! /usr/bin/env python

import gtk

w=gtk.Window()
vbox=gtk.VBox()
hbox=gtk.HBox()
l1=gtk.Label()
l2=gtk.Label()
entry=gtk.Entry()

w.set_title("Adding Multiple Widgets in GTKVBox")
w.set_size_request(600,-1)
l1.set_label("This is the 1st Label Inside GTKVBox")
l2.set_label("This is the 2nd Label Inside GTKHBox")
entry.set_text("This is the Entry Inside GTKHBox")
w.connect("destroy",gtk.main_quit)

hbox.add(l2)
hbox.add(entry)
vbox.add(l1) # Add Label1 to the VBox
vbox.add(hbox) # Add HBox to the VBox under Label1
w.add(vbox) # Add VBox to the Window
w.show_all()

gtk.main()

w.set_size_request(600,-1) എന്നതുകൊണ്ട് 600 നീളവും ഡിഫാള്‍ട്ട് ഉയരവുമാണ് ഉദ്ദേശിയ്ക്കുന്നതെന്ന് പ്രത്യേകം പറയേണ്ടതില്ലല്ലോ.

Sunday, June 10, 2012

2.1. ജാലകം തുറക്കാം... വിഡ്ജറ്റുകള്‍ ചേര്‍ക്കാം!

കഴിഞ്ഞ അദ്ധ്യായത്തില്‍ നാം ജാലകമുണ്ടാകാന്‍(GTKWindow) പഠിച്ചു. ജാലകമുണ്ടായാല്‍പ്പോരാ, തുറക്കാനാവണം. തുറക്കാനായല്‍പ്പോരാ, കാഴ്ച്ചകള്‍ കാണണം. കാഴ്ച്ചകള്‍ കണ്ടാല്‍പ്പോരാ, വഴിയേ പോകുന്ന കൂട്ടുകാരെ മാടിവിളിയ്ക്കാനാവണം. ജാലകനിര്‍മ്മാണം, കണ്ടെയ്നര്‍ നിര്‍മ്മാണം, വിഡ്ജറ്റുകള്‍ ചേര്‍ക്കല്‍, കണക്ഷന്‍ നല്കല്‍ എന്നിവയെപ്പറ്റിയാണ് പറഞ്ഞു വരുന്നത്.
"അല്ലാ, എന്താണ് വിഡ്ജറ്റുകള്‍?"
"widget - a device or control that is very useful for a particular job"
അതെ. ജി.ടി.കെ.യില്‍ നമുക്കുപകാരമുള്ള എല്ലാ ഉപകരണങ്ങളും 'വിഡ്ജറ്റുകള്‍' ആണ്.
ഉദാ:
GTKWindow, GTKVBox, GTKEntry, GTKLabel
ഇവ യഥാക്രമം ജാലകം, കണ്ടെയ്നര്‍, ഇന്‍പുട്ട്, ഔട്പുട്ട് എന്നിവയ്ക്ക് ഉദാഹരണങ്ങളാണ്.

ഒരു ജി.ടി.കെ. ജാലകത്തില്‍ ഒരേ സമയം ഒരു വിഡ്ജറ്റ് മാത്രമേ ചേര്‍ക്കാനാവൂ. അതാദ്യം പഠിയ്ക്കാം. എന്നിട്ട് ഒന്നിലധികം വിഡ്ജറ്റു ചേര്‍ക്കാം.

ജാലകത്തില്‍ ഒരൊറ്റ വിഡ്ജറ്റ് ചേര്‍ക്കല്‍

#! /usr/bin/env python
import gtk,sys

w=gtk.Window()
l=gtk.Label()

w.set_title("Adding a Single Widget")
w.set_size_request(400,100)
l.set_label("This is a Label Inside GTKWindow")
w.connect("destroy",gtk.main_quit)

w.add(l) # Add Label to the Window
# w.show() will only show the window. You have to give l.show() also.
# s.show_all() will show everything. You shouldn't to give l.show().

w.show_all()

gtk.main()


കഴിഞ്ഞ അദ്ധ്യായത്തില്‍നിന്നു മാറി ജാലകം കണക്റ്റ് ചെയ്തതു നോക്കുക. ഇരു രീതിയും പരീക്ഷിയ്ക്കുക.
w.show()യ്ക്ക് പകരം w.show_all() കൊടുക്കുന്നതെന്തിനാണെന്ന് കമന്റ് നോക്കി മനസ്സിലാക്കുക.
gtk.Label()ന് പകരം gtk.Entry(), gtk.Button() എന്നിവ പരീക്ഷിയ്ക്കുക.
gtk.Entry() കൊടുത്താല്‍ l.set_label("...") എന്നതിനു പകരം l.set_text("...") എന്ന് ഉപയോഗിയ്ക്കുക. ബട്ടണ് മാറ്റമില്ല.

Friday, June 8, 2012

1. Your First GTK Window!


I) Just a single Window

In this session, we will create a single GTK Window in Python. I will explain line by line. After that I will show you the full code. You can tpye it or copy it. Save it as a text file (better to give .py extension). (GNU/Linux) Right click on the file, Properties -> Permissions -> Check 'Allow executing file as program'.

First line:
#! /usr/bin/env python
When we tell the computer to run this file, it will be given to python.

import gtk
We need a module called 'gtk' for GTK programming.

w=gtk.Window()
Create a GTK Window in variable 'w'.

w.show()
Show the window.

gtk.main()
To work all commands with GTK, this is needed.

So our code is:

#! /usr/bin/env python
import gtk
w=gtk.Window()
w.show()
gtk.main()


II) More customized window

We will set some properties of our window. I think no descriptions are needed.

#! /usr/bin/env python
import gtk,sys

w=gtk.Window()
w.set_title("My First GTK Window")
w.set_icon_name("gtk-yes")
w.set_size_request(400,300)
w.set_position(gtk.WIN_POS_CENTER)
w.show()

gtk.main()


III) A Simple Event Connection

To handle events(eg. Key Press), we should connect them with functions in our programme.
Now our window has a problem : When we closes it, it disappears, but the programme really runs. To stop our programme when we closed our window, we sould connect the "destroy" event.
function (It doesn't work automatically):
def on_window_destroy(widget):
    sys.exit(1)
# Here is a tab space before the line

connection:
w.connect("destroy",on_window_destroy)

see the code now:

#! /usr/bin/env python
import gtk,sys,os

def on_window_destroy(widget):
    sys.exit(1) # Here is a tab space before the line

w=gtk.Window()
w.set_title("My First GTK Window")
w.set_icon_name("gtk-yes")
w.set_size_request(400,300)
w.set_position(gtk.WIN_POS_CENTER)
w.connect("destroy",on_window_destroy)
w.show()

gtk.main()