લેબલ java સાથે પોસ્ટ્સ બતાવી રહ્યું છે. બધી પોસ્ટ્સ બતાવો
લેબલ java સાથે પોસ્ટ્સ બતાવી રહ્યું છે. બધી પોસ્ટ્સ બતાવો

શુક્રવાર, 23 માર્ચ, 2018

Write an applet that uses the mouse listener, which overrides only two methods which are mousePressed and mouseReleased

Experiment : 12
આપણે આ practical માં mouse event નો ઉપયોગ કરવા નો છે. Mouse event માં પણ mouse press અને mouse release.

Code = Exp12.java

import java.awt.*;
import java.awt.event.*;

public class Exp12 extends Frame implements MouseListener
{
   TextField t1,t2;
   Exp12()
   {
       setVisible(true);
       setSize(500,500);
       setLayout(new FlowLayout());
       t1=new TextField(20);
       t2=new TextField(20);
       add(t1);
       add(t2);
       addMouseListener(this);
   }

   public void mouseReleased(MouseEvent e)
   {
       System.out.println("Mouse is released");
       t1.setText("Mouse is released");
   }

   public void mousePressed(MouseEvent e)
   {
       System.out.println("Mouse is pressed");
       t1.setText("Mouse is pressed");
   }
   public void mouseEntered(MouseEvent e)
   {
     t2.setText("Mouse is In");
   }
   public void mouseExited(MouseEvent e)
   {
     t2.setText("Mouse is Exite");
   }
   public void mouseClicked(MouseEvent e)
   {

   }
   public static void main(String args[])
   {
       new Exp12();
   }
}


  • Output :










આ પ્રોગ્રામમાં, એક Frame બનાવવામાં આવ્યો છે અને તેમાં એવી માઉસની ઘટનાઓનું સમર્થન કરવા માટે MouseListener ઇન્ટરફેસનો ઉપયોગ કરવામાં આવ્યો છે. જ્યારે માઉસ એન્ટર કરે છે, ત્યારે "Mouse entered the frame." મેસેજ મુદ્દાઈ દીધો છે, અને જ્યારે માઉસ એક્ઝિટ કરે છે, ત્યારે "Mouse exited the frame." મેસેજ મુદ્દાઈ દીધો છે.આ પ્રોગ્રામનો રન કરાવીને, તમારે ફોર્મ પર માઉસ એન્ટર અને એક્ઝિટ ઇવેન્ટનું અનુભવ કરવામાં આવશે. અમુક સમયને ફોર્મ પર માઉસનું સ્થાન ચેક કરીને "Mouse entered the frame." અથવા "Mouse exited the frame." મેસેજ દેખવામાં આવશે


જાવા AWT (Abstract Window Toolkit) માઉસ ઇવેન્ટ્સ તમારા પ્રોગ્રામને માઉસની ક્રિયાઓ અથવા માઉસની ઘટનાઓનો સમર્થન કરે છે. ઉદાહરણ તરીકે, તમે માઉસ કરીને કોઈ બટનને ક્લિક કરી શકો છો, બટન સ્ક્રોલ કરી શકો છો અને માઉસ સ્ક્રોલ કરી શકો છો.

જાવા AWT માઉસ ઇવેન્ટ્સ માટે, તમારી એપ્લિકેશનમાં મોટાભાગની પોપ્યુલર ઇવેન્ટ્સ હેરાન કરેલ વિગતોમાં, MouseListener અને MouseMotionListener હોય છે. MouseListener તમારે માઉસની ક્રિયાઓનું સમર્થન કરે છે (જે માઉસનું સ્થિતિમાં બદલે છે, માઉસ ક્લિક કરે છે, બટન માઉસ પર અક્ષર ને સ્ક્રોલ કરે છે) અને MouseMotionListener તમારી એપ્લિકેશનમાં માઉસની કર્યાનું સમર્થન કરે છે (જે માઉસનું સ્થિતિમાં ફેરફાર કરે છે).

માઉસ પ્રેસ ઇવેન્ટ તમારી માઉસ બટનને ક્લિક કરવામાં સંબંધિત છે. જ્યારે તમે માઉસનું કોઈ બટન પ્રેસ કરો છો, આપતું બટનનો પ્રેસ ઇવેન્ટ ઉંમરે છે. આ ઇવેન્ટ ઘટના સંબંધિત માઉસ બટનનું સ્થાયી કે સ્થાનિક અવસ્થાને લેવામાં આવે છે.

આપતું માઉસ પ્રેસ ઇવેન્ટનું અભિગમ તમારી એપ્લિકેશનમાં MouseListener ઇન્ટરફેસની મદદથી કરી શકાય છે. તમારી એપ્લિકેશનમાં MouseListenerનાં મેથડ્સમાં મુખ્ય છે: mousePressed() અને mouseReleased(). જ્યારે તમે માઉસનો બટન પ્રેસ કરો છો, mousePressed() મેથડ ચલે છે અને જ્યારે તમે બટનને રિલીઝ કરો છો, mouseReleased() મેથડ ચલે છે.

આ ઇવેન્ટ્સ નું સરળ ઉદાહરણ હોય તો, તમે માઉસને બટન પ્રેસ કરીને કેટલાક કાર્યો કરેલ છો અને તમે બટનને રિલીઝ કરીને કેટલાક અન્ય કાર્યો કરેલ છો.

આપણે કોઈ પણ કામ computer માં કર્યે તો mouse નો ઉપયોગ થાય જ છે. એમાં પણ જો track કરવું હોય જોવું હોય શું થાય તે જાણવા mouse event નો ઉપયોગ કર્યે.

માઉસ એન્ટર (Mouse Enter) અને માઉસ એક્ઝિટ (Mouse Exit) ઇવેન્ટ માઉસની અવસ્થાની બદલાવ સંબંધિત છે. જ્યારે માઉસ માઉસ કંપોઝિશનમાં બદલે છે, આ ઇવેન્ટ્સ કાર્યક્રમ ચલાવે છે.

માઉસ એન્ટર (Mouse Enter) ઇવેન્ટ જ્યારે માઉસ એપ્લિકેશનની એક બંદ વિંડો થી બીજી બંદ વિંડોમાં પ્રવેશ કરે છે ત્યારે ઘટે છે. આ ઇવેન્ટમાં, માઉસનું કર્યું સ્થાન તમારી એપ્લિકેશનની પરિમિતિઓની અંદર આવે છે.

માઉસ એક્ઝિટ (Mouse Exit) ઇવેન્ટ જ્યારે માઉસ એપ્લિકેશનની એક બંદ વિંડોમાંથી બીજી બંદ વિંડોમાં નિકલે છે ત્યારે ઘટે છે. આ ઇવેન્ટમાં, માઉસનું કર્યું સ્થાન તમારી એપ્લિકેશનની પરિમિતિઓની બહાર જતું દેખાય છે.

આ ઇવેન્ટ્સ માટે, તમારી એપ્લિકેશનમાં MouseListener ઇન્ટરફેસનો ઉપયોગ કરી શકાય છે, જે માઉસના સંબંધિત મેથડનું સમર્થન કરે છે.



આપણે ક્યાં click કરી ક્યાં drag કર્યું ક્યારે relese કર્યું તે બધું આ mouse event listener દ્વારા જાણી શકાય ઊપયોગ કરી શકાય.

આમાં પણ awt library નો import (keyword) નો ઉપયોગ કરી ને લાઇબ્રેરી add કરી.

public class Exp12 extends Frame implements MouseListener

Exp12 માં frame extand કરાવ્યું inherent કર્યું અને Mouselisener ને implement કર્યું જેથી તેમાં રહેલી method ને define ઉપયોગ કરી શકાય આપણ પ્રમાણે.

TextField t1,t2;

બે t1 ને t2 નામની textfield બનાવી જેથી કરી ને તેમાં આપણે show કરી કે code માં શું થાય છે. કઈ method use માં આવે છે.

Exp12()
   {
       setVisible(true);
       setSize(500,500);
       setLayout(new FlowLayout());
       t1=new TextField(20);
       t2=new TextField(20);
       add(t1);
       add(t2);
       addMouseListener(this);
   }

ત્યાર બાદ Exp12() જે એક constructer છે કેમકે class નું નામ સરખું છે તેથી.

ત્યારબાદ ક્રમશઃ size setSize () દ્વારા 
new TextField(20) દ્વારા text field જેની default size 20 છે.
અને ત્યાર બાદ add (); નો ઉપયોગ કરી ને તેમાં add કર્યું.

addMouseListener (this)
આના લાઇન નો ઉપયોગ કરી ને Mouselisener ને add કર્યું  જેમાં this(keyword) લખી ને object પાસ કર્યો 

ત્યાર બાદ mouse event listener
  • mouseReleased
  • mousePressed
  • mouseEntered
  • mouseExited
  • mouseClicked
mousePressed ત્યારે call થશે જ્યારે mouse નું button દબાવી રાખ્યું હોય એટલો time mouse pressed t1 text field માં લખાઇલું રેહસે.

જેવુ છોડસો click છોડશો તેવું mouse release call થશે. ને t1 textfield માં લખસે "Mouse is released"

mouseclicked ત્યારે run થશે press અને released થાય એટલે clicked થાય.

જ્યારે applet frame માં pointer દાખલ થાય ત્યારે mouseEntered run થાય t2 textfield માં "Mouse is in" થસે.

જ્યારે applet frame માં pointer બહાર થાય ત્યારે mouseExit run થાય t2 textfield માં "Mouse is Exite" થસે.

તમે કઈ જોયું screen shot માં cmd માં પણ print થાય છે.
System.out.println("");
ના લીધે Cmd માં પણ સાથે સાથે print થાય છે. 
Mouse press અને mouse release ને cmd માં print કર્યું છે કેમકે એ તરત જ પળ વારમાં થઇ જાય છે. એટલે cmd મા રેકોર્ડ થાય છે એટલે તેમાં જોઈ સકાય.


Develop an applet to display the message "Happy New Year" within a text field

Experiment : 6
આપણે આમાં એક applet બનાવવાનું છે જે "happy new year" નો મેસેજ print કરતું હોય એને તે button નો ઉપયોગ થી થાય.
yearbtn.java

import java.awt.*;
import java.awt.event.*;

public class yearbtn extends Frame implements ActionListener{
Button b1;
Label l1;
    yearbtn()
    {
        b1=new Button("year");
        l1=new Label(" ");
        setLayout(new FlowLayout());
        setVisible(true);
        setSize(300,500);
        add(b1);
        add(l1);
        b1.addActionListener(this);
    }
    public static void main(String args[])
    {
        yearbtn s=new yearbtn();        
    }
    
public void actionPerformed(ActionEvent e)
    {
        if(e.getSource()==b1)
        {
            l1.setText("happy new year");
        }
}
}

  • Output :
  •  
     



આ ઉદાહરણમાં, જ્યારે તમે લેબલ પર ક્લિક કરો છો, ત્યારે લેબલનો ટેક્સ્ટ લેબલ "Label clicked!" પર બદલાવામાં આવશે. તો એપ્લિકેશનમાં બટનનો છે પરંતુ પ્રતિક્રિયાઓને દર્શાવવામાં આવે છે.આવું માટે, એપ્લિકેશનનો કોડ વધુ વિસ્તૃત કરવામાં આવે છે કારણ કે તમારી એપ્લિકેશનમાં વધુમાં વધુ GUI એલીમેન્ટ્સ અને ક્રિયાઓ હોવી જરૂરી છે. પરંતુ, આ ઉદાહરણ તમને બટન અને લેબલની બસીક પ્રિંસિપલ્સ સમજાવે છે.
બટન (Button) અને લેબલ (Label) પ્રોગ્રામિંગ માં GUI એલીમેન્ટ્સ સંબંધિત છે.
બટન (Button): બટન, સાધારણ રીતે, તેમના સાથે એક ક્લિક કરવાથી કોઈ પ્રોસેસિંગ યોજના શરૂ કરે છે. Java માં, બટનનો ઉપયોગ વપરીને એપ્લિકેશનમાં બટન દૃષ્ટિકોના ફોર્મમાંથી વિવિધ ક્રિયાઓનું પ્રાથમિક રૂપે સ્થાન રખવામાં આવે છે.
લેબલ (Label): લેબલ એપ્લિકેશનમાં માહિતીનો પ્રદર્શન કરવાનું એક સાધારણ રીતે ઉપયોગ થાય છે. Java માં, લેબલનો ઉપયોગ પ્રદર્શિત કરવામાં માહિતીનાં ટેક્સ્ટને સંકલિત કરવા માટે કરવામાં આવે છે.

આપણે આમાં એક બટન ને એક text field લેસુ અને button ના click પર text field માં message બતાવ શું.

import java.awt.*;
import java.awt.event.*;

આ import દ્વારા આપણે લાઇબ્રેરી add કરી awt.

Button b1;
Label l1;
Button પર clicked અને label ને change કરવાનું.
આ દ્વારા b1 નામનું બટન અને l1 લેબલ જેમાં happy new year print કરવા.



public static void main(String args[])
    {
        yearbtn s=new yearbtn();        
    }

Program ની શરૂઆત થાય main function થી.
yearbtn નામનાં class નો object બનાવી ને call કર યો છે. yearbtn નો s નામ નો object. બનાવ્યો.

  yearbtn()
    {
        b1=new Button("year");
        l1=new Label(" ");
        setLayout(new FlowLayout());
        setVisible(true);
        setSize(300,500);
        add(b1);
        add(l1);
        b1.addActionListener(this);
    }

yearbtn() જે એક constructer છે. જે yearbtn નો s નામનો object બનતા ની સાથે call થાય છે.
 ત્યાર બાદ ક્રમશઃ button create size set કરવી અને છેલ્લે ActionListner.

actionPerformed(ActionEvent) એક Java એન્ટરફેસ છે અને java.awt.event.ActionListener ઇન્ટરફેસ દ્વારા પ્રદાન કરવામાં આવે છે. આ ઇન્ટરફેસમાં એક મેથડ છે, જેનો નામ actionPerformed છે.આપેલ ઉદાહરણોમાં, તમે ક્લાસ બનાવ્યો છે અને એપ્લિકેશનમાં બટનને ક્લિક કરવાથી કઈ ક્રિયા કરવી તે નિર્ધારવા માટે actionPerformed(ActionEvent) મેથડનો ઉપયોગ કરવામાં આવે છે.જ્યારે તમે બટન પર ક્લિક કરો છો, તે એક ActionEvent ઉત્પન્ન કરે છે અને તમારી actionPerformed(ActionEvent) મેથડ કોલ કરે છે.

actionPerformed(ActionEvent e)

જેવુ કંઇ clicked થસે action થસે તેવું આ function call થસે.

setText() એક મેથડ છે, જેનો ઉપયોગ ટેક્સ્ટ બૉક્સ, લેબલ, બટન માં વિવિધ એપ્લિકેશનમાં ટેક્સ્ટને સેટ કરવા માટે કરવામાં આવે છે.

l1.setText("happy new year");

setText(""); દ્વારા happy new year set થયું.

આમ simple button ના action પર actionPerformed call 
થાય એના આધારે lable update થાય.

Built an applet that displays a horizontal rectangle in its center. Let the rectangle fill with color from left to right.

Experiment : 3
આપણે આ practical માં applet માં progress bar બનાવવાની છે.એના માટે વચ્ચે એક આળું લંબચોરસ ની અંદર કલર વાળા લંબચોરસ ને ભરી ને કરી સકાય.
Code = ProgressD.java


import java.applet.Applet;
import java.awt.*;

/*<applet code="ProgressD.class" width=320 height=150>
</applet>
*/

public class ProgressD extends Applet{

    public void paint(Graphics G){
        G.drawRect(48,50,218,50);
        
        for(int x=50;x<=260;x=x+12){
            try{
            Thread.sleep(500);
            G.fillRect(x,52,10,46);
            }catch(Exception e){

            }
        }
    }

}
  • Output :





 
ચાલો તો એક પછી એક કરી લાઈન by લાઈન કોડ ને સમજયે 

import java.applet.Applet;
import java.awt.*;
આ લાઈન માં import નો ઉપયોગ લાઇબ્રેરી ને add કરવા ઊપયોગ થયો છે, java applet અને java awt librery ને import કરવી છે એટલે તેના રહેલા function method નો ઉપયોગ આપણે કોડ માં કરી સકાય.

/*<applet code="ProgressD.class" width=500 height=300>
</applet>*/
ઉપર ની લાઈન માં આપણે applet ના dimention hight(ઊંચાઈ) ને width (પોહળાઇ) ને નક્કી કરી છે.

public class ProgressD extends Applet
ProgressD નામનો class (keyword) બનાવ્યો, અને extands (keyword) નો ઉપયોગ કરી ને applet class ને inherat કર્યો જેથી applet class ની વસ્તુ નો ઊપયોગ કરી સકાય.

public void paint(Graphics g)
અહી paint નામની method બનાવી જેનો return type void છે, એટલે એ કાઇપણ return કરસે નહિ. અને Graphics નો object g ને બનાવી પાસ કર્યો જેથી g નો ઉપયોગ કરી applet માં graphics લગતા function use કરી સકાય.
drawRect મેથોડનો ઉપયોગ કરીને સીધું બાજુથી 48 પિક્સલ અને 50 પિક્સલની સ્થાનિકતાથી 218 પિક્સલ અને 50 પિક્સલ સુધીનું રેક્ટેંગલ બનાવીશ છે.


ટ્રાય (Try) એક એક્સેપ્શન હેન્ડલિંગ નો મૂળ પદ્ધતિ છે જેમાં પ્રોગ્રામમાં એન્યુનો ભાંગવું અથવા અસામાન્ય ક્રિયા કરવી હોય, જેમનો પરિણામસ્વરૂપ એક એક્સેપ્શન ઉત્પન્ન થતો હોય.

ટ્રાય બ્લોકનો સારો ઉપયોગ એ છે કે તે એક સુસંગત પ્રોગ્રામ દ્વારા અસુવિધાની સ્થિતિઓનો ધ્યાન ધરાવે. ઉદાહરણ તરીકે, જો તમે ફાઇલ વાંચવાનો પ્રયાસ કરો છો અને ફાઇલ અસ્તિત્વમાં ન હોય, તો એક `FileNotFoundException` નો એક્સેપ્શન ઉત્પન્ન થઈ શકે છે. તેમાં, તમે ટ્રાય-કેચ બ્લોકનો ઉપયોગ કરીને આ એક્સેપ્શનને હેન્ડલ કરી શકો છો અને તમારો પ્રોગ્રામ બંદ ન થઈએ.

થ્રેડ સ્લીપ (Thread sleep) મેથડ એક થ્રેડને નિર્દિષ્ટ સમય સુધી ડાહ્યું રાખવા માટે ઉપયોગ થાય છે. જ્યારે તમે થ્રેડને સ્લીપ કરાવો છો, તે નિર્દિષ્ટ સમય માટે આપને પ્રતીક્ષા કરતું રહેશે.
થ્રેડને સ્લીપ કરાવવાનો ઉપયોગ કોઈ પ્રક્રિયાને બંધ કરવામાં આવે છે અથવા ડેલેય કરવામાં આવે છે, જે થ્રેડને પ્રતીક્ષામાં રાખે છે કે તેમની માટે તમારી પ્રોગ્રામમાં કંપ્યુટેશનલ્યુટેડ પ્રોસેસિંગને રોકે છે. આપેલ ઉદાહરણમાં, પ્રોગ્રામમાં સ્લીપ થઇ રહ્યું મોટાભાગનો કારણ આપનો પ્રોગ્રામ બધાની કાર્યક્રમનું પ્રતીક્ષા કરી રહ્યો છે જ્યારે થ્રેડ સ્લીપ થયો છે.

Draw seven red circles in a vertical column in the center of the applet

Experiment : 2
આ practical માં આપણે સાત લાલ ગોળ ઊભી (vertical) માં applet ના વચ્ચે દોરવાના છે.
Code = redcircle.java

import java.applet.Applet;
import java.awt.*;

/*<applet code="redcircle.class" width=700 height=700>
</applet>*/


public class redcircle extends Applet
{
   public void paint(Graphics g)
   {
       g.drawString("Hello",338,355);


       int y=0;
       g.setColor(Color.RED);
       for(int i=0;i<7;i++)
       {

           g.fillOval(300,y,100,100);
           y=y+100;
       }
   }
}
  • Output


આ task કરવા માટે આપણે આને પેહલા એક applet બનાવ્યે અને ત્યાર બાદ loop ની મદદ થી 10 ગોળ બનાવી.

import java.applet.Applet;
import java.awt.*;

આપણે અહી import (keyword) નો ઉપયોગ કરી ને જરૂરી library ને add કરી છે. આમાં applet librery દ્વારા applet ના function methods ઉપયોગ કરી સકાસે. એને Awt (Abstract windows Toolkit) windows user interface tools ઊપયોગ કરી સકાઈ.

/*<applet code="redcircle.class" width=700 height=700></applet>*/
ઉપર ની લાઈન માં આપણે applet ના dimention hight(ઊંચાઈ) ને width (પોહળાઇ) ને નક્કી કરી છે.

public class redcircle extends Applet
redcircle નામનો class (keyword) બનાવ્યો, અને extands (keyword) નો ઉપયોગ કરી ને applet class ને inherat કર્યો જેથી applet class ની વસ્તુ નો ઊપયોગ કરી સકાય.

public void paint(Graphics g)
અહી paint નામની method બનાવી જેનો return type void છે, એટલે એ કાઇપણ return કરસે નહિ. અને Graphics નો object g ને બનાવી પાસ કર્યો જેથી g નો ઉપયોગ કરી applet માં graphics લગતા function use કરી સકાય
g.setColor(Color.RED);

setColor(Color.RED) મેથોડ એ જાવાની Graphics ક્લાસનો એક મેથોડ છે, જેનો ઉપયોગ ગ્રાફિકલ વસ્તુઓના રંગ સેટ કરવામાં થાય છે. તેમજ Color.RED એ જાવાની Color ક્લાસનો એક સ્ટેટિક ચિન્હ છે, જેથી વર્ણનું પ્રકાર લાલ હોય છે.જો તમે કોઈ ગ્રાફિકલ બનાવવું અથવા રંગપૂર્ણ વાગ્યું વૃત્તબિંબ અને તેની રંગમાં લાલ વાગ્યું વાંચવું છે, તો setColor(Color.RED) નો ઉપયોગ કરીને કરી શકો છો.
setColor function નો ઉપયોગ કરી ને લાલ કલર set કરી દીધું.
હવે આપણે ૭ સર્કલ દોરવાના છે, એટલે  આપણે loop નો ઉપયોગ કર્યે.
for(int i=0;i<7;i++) { .. }
Syntax for loop :-
for(initiation, condition, increment) { .. }

for લૂપનો ઉપયોગ કરીને fillOval મેથોડનું સાત સમાન વૃત્તબિંબોને બનાવવામાં આવ્યું છે. પ્રતિ વૃત્તબિંબની y-મૂલ્યને અવરોધવામાં હતી તથા તે 100 પિક્સલ વધારે બદલાય છે પરંતુ x-મૂલ્ય સ્થાયી છે (માને 300). જેમાં, હરેક વૃત્તબિંબની y-સ્થાનનું અંતર 100 પિક્સલ છે, અને વૃત્તબિંબની લંબાઈ અને ચોડી એ 100 પિક્સલ છે.
Initiation માં i=0 i ની કિંમત 7 assign કરી
Condition માં i<7 જ્યાં સુધી i ની કિંમત 7 થી ઓછી હોય ત્યાં સુધી loop ફર્યા કરસે, એટલે અંદર નો કોડ run થાય કરસે.
Increment માં i++ એટલે દરેક iteration (round) વખતે i ની કિંમત માં એક નો વધારો થાય.
g.fillOval(300,y,100,100);
લાલ circle બનાવવાનું છે એટલે fillOval નો ઉપયોગ  કરશું
એપ્લેટમાં fillOval એ એક ગ્રાફિકલ પ્રક્રિયા છે, જેમાં રંગપૂર્ણ વાગ્યું વૃત્તબિંબને બનાવીને પૂર્ણ વૃત્તનો ભાગ પંક્તિ દ્વારા વિગ્રહાત્મક કરવામાં આવે છે. અંદાજે, ટૂલકિટ દ્વારા આપેલ વ્યાખ્યા જોઈને એપ્લેટમાં fillOval માત્ર લાલ વાગ્યું વૃત્તબિંબ બનાવવામાં આવે છે.

Syntax :- 
fillOval(int x ,int y, int hight , int width)
Int x એ x cordinat ની કિંમત 300
Int y એ y cordinat ની કિંમત અહી variable y
Int hight એ hight ઊંચાઈ  અહી 100
Int width એ width પોહળાઈ અહી 100
હવે જો આટલું જ રાખ્યે તો એકજ જગ્યાએ ૭ ગોળ દોરસ પણ આપણે એક પછી એક કરવાના છે ઊભી લાઇન મા.
એટલે y cordinat માં ચેન્જ કરવો પડશે એટલે આપણે 
y=y+100;
Y ની કિંમત મા દર વખતે 100 નો વધારે થાય છે. ઊંચાઈ પોહળાઈ 100 રાખી એટલે y ની કિંમત 100 રાખી, જેથી એક પછી એક draw થાય.


Python tkinter

 Tkinter એ python ની graphics tool library છે. Tkinter library ની મદદ થી આપણૅ કમ્પ્યુટર applaction બનાવી સકે. હમણાં સુધી આપણૅ અલગ અલગ script...