Mobile_Programming

Document Sample
Mobile_Programming Powered By Docstoc
					‫‪www.txt.ir‬‬     ‫‪www.txt.ir‬‬           ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬     ‫‪www.txt.ir‬‬




               ‫آﻣﻮزش ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺗﻠﻔﻦ ﻫﺎي ﻫﻤﺮاه‬
               ‫ﺑﻪ زﺑﺎن ‪ J2ME‬در ‪IDE NetBeans‬‬


                                   ‫ﻧﻮﻳﺴﻨﺪﮔﺎن :‬
                             ‫ﻣﻬﻨﺪس اﻳﻤﺎن اﺷﻜﺎوﻧﺪ راد‬
                                ‫ﻣﻬﻨﺪس ﺣﺴﻦ ﻓﺮزاﻧﻪ‬


                                    ‫ﺳﺎل 6831‬


                              ‫اﻣﺎم ﻋﻠﻲ )ع( ﻓﺮﻣﻮدﻧﺪ :‬
                       ‫زﻛﺎت ﻋﻠﻢ ﻧﺸﺮ و ﮔﺴﺘﺮش آن ﻣﻲ ﺑﺎﺷﺪ‬




                    ‫اﻳﻦ ﻛﺘﺎب اﻟﻜﺘﺮوﻧﻴﻜﻲ ﻛﺎﻣﻼً راﻳﮕﺎن ﻣﻲ ﺑﺎﺷﺪ‬
                                           ‫و‬
                ‫ﺑﻪ ﺗﻤﺎﻣﻲ اﻳﺮاﻧﻴﺎن ﻋﺰﻳﺰ و ﻓﺎرﺳﻲ زﺑﺎﻧﺎن ﺗﻘﺪﻳﻢ ﻣﻲ ﮔﺮدد‬




                                       ‫1‬
  ‫‪www.txt.ir‬‬    ‫‪www.txt.ir‬‬           ‫‪www.txt.ir‬‬           ‫‪www.txt.ir‬‬    ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬                    ‫‪www.txt.ir‬‬                   ‫‪www.txt.ir‬‬                    ‫‪www.txt.ir‬‬



                                                         ‫ﭼﻜﻴﺪه‬
                                        ‫آﻣﻮزش ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺗﻠﻔﻦ ﻫﺎي ﻫﻤﺮاه‬
                                     ‫ﺑﻪ زﺑﺎن ‪ J2ME‬در ‪IDE NetBeans‬‬


    ‫اﻳﻦ ‪ PDF‬ﺷﺎﻣﻞ دو ﻓﺼﻞ از ﻣﺒﺎﺣﺚ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺗﻠﻔﻦ ﻫﻤﺮاه ﺑﻪ زﺑﺎن ‪ J2ME‬اﺳﺖ . ﺑﻌﺪ از ﻣﻄﺎﻟﻌﻪ اﻳﻦ ﻛﺘﺎب ﺷﻤﺎ ﺑﺎ اﻧﻮاع‬
    ‫زﺑﺎﻧﻬﺎي ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ در ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ﺳﻴﻤﺒﻴﻦ و ﺑﻪ وﻳﮋه زﺑﺎن ‪ J2ME‬آﺷﻨﺎ ﻣﻴﺸﻮﻳﺪ. ﻣﻄﺎﻟﻌﻪ اﻳﻦ ﻛﺘﺎب ﻫﻤﭽﻨﻴﻦ ﺷﻤﺎ را ﺑﺎ ﻣﺤـﻴﻂ‬
    ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﻧﺖ ﺑﻴﻨﺰ 5 و اﻧﻮاع ﻛﺎﻣﭙﻮﻧﻨﺖ ﻫﺎ و ﻧﺤﻮه ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ در آن و ﻗﺎﺑﻠﻴﺖ ﻫﺎي آن ﺑـﺮاي ﺑﺮﻧﺎﻣـﻪ ﻧﻮﻳـﺴﻲ ﺑـﻪ زﺑـﺎن‬
                   ‫‪ J2ME‬آﺷﻨﺎ ﺧﻮاﻫﺪ ﻛﺮد. در اداﻣﻪ ﻧﻴﺰ ﺑﺎ ﻧﺤﻮه ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﭘﺎﻳﮕﺎه داده ‪ RMS‬در ‪ J2ME‬آﺷﻨﺎ ﺧﻮاﻫﻴﺪ ﺷﺪ.‬


                                                                                                 ‫واژهﻫﺎي ﻛﻠﻴﺪي‬
                             ‫ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ﺳﻴﻤﺒﻴﻦ، ‪ ،J2ME‬ﻧﺖ ﺑﻴﻨﺰ‪ , Symbian , NetBeans ، RMS‬ﺟﺎوا‬
                                                                       ‫‪Mobile Programming‬‬




                                                          ‫2‬
  ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬
www.txt.ir     www.txt.ir     www.txt.ir     www.txt.ir      www.txt.ir




     IDE Netbeans ‫ و‬J2ME ‫ﻓﺼﻞ اول - آﺷﻨﺎﻳﻲ ﺑﺎ ﻣﺤﻴﻂ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ‬




                                3
  www.txt.ir    www.txt.ir    www.txt.ir     www.txt.ir    www.txt.ir
‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬




           ‫ﻓﺼﻞ اول - آﺷﻨﺎﻳﻲ ﺑﺎ ﻣﺤﻴﻂ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ‪ J2ME‬و ‪IDE Netbeans‬‬


                                               ‫1-1- آﺷﻨﺎﻳﻲ ﺑﺎ ﻣﺤﻴﻂ ﻫﺎي ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺟﺎوا‬

    ‫اﻣﺮوزه، ﺑﺎ وﺟﻮد اﻳﺴﺘﮕﺎهﻫﺎي ﻛﺎري، ﻛﻪ داراي ﭘﺮدازﻧﺪهﻫﺎي ﺳﻪ ﮔﻴﮕﺎ ﻫﺮﺗﺰي و ‪ RAM‬ﻫﺎي ﻳﻚ ﮔﻴﮕﺎﺑﺎﻳﺘﻲ‬
    ‫ﻫﺴﺘﻨﺪ، ﻣﺤﻴﻂﻫﺎي ﻗﺪرﺗﻤﻨﺪ ﻣﻲﺗﻮاﻧﻨﺪ ﺑﺪون وارد ﺳﺎﺧﺘﻦ ﺑﺎر اﺿﺎﻓﻲ ﺑﺮ ﺳﺨﺖاﻓﺰار اﺟﺮا ﮔﺮدﻧﺪ. در ﻧﺘﻴﺠﻪ اﻳﻦ‬
    ‫ﭘﻴﺸﺮﻓﺖ، ﻃﻲ ﭼﻨﺪ ﺳﺎل ﮔﺬﺷﺘﻪ ﺷﺎﻫﺪ ﻇﻬﻮر ﻣﺤﺼﻮﻻت ﻗﺎﺑﻞ ﺗﻮﺟﻬﻲ، از ﻗﺒﻴﻞ وﻳﮋوال اﺳﺘﻮدﻳﻮ دات ﻧﺖ1،‬
                                    ‫اﻳﻜﻠﻴﭙﺲ 0,32، ﻧﺖ ﺑﻴﻨﺰ 0,5 3 و ... ﺑﻮدهاﻳﻢ ﻛﻪ ﺳﻄﺢ ‪ IDE‬ﻫﺎ را ﺑﺎﻻ ﺑﺮدهاﻧﺪ.‬

                                        ‫ﭼﻬﺎر ﺷﺮﻛﺖ ﭘﻴﺸﺮو ﺑﺮاي ﺗﻮﺳﻌﻪ ﺟﺎوا و اﺑﺰارﻫﺎي ﻫﻤﺮاه آن ﻋﺒﺎرﺗﻨﺪ از :‬
                                                                          ‫• ﺷﺮﻛﺖ ﺳﺎن ﻣﻴﻜﺮو ﺳﻴﺴﺘﻢ‬
                                                                                  ‫• ﺷﺮﻛﺖ آي ﺑﻲ ام‬
                                                                                     ‫• ﺷﺮﻛﺖ اراﻛﻞ‬
                                                                                     ‫• ﺷﺮﻛﺖ ﺑﻮرﻟﻨﺪ‬




       ‫1‬
         ‫‪Visual Studio.Net‬‬
       ‫2‬
         ‫0.3 ‪Eclipse‬‬
       ‫3‬
         ‫0.5 ‪Netbeans‬‬

                                                   ‫4‬
  ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬          ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬            ‫‪www.txt.ir‬‬                   ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬                   ‫‪www.txt.ir‬‬




                                    ‫ﺷﻜﻞ 1-1- ﻣﺤﻴﻂ ﻫﺎي ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺟﺎوا‬


    ‫اﻳﻦ ﻣﺤﺼﻮﻻت ﺑﻪ ﺷﻜﻠﻲ ﺟﺎﻟﺐ ﺗﻮﺟﻪ، ﺳﻤﺒﻞﻫﺎي ‪ IDE‬ﻣﺘﻔﺎوت را ﺑﻪ ﻛﺎر ﻣﻲﺑﺮﻧـﺪ. ﻣﺤـﺼﻮل اﻳﻜﻠﻴـﭙﺲ 0,3‬
    ‫آي ﺑﻲ ام، ﻣﺒﺘﻨﻲ ﺑﺮ ﻣﺤﺼﻮل راﻳﮕﺎن ﻛﺪﺑﺎز اﺳﺖ ﻛﻪ ﻣﻘﺒﻮﻟﻴﺖ زﻳﺎدي در ﺑـﻴﻦ ﺗﻮﺳـﻌﻪﮔـﺮان ﺟـﺎوا دارد. ﻣﺤـﺼﻮل‬
    ‫ﺳﺎن ﻣﺒﺘﻨﻲ ﺑﺮ ﭘﻠﺘﻔﺮم ‪ IDE‬ﻛﺪ ﺑﺎز رﻗﻴﺐ، ﻳﻌﻨﻲ ﻧﺖ ﺑﻴﻨﺰ اﺳﺖ و ﻣﺤﺼﻮﻻت اراﻛﻞ و ﺑﻮرﻟﻨﺪ ﺑـﺮ ﻣﺒﻨـﺎي راﺑـﻂﻫـﺎي‬
                                                                           ‫ﻛﺎرﺑﺮ اﺧﺘﺼﺎﺻﻲ ﺳﺎﺧﺘﻪ ﺷﺪهاﻧﺪ.‬
    ‫ﻣﻦ ﺑﺮاي اﻧﺠﺎم اﻳﻦ ﭘﺮوژه ﻣﺤﻴﻂ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﻧﺖ ﺑﻴﻨﺰ 5 را اﻧﺘﺨـﺎب ﻧﻤـﻮدم ﻛـﻪ ﺗﻮﺳـﻂ ﺷـﺮﻛﺖ ﺳـﺎن ﻣﻴﻜـﺮو‬
                    ‫ﺳﻴﺴﺘﻢ اراﺋﻪ ﺷﺪه اﺳﺖ و داراي ﻗﺎﺑﻠﻴﺖ ﻫﺎي ﺧﻮﺑﻲ ﺑﺮاي ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺑﻪ زﺑﺎن ‪ J2ME‬ﻣﻲ ﺑﺎﺷﺪ.‬
    ‫ﻋﻼوه ﺑﺮ ﻳﻚ ﻣﺤﻴﻂ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺑﺮاي اﺟﺮاي ﺑﺮﻧﺎﻣﻪ ﻫﺎ ﺑﻪ زﺑﺎن ‪ J2ME‬ﻧﻴﺎز ﺑﻪ ﻧﺼﺐ ﻳﻚ ‪ SDK‬ﻧﻴﺰ دارﻳﻢ.‬
    ‫‪ SDK‬ﺣﺎوي ‪ API‬ﻫﺎ، ﻛﺘﺎﺑﺨﺎﻧﻪﻫﺎ، ﺷﺒﻴﻪﺳﺎز و دﻳﮕﺮ اﺑﺰار ﻛﺎر ﺑﺎ ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ﻣﺮﺑﻮﻃﻪ ﻫﺴﺘﻨﺪ. ﺑﺮاي ﺳﻴﻤﺒﻴﻦ ﺳﺮي‬
                                               ‫06 ﻣﻲﺗﻮاﻧﻴﻢ از ‪ SDK‬ﻫﺎي وﻳﺮاﻳﺶ 2.1 ﻳﺎ ‪ 2.x‬اﺳﺘﻔﺎده ﻧﻤﺎﻳﻴﻢ.‬




                                                       ‫5‬
  ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬            ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                   ‫‪www.txt.ir‬‬



                                                 ‫ﻣﻠﺰوﻣﺎت ﻻزم ﺑﺮاي اﻳﺠﺎد ﻣﺤﻴﻂ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ‪J2ME‬‬
                 ‫در زﻳﺮ ﻣﻠﺰوﻣﺎت ﻻزم ﺑﺮاي اﻳﺠﺎد ﻳﻚ ﻣﺤﻴﻂ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺑﻪ زﺑﺎن ‪ J2ME‬ﻧﺎم ﺑﺮده ﺷﺪه اﺳﺖ.‬
                                  ‫١. 0.5 ‪Java Standard Development Kit (JDK™) version‬‬

                                              ‫٢. 0.2 ‪(WTK2.0) Emulator Wireless Toolkit‬‬

                                                                             ‫٣. 0.5 ‪IDE NetBeans‬‬

                                                                ‫۴. ‪NetBeans Mobility 5.0 Pack‬‬

    ‫ﺑﺮاي داﻧﻠﻮد اﻳﻦ ﻣﻠﺰوﻣﺎت ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﻪ ﺳﺎﻳﺖ ‪ www.netbeans.org‬ﻣﺮاﺟﻌﻪ ﻧﻤﺎﻳﻴﺪ. ﭘﺲ از ﺗﻬﻴﻪ اﻳـﻦ ﻧـﺮم‬
                                                           ‫اﻓﺰارﻫﺎ ﺑﻪ ﺗﺮﺗﻴﺐ ذﻛﺮ ﺷﺪه اﻗﺪام ﺑﻪ ﻧﺼﺐ آن ﻫﺎ ﻧﻤﺎﻳﻴﺪ.‬


                                                          ‫1-2- ﻃﺮاﺣﻲ وﻳﮋوال ﺑﺮﻧﺎﻣﻪ ﻫﺎي ‪MIDP‬‬
    ‫ﻳﻚ ‪ 1 VMD‬ﺷﻤﺎ را ﻗﺎدر ﻣﻲ ﺳﺎزد ﻛﻪ ﺑﻪ ﺻﻮرت وﻳﮋوال ﺑﻪ ﻃﺮاﺣﻲ روﻧﺪ ﺟﺮﻳـﺎن ﺑﺮﻧﺎﻣـﻪ ﻫﺎﻳﺘـﺎن و ﻫﻤﭽﻨـﻴﻦ‬
    ‫راﺑﻂ ﻛﺎرﺑﺮ ﮔﺮاﻓﻴﻜﻲ )‪ (GUI‬ﺑﭙﺮدازﻳﺪ. ﺑـﻪ ﻋﻨـﻮان ﻣﺜـﺎل ﺷـﻤﺎ ﻣـﻲ ﺗﻮاﻧﻴـﺪ ﺑـﺎ ﻛـﺸﻴﺪن و رﻫـﺎ ﻛـﺮدن اﺷـﻴﺎ ﺑـﺮ روي‬
    ‫ﭘﻨﺠﺮه ﻫﺎي ‪ Flow Designer‬و ‪ Screen Designer‬ﻳﻚ ﻣﺤﻴﻂ را ﻃﺮاﺣﻲ ﻧﻤﺎﻳﻴﺪ و ﻣﺤـﻴﻂ ﺑﺮﻧﺎﻣـﻪ ﻧﻮﻳـﺴﻲ‬
                                          ‫ﺑﺮاي ﺷﻤﺎ ﺑﻪ ﻃﻮر ﺧﻮدﻛﺎر ﻛﺪﻫﺎي ﺟﺎواي آن اﺷﻴﺎ را ﺗﻮﻟﻴﺪ ﺧﻮاﻫﺪ ﻧﻤﻮد.‬
    ‫ﺑﺮاي اﺳﺘﻔﺎده از ﺣﺎﻟﺖ ‪ ،VMD‬ﺷﻤﺎ ﺑﺎﻳﺪ ﺑﺎ ﻓﺎﻳﻞ ﻫـﺎﻳﻲ ﻛـﺎر ﻧﻤﺎﻳﻴـﺪ ﻛـﻪ ﺑـﻪ وﺳـﻴﻠﻪ اﻟﮕﻮﻫـﺎي ‪ VMD‬ﺗﻮﻟﻴـﺪ‬
    ‫ﻣﻲ ﺷﻮﻧﺪ و در ﻗﺴﻤﺖ اﻳﺠﺎد ﻓﺎﻳﻞ ﺟﺪﻳﺪ2 ﺑﻪ ﺻﻮرت وﻳﺰارد وﺟﻮد دارﻧﺪ. ﺷﻤﺎ ﻧﻤﻲ ﺗﻮاﻧﻴﺪ از ﺣﺎﻟـﺖ ‪ VMD‬ﺑـﺮاي‬
    ‫اﺻﻼح ﻓﺮم ﻫﺎي ‪ GUI‬ﻳﻲ ﻛﻪ ﺧﺎرج از ‪ IDE‬ﺗﻮﻟﻴﺪ ﺷﺪه اﻧﺪ، اﺳﺘﻔﺎده ﻧﻤﺎﻳﻴﺪ. ﻫﻤﭽﻨﻴﻦ اﮔﺮ ﺷﻤﺎ ﻛﺪ ﺗﻮﻟﻴﺪ ﺷـﺪه در‬
           ‫ﻣﺤﻴﻂ ‪ VMD‬را در ﻛﺪ ﻣﻨﺒﻊ ﺗﻐﻴﻴﺮ دﻫﻴﺪ، ﺷﻤﺎ دﻳﮕﺮ ﻧﻤﻲ ﺗﻮاﻧﻴﺪ در ﺣﺎﻟﺖ وﻳﮋوال ﺑﻪ ﻛﺎر ﺧﻮد اداﻣﻪ دﻫﻴﺪ.‬
    ‫‪ VMD‬اﺑﺰارﻫﺎي زﻳﺮ را ﺑﺮاي ﺳﺎده ﺗﺮ ﺷﺪن ﻓﺮآﻳﻨﺪ ﻃﺮاﺣﻲ ﺑﺮﻧﺎﻣﻪ ﻫﺎي ‪ MIDP‬ﺷﻤﺎ ﻓﺮاﻫﻢ ﻧﻤـﻮده اﺳـﺖ ﻛـﻪ‬
                                                                                         ‫اﻳﻦ اﺑﺰارﻫﺎ ﻋﺒﺎرﺗﻨﺪ از:‬
    ‫• ‪ :Flow Designer‬اﻳﻦ ﻣﺤﻴﻂ ﻓﻀﺎي ﻛﺎري اﺻـﻠﻲ ‪ VMD‬ﻣـﻲ ﺑﺎﺷـﺪ. در اﻳـﻦ ﻓـﻀﺎ ﺷـﻤﺎ ﺷـﺎﻫﺪ‬
    ‫ﻧﻤﺎﻳﻲ ﻛﻠﻲ از ﻛﺎﻣﭙﻮﻧﻨﺖ ﻫﺎي ﺻﻔﺤﻪ3 و دﻳﮕﺮ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻫﺎي ‪ UI‬و ﻫﻤﭽﻨﻴﻦ ﻧﺤﻮه اﺗﺼﺎل ﻓﺮﻣﺎن4ﻫﺎ ﺑﻪ‬
                                                                                ‫ﻛﺎﻣﭙﻮﻧﻨﺖ ﻫﺎ ﻫﺴﺘﻴﺪ.‬
    ‫• ‪ :Screen Designer‬اﻳﻦ ﻣﺤﻴﻂ ﺷﻤﺎ را ﻗـﺎدر ﺑـﻪ ﻃﺮاﺣـﻲ و اﺻـﻼح ﺻـﻔﺤﻪ ﻫـﺎي داﺧـﻞ ﺑﺮﻧﺎﻣـﻪ‬
                                                                                          ‫ﻣﻲ ﻧﻤﺎﻳﺪ.‬

       ‫1‬
         ‫‪Visual Mobile Designer‬‬
       ‫2‬
         ‫‪New File‬‬
       ‫3‬
         ‫‪Screen‬‬
       ‫4‬
         ‫‪Command‬‬

                                                      ‫6‬
  ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                     ‫‪www.txt.ir‬‬



    ‫• ﭘﻨﺠﺮه ‪ :Inspector‬اﻳﻦ ﭘﻨﺠﺮه ﻳﻚ ﺳﺎﺧﺘﺎر درﺧﺘﻲ از ﻫﻤـﻪ ﻛﺎﻣﭙﻮﻧﻨـﺖ ﻫـﺎي ﻣﻮﺟـﻮد در آرﺷـﻴﻮ‬
                          ‫ﺑﺮﻧﺎﻣﻪ ﺟﺎري را ﻧﻤﺎﻳﺶ ﻣﻲ دﻫﺪ ﻛﻪ ﺷﺎﻣﻞ ﺻﻔﺤﻪ ﻫﺎ، ﻓﺮﻣﺎن ﻫﺎ و ﻣﻨﺎﺑﻊ1 ﻣﻲ ﺑﺎﺷﺪ.‬
    ‫• ﭘﺎﻟﺖ ‪ :Component‬اﻳﻦ ﭘﺎﻟﺖ ﺷﺎﻣﻞ ﻫﻤﻪ اﺷﻴﺎء ﺟﺎوا اﺳﺖ ﻛﻪ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﺗﺎن اﺿﺎﻓﻪ‬
                                                                                             ‫ﻧﻤﺎﻳﻴﺪ.‬
    ‫• ﻣﺪﻳﺮﻳﺖ ﭘﺎﻟﺖ ‪ :Component‬ﺷﻤﺎ را ﻗﺎدر ﻣﻲ ﺳﺎزد ﻛﻪ ﺻﻔﺤﻪ ﻫﺎ و اﺷﻴﺎء ﺧﻮدﺗﺎن را ﺑـﻪ ﭘﺎﻟـﺖ‬
                                                                             ‫ﻛﺎﻣﭙﻮﻧﻨﺖ اﺿﺎﻓﻪ ﻧﻤﺎﻳﻴﺪ.‬
    ‫• ‪ :Projects Sheet‬اﻳﻦ ﺻﻔﺤﻪ ﺑﻪ ﻧﻤﺎﻳﺶ ﺗﻨﻈﻴﻤﺎت ﻗﺎﺑـﻞ اﺻـﻼح، ﺑـﺮاي ﻛﺎﻣﭙﻮﻧﻨـﺖ اﻧﺘﺨـﺎب ﺷـﺪه‬
                                                                                  ‫ﺟﺎري ﻣﻲ ﭘﺮدازد.‬


                                             ‫1-3- اﻳﺠﺎد ﻳﻚ ﭘﺮوژه ﺟﺪﻳﺪ در ﺣﺎﻟﺖ ‪VMD‬‬
                                                              ‫ﺑﺮاي اﻳﻦ ﻣﻨﻈﻮر ﺑﺎﻳﺪ ﻣﺮاﺣﻞ زﻳﺮ را اﻧﺠﺎم دﻫﻴﺪ:‬
    ‫1. از ﻣﻨـﻮي ﻓﺎﻳـﻞ ﮔﺰﻳﻨـﻪ ‪ (Ctrl-Shift-N) New Project‬را اﻧﺘﺨـﺎب ﻧﻤﺎﻳﻴـﺪ. در ﭘﻨﺠـﺮه ﺑـﺎز ﺷـﺪه در‬
    ‫ﻗﺴﻤﺖ ‪ Categories‬ﮔﺰﻳﻨﻪ ‪ Mobile‬ودر ﻗـﺴﻤﺖ ‪ Projects‬ﮔﺰﻳﻨـﻪ ‪ Mobile Application‬را‬
                                                    ‫اﻧﺘﺨﺎب ﻧﻤﻮده وﺳﭙﺲ دﻛﻤﻪ ‪ Next‬را ﻛﻠﻴﻚ ﻧﻤﺎﻳﻴﺪ.‬
    ‫2. ﺳﭙﺲ ﻳﻚ ﻧﺎم ﻣﺎﻧﻨﺪ ‪ myHello‬را در ﻓﻴﻠﺪ ‪ Project Name‬وارد ﻧﻤﺎﻳﻴﺪ. ﺳﭙﺲ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴـﺪ ﻣـﺴﻴﺮ‬
                      ‫ذﺧﻴﺮه ﺷﺪن ﭘﺮوژه را ﺗﻐﻴﻴﺮ داده و در ﻫﺮ ﻣﺴﻴﺮ دﻟﺨﻮاه از ﺳﻴﺴﺘﻢ ﺧﻮد آن را ﻗﺮار دﻫﻴﺪ.‬
    ‫3. ﭼـﻚ ﻧﻤﺎﻳﻴـﺪ ﻛـﻪ دو ﭼـﻚ ﺑـﺎﻛﺲ ‪ Set as Main Project‬و ‪ Create Hello MIDlet‬ﺗﻴـﻚ‬
                                    ‫ﺧﻮرده ﺑﺎﺷﻨﺪ )اﻟﺒﺘﻪ اﻳﻦ دو ﮔﺰﻳﻨﻪ ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض اﻧﺘﺨﺎب ﺷﺪه اﻧﺪ(.‬
    ‫4. ﺳﭙﺲ 2.2 ‪ J2ME Wireless Toolkit‬را ﺑـﻪ ﻋﻨـﻮان ‪ Emulator Platform‬اﻧﺘﺨـﺎب ﻧﻤـﻮده و‬
                                    ‫ﻧﺴﺨﻪ ‪ MIDP‬و ‪ CLDC‬را ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﻧﻮع وﺳﻴﻠﻪ ﺧﻮد ﺗﻌﻴﻴﻦ ﻧﻤﺎﻳﻴﺪ.‬
    ‫5. ﻛﻠﻴﺪ ‪ Finish‬را ﻛﻠﻴﻚ ﻧﻤﺎﻳﻴﺪ. ﻣﺤﻴﻂ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺑﺮاي ﺷﻤﺎ در ﻣـﺴﻴﺮ اﻧﺘﺨـﺎب ﻛـﺮده در ﻣﺮاﺣـﻞ ﻗﺒـﻞ‬
    ‫ﻳﻚ ﭘﻮﺷﻪ ﺑـﺎ ﻧـﺎم ‪ …/myHello‬اﻳﺠـﺎد ﻣـﻲ ﻧﻤﺎﻳـﺪ. اﻳـﻦ ﭘﻮﺷـﻪ ﭘـﺮوژه ﺷـﺎﻣﻞ ﻫﻤـﻪ ﻓﺎﻳـﻞ ﻫـﺎي ﻣﻨﺒـﻊ و‬
                                        ‫ﻣﺘﺎدﻳﺘﺎ2ﻫﺎي ﭘﺮوژه ﺷﻤﺎ از ﻗﺒﻴﻞ ‪ Project Ant Script‬ﻣﻲ ﺑﺎﺷﺪ.‬
                      ‫ﺑﺮﻧﺎﻣﻪ ﺧﻮدش را در ﭘﻨﺠﺮه ‪ Flow Design‬از ﺣﺎﻟﺖ ‪ VMD‬ﺑﻪ ﻧﻤﺎﻳﺶ ﻣﻲ ﮔﺬارد.‬




       ‫1‬
           ‫‪Resource‬‬
       ‫2‬
           ‫‪MetaData‬‬

                                                      ‫7‬
  ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬            ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬                    ‫‪www.txt.ir‬‬




                                ‫ﺷﻜﻞ 1-2- اﺟﺮاي ﻳﻚ ﭘﺮوژه ﺟﺪﻳﺪ در ﺣﺎﻟﺖ ‪VMD‬‬




                                                                           ‫اﺻﻼح ﻛﺪ ﻣﻨﺒﻊ ﺟﺎوا‬
    ‫ﺷﻤﺎ ﻫﻤﭽﻨﻴﻦ ﻣﻲ ﺗﻮاﻧﻴﺪ ﻣﺘﻦ ﻧﻤﺎﻳﺶ داده ﺷﺪه ﺑﻪ وﺳﻴﻠﻪ ‪ MIDlet‬را اﺻﻼح ﻧﻤﺎﻳﻴﺪ. ﺑﺮاي اﻳﻦ ﻣﻨﻈـﻮر اﻳـﻦ‬
                                                                                  ‫اﻋﻤﺎل را اﻧﺠﺎم دﻫﻴﺪ:‬
    ‫1. ﺑــﺮ روي ‪ Screen Design‬از ‪ Toolbar‬ﻛﻠﻴــﻚ ﻧﻤﺎﻳﻴــﺪ. ﺑــﺎ اﻳــﻦ ﻋﻤــﻞ ﭘﻨﺠــﺮه ‪Screen‬‬
               ‫‪ Designer‬ﺑﺎز ﻣﻲ ﺷﻮد و ﺑﺮاي ﺷﻤﺎ ﻣﺤﺘﻮﻳﺎت ﻓﺮم ‪ helloForm‬را ﻧﻤﺎﻳﺶ ﻣﻲ دﻫﺪ.‬
    ‫2. ﺷﻤﺎ ﺑﺎ داﺑﻞ ﻛﻠﻴﻚ ﺑﺮ روي ﻣﺘﻦ "!‪ "Hello World‬در ﭘﺮوژه اﻳﺠﺎد ﻛﺮده آن را ﺑﻪ ﺣﺎﻟﺖ اﻧﺘﺨﺎب‬
                               ‫در آورده و ﻫﺮ ﻣﺘﻦ دﻟﺨﻮاﻫﻲ را ﻣﻲ ﺗﻮاﻧﻴﺪ در داﺧﻞ آن وارد ﻧﻤﺎﻳﻴﺪ.‬




                                                     ‫8‬
  ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                   ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬



                                                                           ‫1-4- اﺟﺮاي ﻳﻚ ﺑﺮﻧﺎﻣﻪ ‪MIDP‬‬
    ‫ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﺷﻤﺎ ﻳﻚ ﺑﺮﻧﺎﻣﻪ ‪ MIDP‬را اﺟﺮا ﻣﻲ ﻧﻤﺎﻳﻴﺪ. ﻣﺤﻴﻂ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ، ﻋﻤﻠﻴﺎت ﻛﺎﻣﭙﺎﻳﻞ، ﭘﻴﺶ ﺷﻨﺎﺳﺎﻳﻲ‬
    ‫و ﺳﺎﺧﺘﻦ ﺑﺮﻧﺎﻣﻪ را ﺑﺮ ﻃﺒﻖ ﭘﻴﻜﺮﺑﻨﺪي ﻫﺎي ﻧﺼﺐ ﺷﺪه ﺑﺮاي ﭘﺮوژه ﺟﺎري ﺑﻪ ﻋﻨﻮان ﻳﻚ ‪ MIDlet‬اﺟﺮا ﻣـﻲ ﻧﻤﺎﻳـﺪ.‬
                                                                     ‫ﺧﺮوﺟﻲ در ﻳﻚ اﻳﻤﻮﻻﺗﻮر1 ﻧﻤﺎﻳﺶ داده ﻣﻲ ﺷﻮد.‬
    ‫ﻫﻤﭽﻨﻴﻦ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﭘﺮوژه اﺻﻠﻲ 2ﻳﺎ ﻫﺮ ﭘﺮوژه ﻣﺠﺰاي دﻳﮕﺮي ﻛﻪ ﺷﺎﻣﻞ ﻳـﻚ ﻛـﻼس ﻗﺎﺑـﻞ اﺟـﺮا ﺑﺎﺷـﺪ را‬
                                                                                                    ‫اﺟﺮا ﻧﻤﺎﻳﻴﺪ.‬
                          ‫ﺑﺮاي اﺟﺮاي ﻳﻚ ﭘﺮوژه در ﻧﺖ ﺑﻴﻨﺰ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﻳﻜﻲ از ﭼﻬﺎر ﻋﻤﻞ زﻳﺮ را اﻧﺠﺎم دﻫﻴﺪ:‬
                                        ‫• از ﻃﺮﻳﻖ ﻣﻨﻮي ‪ Run‬و اﻧﺘﺨﺎب ﮔﺰﻳﻨﻪ ‪Run Main Project‬‬
                                                                                     ‫• ﻓﺸﺮدن ﻛﻠﻴﺪ 6‪F‬‬
                                                      ‫(‬        ‫• از ﻃﺮﻳﻖ ﻓﺸﺮدن آﻳﻜﻮن اﺟﺮاي ﭘﺮوژه اﺻﻠﻲ)‬
              ‫• از ﻃﺮﻳﻖ راﺳﺖ ﻛﻠﻴﻚ ﺑﺮ روي ﭘﺮوژه در ﭘﻨﺠﺮه ‪ Project‬و اﻧﺘﺨﺎب ﮔﺰﻳﻨﻪ ‪Run Project‬‬




                                     ‫ﺷﻜﻞ1-3 - اﺟﺮاي ﻳﻚ ﭘﺮوژه در اﻳﻤﻮﻻﺗﻮر‬


                                                          ‫1-5- اﺟﺮاي ﭘﺮوژه ﺑﺎ ﻳﻚ اﻳﻤﻮﻻﺗﻮر ﻣﺘﻔﺎوت‬
    ‫ﺑﺮاي اﻳﻦ ﻣﻨﻈﻮر ﺷﻤﺎ ﺑﺎﻳﺪ اﺑﺘﺪا ﺑﺮ روي ﭘﺮوژه راﺳﺖ ﻛﻠﻴﻚ ﻧﻤﻮده و ﮔﺰﻳﻨﻪ ‪ Quick Run With‬را اﻧﺘﺨـﺎب‬
                  ‫ﻧﻤﺎﻳﻴﺪ. ﺳﭙﺲ از ﻟﻴﺴﺖ ﻛﺸﻮﻳﻲ ﻛﻪ ﺷﺎﻣﻞ اﻳﻤﻮﻻﺗﻮر ﻫﺎي ﻧﺼﺐ ﺷﺪه ﻣﻲ ﺑﺎﺷﺪ ﻳﻜﻲ را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ.‬
    ‫ﭘﺮوژه ﺑﺮاي اﺟﺮا از ﻃﺮﻳﻖ ﺗﻮزﻳﻊ ﻓﺎﻳﻞ ‪ JAR‬اﺳﺘﻔﺎده ﻣﻲ ﻧﻤﺎﻳﺪ و ﻧﻴﺎزي ﺑﻪ ﺳﺎﺧﺖ دوﺑﺎره ﭘـﺮوژه ﻗﺒـﻞ از اﺟـﺮاي آن‬
                                                                                                         ‫ﻧﻴﺴﺖ.‬


       ‫1‬
           ‫‪Emulator‬‬
       ‫2‬
           ‫‪Main Project‬‬

                                                           ‫9‬
  ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                    ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                   ‫‪www.txt.ir‬‬



                                                                  ‫1-6- اﺿﺎﻓﻪ ﻛﺮدن ﻳﻚ ‪MIDlet‬‬
                               ‫ﺑﺮاي اﺿﺎﻓﻪ ﻛﺮدن ﻳﻚ ‪ MIDlet‬ﺟﺪﻳﺪ ﺑﻪ ﭘﺮوژه ﺑﺎﻳﺪ ﺳﻪ ﻋﻤﻞ زﻳﺮ را اﻧﺠﺎم دﻫﻴﺪ:‬
                     ‫1. اﺑﺘﺪا ﻳﻚ ﭘﺮوژه را اﻧﺘﺨﺎب ﻧﻤﻮده و از ﻣﻨﻮي ﻓﺎﻳﻞ ﮔﺰﻳﻨﻪ ‪ New File‬را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ.‬
    ‫2. در ﭘﻨﺠﺮه ﺑﺎز ﺷﺪه از ﻗﺴﻤﺖ ‪ Categories‬ﮔﺰﻳﻨﻪ ‪ MIDP‬و در ﻗـﺴﻤﺖ ‪ FileType‬ﮔﺰﻳﻨـﻪ ‪MIDlet‬‬
                                                                                    ‫را اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ.‬
                                      ‫3. ﺳﭙﺲ ﻓﺎﻳﻞ اﻟﮕﻮي ﺧﻮد را ﺑﺮ ﺣﺴﺐ ﻧﻴﺎزﻫﺎﻳﺘﺎن ﺑﻪ آن اﺧﺘﺼﺎص دﻫﻴﺪ.‬


                                                                             ‫1-7- ‪MIDP Screens‬‬
    ‫ﺑﺎ ﺗﻮﺟﻪ ﺑـﻪ ﺻـﻔﺤﻪ ﻫـﺎي ﻧﻤـﺎﻳﺶ ﻛﻮﭼـﻚ و ﺣﺎﻓﻈـﻪ ﻣﺤـﺪود و ﻗـﺪرت ﭘـﺮدازش ﺑـﺮ روي وﺳـﺎﻳﻞ ﻫﻨﺪﻫﻠـﺪ1،‬
    ‫‪ MIDP‬از ﻳﻚ ﻛﻼس ﺧﺎص ﻛﻪ ‪ Displayable‬ﻧﺎﻣﻴﺪه ﻣﻲ ﺷﻮد ﺑﺮاي ﻧﻤﺎﻳﺶ ﻳﻚ ‪ UI‬روي وﺳـﺎﻳﻞ ﺑـﻪ ﺟـﺎي‬
                                                                   ‫ﺳﻴﺴﺘﻢ ﭘﻨﺠﺮه ﺑﻨﺪي ﻣﻌﻤﻮﻟﻲ اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﺪ.‬
     ‫ﻳﻚ ‪ Displayable‬از ﻧﻈﺮ رﻓﺘﺎري ﻣﺸﺎﺑﻪ ﺑﺎ ﻳﻚ ﭘﻨﺠﺮه اﺳﺖ، ﺑﺎ اﻳﻦ ﺗﻔﺎوت ﻛﻪ ﻓﻘﻂ ﻳـﻚ ‪Dispalyable‬‬
    ‫ﻣﻲ ﺗﻮاﻧﺪ در ﻫﺮ زﻣﺎن ﻗﺎﺑﻞ ﻧﻤﺎﻳﺶ ﺑﺎﺷﺪ. در ﻳﻚ ﺑﺮﻧﺎﻣﻪ ‪ ،MIDP‬ﻛﺎﻣﭙﻮﻧﻨﺖ ﻫﺎي ‪ Displayable‬ﮔﻮﻧﺎﮔﻮن ﻣﺎﻧﻨـﺪ‬
    ‫ﻳﻚ دﺳﺘﻪ ﻛﺎرت ﺑﺮروي ﻳﻜﺪﻳﮕﺮ ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ.ﻛﺎرﺑﺮ ﻣﺠﻤﻮﻋﻪ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻫـﺎي ‪ Displayable‬را ﻳﻜـﻲ ﻳﻜـﻲ‬
    ‫ﭘﺸﺖ ﺳﺮ ﻣﻲ ﮔﺬارد ﺗﺎ ﻋﻤﻠﻴﺎت ﻛﺎﻣﻞ ﺷﻮد. ﺟﺎﺑﻪ ﺟﺎﻳﻲ ﺑﻴﻦ دﺳﺘﻪ ‪ Displayable‬ﻫﺎ ﻣﻲ ﺗﻮاﻧﺪ ﺧﻄﻲ ﻳﺎ ﻏﻴﺮ ﺧﻄـﻲ‬
      ‫ﺑﺎﺷﺪ، اﻣﺎ ﺑﺎﻳﺪ ﺑﺮاي ﻛﺎرﺑﺮ روﺷﻦ ﺑﺎﺷﺪ ﻛﻪ ﺑﺮاي ﺟﺎﺑﻪ ﺟﺎﻳﻲ ﺑﻪ ‪ Displayable‬ﺑﻌﺪي ﭼﻪ ﻛﺎري ﺑﺎﻳﺪ اﻧﺠﺎم دﻫﺪ.‬
    ‫ﻛﻼس ‪ Displayable‬دو زﻳﺮ ﻛـﻼس دارد: ‪ Canvas‬و ‪ .Screen‬ﺷـﺶ ﻧـﻮع از ﻛﺎﻣﭙﻮﻧﻨـﺖ ﻫـﺎﻳﻲ ﻛـﻪ از‬
                                                                            ‫‪ Screen‬ﻣﺸﺘﻖ ﺷﺪه اﻧﺪ ﻋﺒﺎرﺗﻨﺪ از:‬
                                                                                      ‫‪Alert‬‬       ‫•‬
                                                                                      ‫‪Form‬‬        ‫•‬
                                                                                        ‫‪List‬‬      ‫•‬
                                                                                   ‫‪TextBox‬‬        ‫•‬
                                                                               ‫‪SplashScreen‬‬       ‫•‬
                                                                                ‫‪WaitScreen‬‬        ‫•‬

    ‫ﺷﻤﺎ ﺑﺎ ‪ Canvas‬و ﻫﻤﻪ ﻛﻼس ﻫﺎي ‪ Screen‬ﺑﺮ ﺣﺴﺐ ﻧﻮع رﻓﺘﺎر ﺷﺎن ﺑﺎ ﺑﻴﺮون، رﻓﺘـﺎر ﻣـﻲ ﻛﻨﻴـﺪ. ﻃﺮاﺣـﻲ‬
    ‫‪ UI‬ﺑﺮاي ﺻﻔﺤﻪ ﻫﺎي ‪ Displayable‬ﺑﻪ ﺳﺎدﮔﻲ اﻣﻜﺎن ﭘﺬﻳﺮ اﺳﺖ. ﻓﻘﻂ ﺑﺎﻳﺪ ﻫﺮ ﺻﻔﺤﻪ را ﺑﻪ ﻳﻚ وﻇﻴﻔـﻪ ﺧـﺎص‬
                                         ‫ﻣﺤﺪود ﻧﻤﺎﻳﻴﺪ و ﺑﺮاي ﺟﺎﺑﻪ ﺟﺎﻳﻲ ﺑﻴﻦ ﺻﻔﺤﺎت از ﻓﺮﻣﺎن ﻫﺎ اﺳﺘﻔﺎده ﻧﻤﺎﻳﻴﺪ.‬




       ‫1‬
           ‫‪Device Hand Held‬‬

                                                     ‫01‬
  ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬           ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬



    ‫وﻗﺘﻲ ﺷﻤﺎ از ﺣﺎﻟﺖ ‪ VMD‬ﺑﺮاي ﭘﺮوژه ﺧﻮد اﺳﺘﻔﺎده ﻣﻲ ﻧﻤﺎﻳﻴﺪ، ﻛﺎر ﺑﺎ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻫﺎي ﺻﻔﺤﻪ1 ﺑـﺴﻴﺎر راﺣـﺖ‬
    ‫اﺳﺖ و ﻓﻘﻂ ﺷﻤﺎ ﻛﺎﻓﻲ اﺳﺖ ﻛﻪ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻣﻮرد ﻧﻈﺮ ﺧﻮد را ﺑـﺮ روي ﺻـﻔﺤﻪ ‪ Flow Designe‬ﻗـﺮار دﻫﻴـﺪ و‬
              ‫ﺗﻨﻈﻴﻤﺎت آن را در ﭘﻨﺠﺮه ‪ properties‬اﻧﺠﺎم دﻫﻴﺪ. ﻛﺪ ﻣﺮﺑﻮط ﺑﻪ آن ﺑﻪ ﻃﻮر ﺧﻮدﻛﺎر ﺗﻮﻟﻴﺪ ﺧﻮاﻫﺪ ﺷﺪ.‬
    ‫‪ Canvas‬ﺑﺮروي ﭘﺎﻟﺖ ﻗﺮار ﻧﺪارد زﻳﺮا ﺑﺮاي اﺳﺘﻔﺎده از ﻳﻚ ‪ ،Canvas‬ﺷﻤﺎ ﺑﺎﻳﺪ ﺑﺎ ﭘﻴﺎده ﺳﺎزي ﻣﺘـﺪ ﻛـﻼس‬
                    ‫)(‪ paint‬در زﻳﺮ ﻛﻼﺳﺶ، آن را ﻓﺮاﻫﻢ ﻧﻤﺎﻳﻴﺪ. زﻳﺮا ﻃﺮاح ‪ UI‬ﻧﻤﻲ ﺗﻮاﻧﺪ اﻳﻦ ﻛﺎر را اﻧﺠﺎم دﻫﺪ.‬
                                  ‫در ﺷﻜﻞ 1-4 ﭘﺎﻟﺖ ‪ MIDP‬را ﺑﻪ ﻫﻤﺮاه ﻛﺎﻣﭙﻮﻧﻨﺖ ﻫﺎي آن ﻣﺸﺎﻫﺪه ﻣﻲ ﻧﻤﺎﻳﻴﺪ.‬




                                        ‫ﺷﻜﻞ1-4– ﭘﺎﻟﺖ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻫﺎي ‪MIDP‬‬




                                                 ‫1-8- ﻣﻌﺮﻓﻲ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻫﺎي ﻗﺴﻤﺖ ‪Screens‬‬

                                                                            ‫1-8-1-ﻛﺎﻣﭙﻮﻧﻨﺖ ‪Alert‬‬
    ‫ﻳﻚ ‪ Alert‬ﻋﺒﺎرت اﺳﺖ از ﻳﻚ ﻣﺘﻦ ﺑﻪ ﻫﻤﺮاه ﻳﻚ آﻳﻜﻮن ﻛﻪ ﺑﻪ ﻛﺎرﺑﺮ ﻧﺸﺎن داده ﻣـﻲ ﺷـﻮد و ﺑـﺮاي ﻣـﺪت‬
    ‫زﻣﺎن ﻣﺸﺨﺼﻲ ﻗﺒﻞ از ﺑﺴﺘﻪ ﺷﺪن ﻳﺎ ﺗﺎ زﻣـﺎﻧﻲ ﻛـﻪ ﻛـﺎرﺑﺮ ﺻـﻔﺤﻪ را ﺑﺒﻨـﺪد، ﻣﻨﺘﻈـﺮ ﻣـﻲ ﻣﺎﻧـﺪ. ‪ Alert‬اﺻـﻮﻻً ﺑـﺮاي‬
    ‫ﮔﺰارش ﺧﻄﺎﻫﺎ و ﺳﺎﻳﺮ ﺷﺮاﻳﻂ اﺳﺘﺜﻨﺎﻳﻲ دﻳﮕﺮ ﺑﻪ ﻛﺎر ﻣﻲ رود. ﺷﻤﺎ ﻛﻨﺘﺮل ﻣﺤﺪودي روي ﻻﻳﻪ ﻫﺎي اﻳـﻦ ﻛﺎﻣﭙﻮﻧﻨـﺖ‬




       ‫1‬
           ‫‪Screen‬‬

                                                     ‫11‬
  ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬



    ‫دارﻳﺪ. ﻳﻚ ‪ Alert‬ﻣﻲ ﺗﻮاﻧﺪ از ﻳﻚ ‪ AlertType‬ﺑﺮاي ﻣـﺸﺨﺺ ﻛـﺮدن ﻧـﻮع ﻫـﺸﺪار و ﭘﺨـﺶ ﻳـﻚ ﺻـﺪاي‬
                                                                   ‫ﻣﻨﺎﺳﺐ در زﻣﺎن ﺑﺎز ﺷﺪن آن اﺳﺘﻔﺎده ﻧﻤﺎﻳﺪ.‬
                                                             ‫ﺗﻌﺪادي از ﻣﺘﺪﻫﺎي ﻣﻬﻢ اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻋﺒﺎرﺗﻨﺪ از:‬
    ‫• ‪ :getDefaultTimeout‬زﻣﺎن ﭘﻴﺶ ﻓﺮض ﺑﺮاي ﻧﻤﺎﻳﺶ ﻳﻚ ‪ Alert‬را ﺑﺮ ﺣﺴﺐ ﻣﻴﻠﻲ ﺛﺎﻧﻴﻪ ﺑـﺮ‬
                                                                                 ‫ﻣﻲ ﮔﺮداﻧﺪ.‬
         ‫• ‪ :getTimeout‬ﻣﻘﺪار زﻣﺎﻧﻲ را ﻛﻪ اﻳﻦ ‪ Alert‬ﻧﻤﺎﻳﺶ داده ﺧﻮاﻫﺪ ﺷﺪ، را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ.‬
              ‫• ‪ :getString‬رﺷﺘﻪ ﻣﺘﻨﻲ را ﻛﻪ ﺑﺮاي ﻧﻤﺎﻳﺶ در ‪ Alert‬اﺳﺘﻔﺎده ﺷﺪه را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ.‬
               ‫• ‪ :setTimeout‬ﻣﻘﺪار زﻣﺎن ﻣﻮرد ﻧﻈﺮ ﺑﺮاي ﻧﻤﺎﻳﺶ ‪ Alert‬را ﻣﻘﺪار دﻫﻲ ﻣﻲ ﻧﻤﺎﻳﺪ.‬
                           ‫• ‪ :setImage‬ﻋﻜﺲ ﻣﻮرد اﺳﺘﻔﺎده در ‪ Alert‬را ﻣﻘﺪار دﻫﻲ ﻣﻲ ﻧﻤﺎﻳﺪ.‬
                              ‫• ‪ :setString‬ﻣﺘﻦ ﻣﻮرد اﺳﺘﻔﺎده در ‪ Alert‬را ﻣﻘﺪار دﻫﻲ ﻣﻲ ﻧﻤﺎﻳﺪ.‬
                                           ‫ﺗﻜﻪ ﻛﺪ زﻳﺮ ﻧﺤﻮه اﻳﺠﺎد وﻛﺎرﺑﺮد ﻳﻚ ‪ Alert‬را ﻧﻤﺎﻳﺶ ﻣﻲ دﻫﺪ.‬




                                                                          ‫1-8-2-ﻛﺎﻣﭙﻮﻧﻨﺖ ‪Form‬‬
    ‫ﻓﺮم ﺗﻨﻬﺎ ﻛﺎﻣﭙﻮﻧﻨﺖ ‪ MIDP‬اﺳﺖ ﻛﻪ ﻣﻲ ﺗﻮاﻧﺪ ﺷﺎﻣﻞ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻫﺎي دﻳﮕﺮ ﺷﻮد. ﻓﺮم ﻳﻚ ﻛﺎﻣﭙﻮﻧﻨﺘﻲ اﺳﺖ ﻛﻪ‬
                                                                    ‫ﺑﻴﺸﺘﺮ در اﻳﺠﺎد ﻳﻚ ‪ UI‬اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد.‬
    ‫ﺷﻤﺎ ﺑﻪ ﻃﻮر ﺗﺌﻮري ﻣﻲ ﺗﻮاﻧﻴﺪ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻫﺎي زﻳﺎدي در ﻳﻚ ﻓﺮم آن ﮔﻮﻧﻪ ﻛﻪ ﻣﻲ ﺧﻮاﻫﻴﺪ ﻗـﺮار دﻫﻴـﺪ، اﻣـﺎ ﺑـﺎ‬
    ‫ﺗﻮﺟﻪ ﺑﻪ ﻧﺎﺣﻴﻪ ﻧﻤﺎﻳﺶ ﻛﻮﭼﻚ ﺗﻠﻔﻦ ﻫﺎي ﻫﻤﺮاه ﺷﻤﺎ ﺑﺎﻳﺪ ﻫﺮ ﻓﺮم را ﺑﻪ ﻳﻚ وﻇﻴﻔﻪ ﺧﺎص ﻣﺤﺪود ﻧﻤﺎﻳﻴـﺪ. ﻫﻤﭽﻨـﻴﻦ‬
    ‫ﻃﻮل ﻳﻚ ﺻﻔﺤﻪ را ﻧﻴﺰ ﺑﺎﻳﺪ ﻣﺤﺪود ﻧﻤﺎﻳﻴﺪ ﻛﻪ ﻛﺎرﺑﺮ ﻧﻴﺎزي ﺑﻪ ﭘﻴﻤﺎﻳﺶ ﺑﻴﺸﺘﺮ از ﺳﻪ ﻳﺎ ﭼﻬﺎر ﺻـﻔﺤﻪ ﺑـﺮ روي وﺳـﻴﻠﻪ‬
        ‫ﻣﻘﺼﺪ ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ. اﻳﻦ ﻣﻮرد ﻛﺎراﻳﻲ وﺳﻴﻠﻪ را اﻓﺰاﻳﺶ ﻣﻲ دﻫﺪ و آن را ﺑﺮاي ﭘﻴﻤﺎﻳﺶ ﻛﺎرﺑﺮ راﺣﺘﺘﺮ ﻣﻲ ﺳﺎزد.‬

                                                   ‫21‬
  ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬



    ‫در ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ 0.1 ‪ MIDP‬ﺗﻮﺳﻌﻪ دﻫﻨﺪه ﺑﺮﻧﺎﻣﻪ، ﻛﻨﺘﺮﻟﻲ ﺑﺮ روي آراﻳﺶ1 ﻛﺎﻣﭙﻮﻧﻨـﺖ در ﻳـﻚ ﻓـﺮم ﻧـﺪارد.‬
    ‫ﺗﻨﻬﺎ ﭼﻴﺰي ﻛﻪ ﻣﻲ ﺗﻮاﻧﻴﺪ درﺑﺎره ﻣﻜﺎن ﻛﻨﺘﺮل ﻛﻨﻴﺪ، ﻧﻈـﻢ ﻛﺎﻣﭙﻮﻧﻨـﺖ ﻫـﺎي ﮔﻮﻧـﺎﮔﻮن در ﻓـﺮم اﺳـﺖ. ﺗﻘﺮﻳﺒـﺎً ﻣـﺸﺎﺑﻪ‬
                                                                              ‫آراﻳﺶ ﻋﻤﻮدي در ‪ J2SE‬اﺳﺖ.‬
    ‫در 0.2 ‪ MIDP‬ﺷﻤﺎ ﺗﺎ ﺣﺪي ﺑﺮ روي آراﻳﺶ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻫﺎ ﺑﺮ روي ﻓﺮم ﻛﻨﺘﺮل دارﻳﺪ. ﻧﺖ ﺑﻴﻨﺰ ﻳﻚ ﺧﺎﺻﻴﺖ‬
    ‫ﺑﻪ ﻧﺎم ‪ Layout‬دارد ﻛﻪ ﺑﻪ ﺷﻤﺎ اﺟﺎزه ﻣـﻲ دﻫـﺪ ﺗـﺎ ﺗﺮازﺑﻨـﺪي اﻓﻘـﻲ، ﻋﻤـﻮدي و ﻧﺤـﻮه ﭘـﺮ ﻛـﺮدن2 ﻛﺎﻣﭙﻮﻧﻨـﺖ را‬
                                                                                              ‫ﻣﺸﺨﺺ ﻧﻤﺎﻳﻴﺪ.‬
                                                              ‫ﺗﻌﺪادي از ﻣﺘﺪﻫﺎي ﻣﻬﻢ اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻋﺒﺎرﺗﻨﺪ از :‬
                                         ‫• ‪ :addCommand‬ﻳﻚ ﻓﺮﻣﺎن را ﺑﻪ ﻓﺮم اﺿﺎﻓﻪ ﻣﻲ ﻧﻤﺎﻳﺪ.‬
                    ‫• ‪ : Append‬ﻳﻚ ﻋﻜﺲ ﻳﺎ ﻳﻚ رﺷﺘﻪ ﻣﺘﻨﻲ ﻳﺎ ﻳﻚ ﻋﻨﺼﺮ را ﺑﻪ ﻓﺮم اﺿﺎﻓﻪ ﻣﻲ ﻧﻤﺎﻳﺪ.‬
    ‫• )‪ :Delete(int itemnum‬ﻋﻨﺼﺮي راﻛﻪ ﺷﻤﺎره آن ﺑﻪ ﻋﻨﻮان ورودي داده ﺷﺪه اﺳﺖ را ﭘـﺎك‬
                                                                                     ‫ﻣﻲ ﻧﻤﺎﻳﺪ.‬
                                            ‫• ‪ : deleteAll‬ﻫﻤﻪ ﻋﻨﺎﺻﺮ روي ﻓﺮم را ﭘﺎك ﻣﻲ ﻧﻤﺎﻳﺪ.‬
                           ‫ﻛﺪ زﻳﺮﻧﺤﻮه اﻳﺠﺎد ﻛﺎﻣﭙﻮﻧﻨﺖ ‪ Form‬و اﺿﺎﻓﻪ ﻛﺮدن آﻳﺘﻢ ﻫﺎ را ﺑﻪ آن را ﻧﺸﺎن ﻣﻲ دﻫﺪ.‬




       ‫1‬
           ‫‪Layout‬‬
       ‫2‬
           ‫‪Fill‬‬

                                                     ‫31‬
  ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬            ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                    ‫‪www.txt.ir‬‬



                                                                           ‫1-8-3-ﻛﺎﻣﭙﻮﻧﻨﺖ ‪List‬‬
                        ‫از اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﺑﺮاي ﻧﻤﺎﻳﺶ و اﻧﺘﺨﺎب ﻳﻚ ﻟﻴﺴﺖ در ﺳﻪ ﺣﺎﻟﺖ زﻳﺮ اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد:‬
                                  ‫• ‪ :IMPLICT‬از اﻳﻦ ﺣﺎﻟﺖ ﻣﻲ ﺗﻮان ﺑﺮاي اﻳﺠﺎد ﻳﻚ ﻣﻨﻮ اﺳﺘﻔﺎده ﻧﻤﻮد.‬
              ‫• ‪ :EXCLUSIVE‬از اﻳﻦ ﺣﺎﻟﺖ ﻣﻲ ﺗﻮان ﺑﺮاي اﻳﺠﺎد ﻳﻚ ﻟﻴﺴﺖ اﻧﺘﺨﺎب ﻣﻨﻔﺮد اﺳﺘﻔﺎده ﻧﻤﻮد.‬
                   ‫• ‪ :MULTIPLE‬از اﻳﻦ ﺣﺎﻟﺖ ﺑﺮاي اﻳﺠﺎد ﺣﺎﻟﺖ ﺑﻴﺶ ازﻳﻚ اﻧﺘﺨﺎب اﺳﺘﻔﺎده ﻣﻲ ﮔﺮدد.‬
                                                                ‫ﺗﻌﺪادي از ﻣﺘﺪﻫﺎي اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻋﺒﺎرﺗﻨﺪ از:‬
      ‫• )‪ : getImage(int elementnum‬ﻋﻜــﺲ ﻗــﺴﻤﺘﻲ از ﻟﻴــﺴﺖ را ﻛــﻪ ﺑــﻪ وﺳــﻴﻠﻪ ﭘــﺎراﻣﺘﺮ‬
                                                  ‫‪ elementnum‬ﻣﺸﺨﺺ ﺷﺪه را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ.‬
    ‫• )‪ : getString(int elementnum‬ﻣﺘﻦ ﻗﺴﻤﺘﻲ از ﻟﻴﺴﺖ را ﻛﻪ ﺑﻪ وﺳﻴﻠﻪ ﭘـﺎراﻣﺘﺮ ‪elementnum‬‬
                                                             ‫ﻣﺸﺨﺺ ﺷﺪه اﺳﺖ را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ.‬
             ‫• )(‪ :getSelectedIndex‬ﺷﻤﺎره آﻳﺘﻤﻲ از ﻟﻴﺴﺖ را ﻛﻪ اﻧﺘﺨﺎب ﺷﺪه اﺳﺖ ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ.‬
    ‫• )‪ : Append(String stringpart,Image imagepart‬اﻳﻦ ﮔﺰﻳﻨﻪ ﻳﻚ آﻳـﺘﻢ ﺑـﻪ ‪ List‬اﺿـﺎﻓﻪ‬
                                                                                      ‫ﻣﻲ ﻛﻨﺪ.‬
    ‫• ‪ :isSelected‬ﻳﻚ ﻣﻘﺪار ﺑﻮﻟﻴﻦ را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ ﻛﻪ ﻧﺸﺎن ﻣﻲ دﻫﺪ آﻳﺎ آﻳﺘﻢ ﻣﻮرد ﻧﻈﺮ اﻧﺘﺨـﺎب ﺷـﺪه‬
                                                                                         ‫اﺳﺖ.‬
                                         ‫ﻛﺪ زﻳﺮ ﻧﺤﻮه اﻳﺠﺎد و اﺳﺘﻔﺎده از ﻛﺎﻣﭙﻮﻧﻨﺖ ‪ List‬را ﻧﺸﺎن ﻣﻲ دﻫﺪ.‬




                                                  ‫41‬
  ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬            ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                   ‫‪www.txt.ir‬‬            ‫‪www.txt.ir‬‬



                                                                        ‫1-8-4-ﻛﺎﻣﭙﻮﻧﻨﺖ ‪TextBox‬‬
    ‫‪ TextBox‬ﻳﻚ ﻛﺎﻣﭙﻮﻧﻨﺘﻲ اﺳﺖ ﻛﻪ ﻛﺎرﺑﺮ ﻣﻲ ﺗﻮاﻧﺪ ﻣﺘﻦ ﻣﻮرد ﻧﻈـﺮ ﺧـﻮد را در آن وارد ﻧﻤـﻮده و وﻳـﺮاﻳﺶ‬
    ‫ﻧﻤﺎﻳﺪ. ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺣﺪاﻛﺜﺮ اﻧﺪازه آن را ﻣﺸﺨﺺ ﻧﻤﺎﻳﻴﺪ و ﻳﻚ ﻣﻘﺪار ﭘـﻴﺶ ﻓـﺮض ﺑـﺮاي ﺧﺎﺻـﻴﺖ ‪ String‬آن‬
    ‫ﻣﺸﺨﺺ ﻧﻤﺎﻳﻴﺪ. اﮔﺮ ﻣﺘﻨﻲ ﻛﻪ در ‪ Textbox‬ﻗﺮار دارد ﺑﻴﺸﺘﺮ از اﻳﻦ ﺑﺎﺷﺪ ﻛﻪ در ﻳـﻚ ﺻـﻔﺤﻪ ﻧﻤـﺎﻳﺶ داده ﺷـﻮد،‬
                                      ‫ﻛﺎرﺑﺮ ﻣﻲ ﺗﻮاﻧﺪ ﺑﺮاي دﻳﺪن ﻳﺎ وﻳﺮاﻳﺶ ﻫﺮ ﻗﺴﻤﺖ ﻣﺘﻦ آن را ﭘﻴﻤﺎﻳﺶ ﻧﻤﺎﻳﺪ.‬
    ‫‪ TextBox‬ﻗﻮاﻋﺪي را اﺳﺘﻔﺎده ﻣﻲ ﻛﻨـﺪ ﻛـﻪ ﺑـﻪ ﺑﺮﻧﺎﻣـﻪ ﻛـﺎرﺑﺮدي اﺟـﺎزه ﻣﺤـﺪود ﻛـﺮدن ورودي ﻛـﺎرﺑﺮ، در‬
              ‫ﻣﻮاردي ﻣﺎﻧﻨﺪ آدرس ﭘﺴﺖ اﻟﻜﺘﺮوﻧﻴﻜﻲ، ﻣﻘﺎدﻳﺮ ﻋﺪدي، ﺷﻤﺎره ﺗﻠﻔﻦ، ‪ URL‬و ﻛﻠﻤﻪ ﻋﺒﻮر را ﻣﻲ دﻫﺪ.‬




                                 ‫ﺷﻜﻞ 1-5- ﻣﺤﺪود ﻛﺮدن ورودي ﻛﺎرﺑﺮ در ‪TextBox‬‬


                                                   ‫ﺗﻜﻪ ﻛﺪ زﻳﺮ ﻧﺤﻮه اﻳﺠﺎد ﻳﻚ ‪ Textbox‬را ﻧﺸﺎن ﻣﻲ دﻫﺪ.‬




                                                    ‫51‬
  ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬        ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬                   ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬



                                                                   ‫1-8-5-ﻛﺎﻣﭙﻮﻧﻨﺖ ‪SplashScreen‬‬
    ‫اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﺷﺒﻴﻪ ﺑﻪ ﻛﺎﻣﭙﻮﻧﻨﺖ ‪ Alert‬ﻣﻲ ﺑﺎﺷﺪ، ﻛﻪ ﺑﻪ وﺳﻴﻠﻪ آن ﻣﻲ ﺗﻮاﻧﻴﺪ ﻳﻚ ﻋﻜﺲ ﺑـﺎ ﻓﺮﻣـﺖ ‪ PNG‬و‬
    ‫ﻳﻚ ﻣﺘﻦ ﻛﻮﺗﺎه را ﺑﺮاي ﻣﺪت زﻣﺎن ﻣﺸﺨﺺ ﺷﺪه ﻛﻪ ﺗﻮﺳـﻂ ﺧﺎﺻـﻴﺖ ‪ Timeout‬در ‪ SplashScreen‬ﺗﻌﻴـﻴﻦ‬
    ‫ﻣﻲ ﺷﻮد، ﻧﻤﺎﻳﺶ داد. ﻣﻘﺪار ﭘﻴﺶ ﻓﺮض اﻳﻦ ﺧﺎﺻﻴﺖ 0005 ﻣﻴﻜﺮوﺛﺎﻧﻴﻪ اﺳـﺖ. ﻫﻤﭽﻨـﻴﻦ ﺑﻌـﺪ از زﻣـﺎن ﺗﻌﻴـﻴﻦ ﺷـﺪه‬
    ‫ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﻃﻮر ﺧﻮدﻛﺎر ﺑﻪ اﺟﺮاي ﻋﻤﻠﻲ ﻛﻪ درﺧﺎﺻﻴﺖ ‪ Action Default‬ﺗﻌﻴﻴﻦ ﻛﺮدﻳﻢ ﻣﻲ ﭘﺮدازد. ﻣـﺜﻼً رواﻧـﻪ‬
                                                                                       ‫ﺷﺪن ﺑﻪ ﻳﻚ ﻓﺮم دﻳﮕﺮ.‬


                                                                      ‫1-8-6-ﻛﺎﻣﭙﻮﻧﻨﺖ ‪WaitScreen‬‬
    ‫از اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﺑﺮاي ﻣﻮاﻗﻌﻲ ﻛﻪ ﺑﺨﻮاﻫﻴﻢ ﻋﻤﻞ زﻣﺎن ﺑﺮي را اﻧﺠﺎم دﻫﻴﻢ و ﻛﺎرﺑﺮ را از اﻳﻦ ﻋﻤﻞ ﻣﻄﻠـﻊ ﻛﻨـﻴﻢ،‬
    ‫اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد. ﻣﺜﻼً ﻧﻤﺎﻳﺶ ﻣﺘﻦ " … ‪ "Wait until background task is complete‬ﺑﻪ ﻫﻤـﺮاه ﻳـﻚ‬
                                                                                          ‫ﺗﺼﻮﻳﺮ ﺳﺎﻋﺖ ﺷﻨﻲ.‬




                                     ‫ﺷﻜﻞ 1-6- اﺳﺘﻔﺎده از ﻛﺎﻣﭙﻮﻧﻨﺖ ‪WaitScreen‬‬



                                                           ‫1-9- ﻣﻌﺮﻓﻲ ﻓﺮﻣﺎن ﻫﺎي ﻣﻮﺟﻮد در ﭘﺎﻟﺖ‬
    ‫در اﻳﻦ ﻗﺴﻤﺖ ﻣﺎ داراي ﻫﺸﺖ ﻧﻮع ﻓﺮﻣﺎن ﻣﺨﺘﻠﻒ ﺑﺮاي ﻛﺎرﺑﺮدﻫﺎي ﺧﺎص ﻫﺮ ﻛﺪام ﻫﺴﺘﻴﻢ. اﻳـﻦ اﻧـﻮاع ﺷـﺎﻣﻞ‬
    ‫‪ Screen ،Item ،Ok ،Help ،Exit ، Cancel ، Back‬و ‪ Stop‬ﻣﻲ ﺑﺎﺷﺪ. ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑـﺎ ﺗﻮﺟـﻪ ﺑـﻪ ﻧﻴـﺎز‬
    ‫ﺑﺮﻧﺎﻣﻪ ﺧﻮد ﻫﺮ ﻛﺪام از اﻳﻦ اﻧﻮاع را ﻛﻪ ﺧﻮاﺳﺘﻴﺪ ﺑﺮ روي ﻓﺮم ﺧـﻮد ﻛـﺸﻴﺪه و ﺑـﺎ ﻛﻠﻴـﻚ ﺑـﺮ روي ‪ Edit‬ﺑـﺮاي آن‬
    ‫ارﺗﺒﺎط ﻻزﻣﻪ را ﻣﺸﺨﺺ ﻧﻤﺎﻳﻴﺪ ﻳﺎ ﺑﺎ ﻣﺮاﺟﻌﻪ ﺑﻪ ﻗﺴﻤﺖ ﺳﻮرس ﺑﺮﻧﺎﻣـﻪ در ﺗـﺎﺑﻊ ‪ Command Action‬ﺑـﺮاي آن‬
                                                                                 ‫ﻓﺮﻣﺎن ﻛﺪﻫﺎي ﻻزم را ﺑﻨﻮﻳﺴﻴﺪ.‬

                                                      ‫61‬
  ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬           ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                    ‫‪www.txt.ir‬‬



       ‫…//‬
       ‫;)1 ,‪private Command exitCommand = new Command("Exit", Command.EXIT‬‬
       ‫;)1 ,‪private Command backCommand = new Command("Back", Command.BACK‬‬
       ‫…//‬
       ‫{)‪public void commandAction(Command command, Displayable displayable‬‬
        ‫{ )‪if (displayable == helloForm‬‬
              ‫{ )‪if (command == exitCommand‬‬
                      ‫;)(‪exitMIDlet‬‬
                ‫)‪} else if (command == backCommand‬‬
                  ‫;))(‪getDisplay().setCurrent(get_helloForm‬‬
            ‫}‬
       ‫…//‬

                           ‫ﺳﻪ ﭘﺎراﻣﺘﺮي ﻛﻪ ﺑﺮاي ﺑﻪ وﺟﻮد آوردن ﻳﻚ ﺷﻲ از ﻧﻮع ﻓﺮﻣﺎن ﻣﻮرد ﻧﻴﺎز اﺳﺖ ﻋﺒﺎرﺗﻨﺪ از:‬
                                                          ‫• ‪ :Lable‬ﺑﺮﭼﺴﺐ ﻓﺮﻣﺎن را ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﺪ.‬
                                                      ‫• ‪ :Position‬ﻣﻜﺎن ﻓﺮﻣﺎن را ﻣﺸﺨﺺ ﻣﻲ ﻛﻨﺪ.‬
                                                     ‫• ‪ :Priority‬اوﻟﻮﻳﺖ ﻓﺮﻣﺎن را ﻣﺸﺨﺺ ﻣﻲ ﻛﻨﺪ.‬
                                                               ‫ﺗﻌﺪادي از ﻣﺘﺪﻫﺎي ﻣﻬﻢ اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻋﺒﺎرﺗﻨﺪ از:‬
    ‫• ‪ :getCommandType‬ﻧﻮع ﻓﺮﻣﺎن را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ. ﻣـﺜﻼً از ﻧـﻮع ‪ Command.ok‬اﺳـﺖ ﻳـﺎ از‬
                                                                 ‫ﻧﻮع ‪ Command.Back‬و ﻏﻴﺮه.‬
                                                         ‫• ‪ :getlable‬ﺑﺮﭼﺴﺐ ﻓﺮﻣﺎن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬
                                                     ‫• ‪ :getpriority‬اوﻟﻮﻳﺖ ﻓﺮﻣﺎن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬


                                          ‫1-01- ﻣﻌﺮﻓﻲ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻫﺎي ﻗﺴﻤﺖ ‪Form Items‬‬


                                                             ‫1-01-1-ﻛﺎﻣﭙﻮﻧﻨﺖ ‪ChoiceGroup‬‬
    ‫ﺑﺎ اﺳﺘﻔﺎده از اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻛﺎرﺑﺮ ﻣﻲ ﺗﻮاﻧﺪ ﻳﻚ ﻳﺎ ﭼﻨﺪﮔﺰﻳﻨﻪ رﺷﺘﻪ اي را اﻧﺘﺨﺎب ﻧﻤﺎﻳﺪ. ﻫﺮ رﺷﺘﻪ ﻣـﻲ ﺗﻮاﻧـﺪ‬
    ‫ﻳﻚ ﺗﺼﻮﻳﺮ اﺧﺘﻴﺎري ﻧﻴﺰ داﺷﺘﻪ ﺑﺎﺷﺪ. دﻛﻤﻪ ﻫﺎي رادﻳﻮﻳﻲ ﻣﻌﻤﻮﻻً ﺑﺮاي اﻧﺘﺨﺎب ﻫﺎي ﻣﻨﻔﺮد و ﭼﻚ ﺑﺎﻛﺲ ﻫﺎ ﺑـﺮاي‬
    ‫ﭼﻨﺪﻳﻦ اﻧﺘﺨﺎب ﻫﻤﺰﻣﺎن اﺳﺘﻔﺎده ﻣﻲ ﮔﺮدﻧﺪ. ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﭘﺎراﻣﺘﺮ ‪ ChoiceType‬آن، اﮔﺮ ‪ Exclusive‬ﺑﺎﺷﺪ ﻳﻚ‬
                                                ‫ﭼﻚ ﺑﺎﻛﺲ و اﮔﺮ ‪ Multiple‬ﺑﺎﺷﺪ ﻳﻚ دﻛﻤﻪ رادﻳﻮﻳﻲ دارﻳﻢ.‬




                                                    ‫71‬
  ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬            ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬



                                                              ‫ﺗﻌﺪادي از ﻣﺘﺪﻫﺎي اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻋﺒﺎرﺗﻨﺪ از:‬
     ‫• )‪ : Append(String stringpart , Image imagepart‬ﻳـﻚ آﻳـﺘﻢ ﺑـﻪ ‪Choicegroup‬‬
                                                                             ‫اﺿﺎﻓﻪ ﻣﻲ ﻧﻤﺎﻳﺪ.‬
    ‫• )‪ : Delete(int elementnum‬آﻳﺘﻤـﻲ را ﻛـﻪ ‪ elementnum‬ﺑـﻪ آن اﺷـﺎره ﻣـﻲ ﻛﻨـﺪ را ﭘـﺎك‬
                                                                                   ‫ﻣﻲ ﻧﻤﺎﻳﺪ.‬
    ‫• )‪ : getImage(int elementnum‬ﻋﻜﺲ ﻗـﺴﻤﺘﻲ از ‪ Choicegroup‬را ﻛـﻪ‪elementnum‬‬
                                                          ‫ﺑﻪ آن اﺷﺎره ﻣﻲ ﻛﻨﺪ را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ.‬
    ‫• ‪ : getSelectedIndex‬ﺷــﻤﺎره آﻳﺘﻤــﻲ از ‪ Choicegroup‬را ﻛــﻪ اﻧﺘﺨــﺎب ﺷــﺪه اﺳــﺖ را ﺑــﺮ‬
                                                                                  ‫ﻣﻲ ﮔﺮداﻧﺪ.‬


                         ‫ﺗﻜﻪ ﻛﺪ زﻳﺮ ﭼﮕﻮﻧﮕﻲ اﻳﺠﺎد ﻳﻚ دﻛﻤﻪ رادﻳﻮﻳﻲ را ﺗﻮﺳﻂ اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻧﺸﺎن ﻣﻲ دﻫﺪ.‬




                                                 ‫81‬
  ‫‪www.txt.ir‬‬            ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬                   ‫‪www.txt.ir‬‬                   ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬



                                                                        ‫1-01-2-ﻛﺎﻣﭙﻮﻧﻨﺖ ‪DateField‬‬
    ‫ﺑﺎ اﺳﺘﻔﺎده از اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴـﺪ ﻓﻴﻠـﺪ ﺗـﺎرﻳﺦ و زﻣـﺎن ﻗﺎﺑـﻞ وﻳـﺮاﻳﺶ در اﺧﺘﻴـﺎر داﺷـﺘﻪ ﺑﺎﺷـﻴﺪ. ﺷـﻤﺎ‬
                                                             ‫ﻣﻲ ﺗﻮاﻧﻴﺪ ﻓﻘﻂ ﺗﺎرﻳﺦ ﻳﺎ زﻣﺎن و ﻳﺎ ﻫﺮ دو را ﻧﻤﺎﻳﺶ دﻫﻴﺪ.‬


                                                                             ‫1-01-3-ﻛﺎﻣﭙﻮﻧﻨﺖ ‪Gauge‬‬
    ‫از اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﺑﺮاي ﻧﻤﺎﻳﺶ ﻳﻚ ﻣﺤﺪوده ازﻣﻘﺎدﻳﺮ ﻛﻪ ﻛﺎرﺑﺮ ﻣﻲ ﺗﻮاﻧﺪ ﻣﺸﺨﺺ ﻧﻤﺎﻳـﺪ اﺳـﺘﻔﺎده ﻣـﻲ ﺷـﻮد.‬
    ‫ﻫﻤﭽﻨﻴﻦ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﺎ اﺳـﺘﻔﺎده از ﺧﺎﺻـﻴﺖ ‪ Maximum Value‬ﻣﻘـﺪار ﺣـﺪاﻛﺜﺮ اﻳـﻦ ﻛﺎﻣﭙﻮﻧﻨـﺖ و ﺗﻮﺳـﻂ‬
                                                        ‫ﺧﺎﺻﻴﺖ ‪ value‬ﻣﻘﺪار ﺟﺎري اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ را ﺗﻌﻴﻴﻦ ﻧﻤﺎﻳﻴﺪ.‬
                                                               ‫ﺗﻌﺪادي از ﻣﺘﺪﻫﺎي ﻣﻬﻢ اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻋﺒﺎرﺗﻨﺪ از:‬
            ‫• )‪ :setValue(int value‬اﻳﻦ ﮔﺰﻳﻨﻪ ‪ Gauge‬را ﺑﺎ ﻣﻘﺪار ‪ value‬ﻣﻘﺪار دﻫﻲ ﻣﻲ ﻛﻨﺪ.‬
                   ‫• )‪ :setMaxValue(int value‬ﻣﺎﻛﺰﻳﻤﻢ ﻣﻘﺪار ‪ Gauge‬را ﻣﺸﺨﺺ ﻣﻲ ﻛﻨﺪ.‬
                                                  ‫• )(‪ :getValue‬ﻣﻘﺪار ‪ Gauge‬را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ.‬
                                  ‫• )(‪ :getMaxValue‬ﻣﺎﻛﺰﻳﻤﻢ ﻣﻘﺪار ‪ Gauge‬را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ.‬


                       ‫ﺗﻜﻪ ﻛﺪ زﻳﺮ ﭼﮕﻮﻧﮕﻲ اﻳﺠﺎد ﻳﻚ ﻛﺎﻣﭙﻮﻧﻨﺖ ‪ Gauge‬از ﻧﻮع ﻣﺤﺎوره اي را ﻧﺸﺎن ﻣﻲ دﻫﺪ.‬




                                                        ‫91‬
  ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬



                                                                 ‫1-01-4-ﻛﺎﻣﭙﻮﻧﻨﺖ ‪ImageItem‬‬
    ‫اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻳﻚ ﻣﺤﻞ ﺑﺮاي ﻗﺮارﮔﻴﺮي ﻋﻜﺲ ﺑﺎ ﻓﺮﻣﺖ ‪ PNG‬اﺳﺖ ﻛﻪ ﻣﻲ ﺗﻮاﻧﺪ ﺷﺎﻣﻞ ﻳﻚ ﺑﺮﭼﺴﺐ ﺑﺎﺷﺪ‬
                     ‫و ﻣﻲ ﺗﻮان ﺗﺎ اﻧﺪازه اي ﺑﻪ وﺳﻴﻠﻪ ﺧﺎﺻﻴﺖ ‪ ،Layout‬ﻣﺤﻞ ﻋﻜﺲ را روي ﺻﻔﺤﻪ ﻛﻨﺘﺮل ﻧﻤﻮد.‬


                                                                       ‫1-01-5-ﻛﺎﻣﭙﻮﻧﻨﺖ ‪Spacer‬‬
            ‫از اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﺑﺮاي ﺟﺪا ﻧﻤﻮدن واﻳﺠﺎد ﻓﻀﺎي ﺧﺎﻟﻲ )ﻳﻚ ﺧﻂ( ﺑﻴﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻫﺎ اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد.‬


                                                                 ‫1-01-6-ﻛﺎﻣﭙﻮﻧﻨﺖ ‪StringItem‬‬
    ‫ﻳﻚ ﻓﻴﻠﺪ ﻣﺘﻨﻲ ﻏﻴﺮ ﻗﺎﺑﻞ وﻳﺮاﻳﺶ ﻛﻪ ﻣﻲ ﺗﻮاﻧﺪ ﻳﻚ ﺑﺮﭼﺴﺐ داﺷﺘﻪ ﺑﺎﺷﺪ. ﺑﺮﭼﺴﺐ و ﻣﺤﺘﻮاي آن ﻣـﻲ ﺗﻮاﻧـﺪ ﺑـﻪ‬
           ‫وﺳﻴﻠﻪ ﺑﺮﻧﺎﻣﻪ ﻛﺎرﺑﺮدي وﻳﺮاﻳﺶ ﮔﺮدﻧﺪ. ﺗﻜﻪ ﻛﺪ زﻳﺮ ﭼﮕﻮﻧﮕﻲ اﻳﺠﺎد ﻳﻚ ‪ StringItem‬را ﻧﺸﺎن ﻣﻲ دﻫﺪ.‬




                                                                   ‫1-01-7-ﻛﺎﻣﭙﻮﻧﻨﺖ ‪TextField‬‬
    ‫اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻳﻚ ﻓﻴﻠﺪ ﻣﺘﻨﻲ ﻗﺎﺑﻞ وﻳﺮاﻳﺶ اﺳﺖ ﻛﻪ ﻣﻲ ﺗﻮاﻧﺪ ﻳﻚ ﺑﺮﭼـﺴﺐ و ﻳـﻚ ﻣـﺘﻦ اوﻟﻴـﻪ داﺷـﺘﻪ ﺑﺎﺷـﺪ.‬
    ‫ﺣﺪاﻛﺜﺮ ﺗﻌﺪاد ﻛﺎرﻛﺘﺮﻫﺎ را ﻣﻲ ﺗﻮاﻧﻴﺪ ﻣﺸﺨﺺ ﻧﻤﺎﻳﻴﺪ. ‪ TextField‬ﻗﻮاﻋﺪي ﺑﺮاي ﻓﻴﻠـﺪﻫﺎي ﺧـﺎص ﻣﺎﻧﻨـﺪ آدرس‬
    ‫ﭘــﺴﺖ اﻟﻜﺘﺮوﻧﻴﻜــﻲ، ﻣﻘــﺎدﻳﺮ ﻋــﺪدي، ﺷــﻤﺎره ﺗﻠﻔــﻦ، ‪ URL‬و ﻛﻠﻤــﻪ ﻋﺒــﻮر دارد. ﻛﺎﻣﭙﻮﻧﻨــﺖ ﻫــﺎي ‪TextField‬‬
                                                      ‫ﮔﻮﻧﺎﮔﻮن ﻣﻲ ﺗﻮاﻧﻨﺪ ﺑﺮاي ورودي ﻛﺎرﺑﺮ ﺑﻪ ﻓﺮم اﺿﺎﻓﻪ ﺷﻮﻧﺪ.‬



                                                     ‫02‬
  ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬



                                            ‫ﺑﻌﻀﻲ از ﻣﺤﺪودﻳﺖ ﻫﺎي ﻗﺎﺑﻞ اﻋﻤﺎل ﺗﻮﺳﻂ اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻋﺒﺎرﺗﻨﺪ از:‬
                            ‫• ‪ : TextField.ANY‬ﻛﺎرﺑﺮ اﺟﺎزه دارد ﻫﺮ ﻣﺘﻨﻲ دﻟﺨﻮاﻫﻲ را وارد ﻧﻤﺎﻳﺪ.‬
                      ‫• ‪ : TextField.EmailAddr‬ﻛﺎرﺑﺮ اﺟﺎزه دارد ﻓﻘﻂ آدرس اﻳﻤﻴﻞ را وارد ﻛﻨﺪ.‬
                                     ‫• ‪ : TextField.Password‬ﻣﺘﻦ وارد ﺷﺪه ﻗﺎﺑﻞ ﻣﺸﺎﻫﺪه ﻧﻴﺴﺖ.‬
               ‫• ‪ : TextField.PhoneNumber‬ﺑﺮاي وارد ﻛﺮدن ﺷﻤﺎره ﺗﻠﻔﻦ ﻗﺎﻟﺐ ﺑﻨﺪي ﺷﺪه اﺳﺖ.‬
                                                                   ‫ﺗﻌﺪادي از ﻣﺘﺪﻫﺎي اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻋﺒﺎرﺗﻨﺪ از:‬
                               ‫• ‪ : Getstring‬ﻣﺤﺘﻮﻳﺎت ﻓﻴﻠﺪ ﻣﺘﻨﻲ را ﻛﻪ ﻳﻚ رﺷﺘﻪ اﺳﺖ ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬
                          ‫• ‪ : Getconstraint‬ﻣﺤﺪودﻳﺖ اﻋﻤﺎل ﺷﺪه روي ﻓﻴﻠﺪ ﻣﺘﻨﻲ را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ.‬
    ‫• )‪ : Setstring(String text‬ﻣﺤﺘﻮﻳـﺎت ﻣـﺘﻦ داده ﺷـﺪه ﺑـﻪ آن را ﺑـﻪ ﺟـﺎي ﻣﺤﺘﻮﻳـﺎت ﻓﻴﻠـﺪ ﻣﺘﻨـﻲ‬
     ‫ـ ـ‬          ‫ـ‬        ‫ـ ـ‬           ‫ـ ـ‬            ‫ـ‬    ‫ـ‬
                                                                               ‫ﺟﺎﻳﮕﺬاري ﻣﻲ ﻛﻨﺪ.‬
    ‫• )(‪ : getMaxsize‬ﻣﺎﻛﺰﻳﻤﻢ ﺗﻌﺪاد ﻛﺎراﻛﺘﺮﻫـﺎﻳﻲ ﻛـﻪ در ﻓﻴﻠـﺪ ﻣﺘﻨـﻲ ﻣـﻲ ﺗﻮاﻧﻨـﺪ ﻗـﺮار ﺑﮕﻴﺮﻧـﺪ را ﺑـﺮ‬
                                                                                       ‫ﻣﻲ ﮔﺮداﻧﺪ.‬
                                                ‫ﺗﻜﻪ ﻛﺪ زﻳﺮ ﭼﮕﻮﻧﮕﻲ اﻳﺠﺎد ﻳﻚ ‪ TextField‬را ﻧﺸﺎن ﻣﻲ دﻫﺪ.‬




                                                                ‫1-01-8-ﻛﺎﻣﭙﻮﻧﻨﺖ ‪TabelItems‬‬
    ‫از اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﺑﺮاي ﻧﻤﺎﻳﺶ اﻃﻼﻋﺎت در داﺧﻞ ﺟﺪول ﻣﻲ ﺗﻮان اﺳﺘﻔﺎده ﻧﻤﻮد. ﺑﺎ داﺑـﻞ ﻛﻠﻴـﻚ ﺑـﺮ روي اﻳـﻦ‬
    ‫ﻛﺎﻣﭙﻮﻧﻨﺖ ﺻﻔﺤﻪ اي ﺑﺮاي ورود و اﺻﻼح اﻃﻼﻋﺎت ﺑﻪ درون ﺟﺪول ﺑﺎز ﻣﻲ ﺷﻮد. ﻫﻤﭽﻨﻴﻦ ﺷـﻤﺎ ﻣـﻲ ﺗﻮاﻧﻴـﺪ ﺗﻌـﺪاد‬
                                                                       ‫ﺳﻄﺮ ﻳﺎ ﺳﺘﻮن ﺟﺪول را ﻧﻴﺰ ﺗﻌﻴﻴﻦ ﻧﻤﺎﻳﻴﺪ.‬



                                                    ‫12‬
  ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬            ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬                       ‫‪www.txt.ir‬‬           ‫‪www.txt.ir‬‬



                       ‫در ﺷﻜﻞ 1-7 ﺗﻤﺎﻣﻲ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻫﺎي ‪ Form Item‬را ﺑﺮ روي ﻳﻚ ﻓﺮم ﻣﺸﺎﻫﺪه ﻣﻲ ﻧﻤﺎﻳﻴﺪ.‬




                               ‫ﺷﻜﻞ 1-7- ﻛﺎﻣﭙﻮﻧﻨﺖ ﻫﺎي ﻗﺴﻤﺖ ‪ Form Items‬ﺑﺮ روي ﻓﺮم‬




                                                          ‫1-11-ﻛﺎﻣﭙﻮﻧﻨﺖ ﻫﺎي ﺑﺨﺶ ‪Elements‬‬


                                                           ‫1-11-1-ﻛﺎﻣﭙﻮﻧﻨﺖ ‪Choice Element‬‬
    ‫از اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﺑﺮاي ﻗﺮار ﮔﺮﻓﺘﻦ در ﻳﻚ ‪ ChoiceGroup‬اﺳﺘﻔﺎده ﻣﻲ ﮔﺮدد و ﻣﻲ ﺗﻮان ﭼﻨﺪﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ‬
                                        ‫از اﻳﻦ ﻧﻮع را ﺑﻪ ﻣﻴﺰان ﻻزم ﺑﺮروي ‪ ChoiceGroup‬ﻣﻮرد ﻧﻈﺮ ﻗﺮار داد.‬
                                                               ‫1-11-2-ﻛﺎﻣﭙﻮﻧﻨﺖ ‪List Element‬‬
    ‫از اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﺑﺮاي ﻗﺮار ﮔﺮﻓﺘﻦ در ﻳﻚ ‪ List‬اﺳﺘﻔﺎده ﻣﻲ ﮔﺮدد و ﻣﻲ ﺗﻮان ﭼﻨﺪﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ از اﻳﻦ ﻧﻮع را‬
                                                                   ‫ﺑﻪ ﻣﻴﺰان ﻻزم ﺑﺮروي ﻟﻴﺴﺖ ﻣﻮرد ﻧﻈﺮ ﻗﺮار داد.‬




                              ‫ﺷﻜﻞ1-8- ﻧﻤﺎﻳﺶ ﻳﻚ ﻟﻴﺴﺖ ﺑﻪ ﻫﻤﺮاه ‪ List Element‬ﻫﺎي آن‬

                                                     ‫22‬
  ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                     ‫‪www.txt.ir‬‬         ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬                   ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬



                                                          ‫1-21-ﻛﺎﻣﭙﻮﻧﻨﺖ ﻫﺎي ﺑﺨﺶ ‪Resources‬‬


                                                                               ‫1-21-1-ﻛﺎﻣﭙﻮﻧﻨﺖ ‪Font‬‬
    ‫از اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﺑﺮاي اﻳﺠﺎد ﻳﻚ ﻧﻮع ﻓﻮﻧﺖ دﻟﺨﻮاه، ﺑﺎﺗﻌﻴﻴﻦ ﺳﺎﻳﺰ، ﻧﻮع وﺣﺎﻟﺖ آن ﺑﻪ ﻛﺎر ﻣﻲ رود. ﺳﭙﺲ ﺷﻤﺎ‬
    ‫ﻣﻲ ﺗﻮاﻧﻴﺪ در ﻫﺮ ﺟﺎ ﻛﻪ ﻳﻚ ﻣﺘﻦ دارﻳﺪ اﻳﻦ ﻓﻮﻧﺖ را ﺑﻪ ﺧﺎﺻﻴﺖ ﻓﻮﻧﺖ آن ﻣﺘﻦ ﻧـﺴﺒﺖ دﻫﻴـﺪ. در ﺷـﻜﻞ 1-9 ﺷـﻤﺎ‬
                                                                        ‫ﭘﻨﺠﺮه ﺗﻨﻈﻴﻤﺎت ﻓﻮﻧﺖ را ﻣﺸﺎﻫﺪه ﻣﻲ ﻧﻤﺎﻳﻴﺪ.‬




                                          ‫ﺷﻜﻞ 1-9- ﭘﻨﺠﺮه ﺗﻨﻈﻴﻤﺎت ﻓﻮﻧﺖ‬


                                                                            ‫1-21-2-ﻛﺎﻣﭙﻮﻧﻨﺖ ‪Image‬‬
    ‫ﺑﺎ اﺳﺘﻔﺎده از اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﻪ ﻳﻚ ﻋﻜـﺲ در ﭘـﺮوژه ﺧـﻮد دﺳﺘﺮﺳـﻲ داﺷـﺘﻪ ﺑﺎﺷـﻴﺪ. ﺑـﺮاي اﻳـﻦ‬
    ‫ﻣﻨﻈﻮر اﺑﺘﺪا ﺑﺎﻳﺪ ﻋﻜﺲ ﻣﻮرد ﻧﻈﺮ ﺧﻮد را ﺑﺎ ﻓﺮﻣﺖ ‪ PNG‬را در ﭘﻮﺷﻪ ﭘﺮوژه در ﺷﺎﺧﻪ ‪ /src‬ﻛﭙﻲ ﻧﻤﺎﻳﻴﺪ. ﺳﭙﺲ ﺑـﺎ‬
    ‫ﻛﻠﻴﻚ ﺑﺮ روي ‪ ،Resource Path‬ﭘﻨﺠﺮه اي ﺑﺎز ﺷـﺪه و ﺷـﻤﺎ ﻣـﻲ ﺗﻮاﻧﻴـﺪ آدرس ﻋﻜـﺲ ﻣـﻮرد ﻧﻈـﺮ را اﻧﺘﺨـﺎب‬
                                     ‫ﻧﻤﺎﻳﻴﺪ ﻳﺎ ﺑﻪ ﻃﻮر دﺳﺘﻲ در ﻗﺴﻤﺖ ‪ Resource Path‬آدرس آن را ﺑﻨﻮﻳﺴﻴﺪ.‬




                                 ‫ﺷﻜﻞ1-01- اﻧﺘﺨﺎب آدرس ﻋﻜﺲ ﺑﺮاي ‪Resource Path‬‬


                                                     ‫32‬
  ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬



                                                                           ‫1-21-3-ﻛﺎﻣﭙﻮﻧﻨﺖ ‪Ticker‬‬
    ‫اﻳﻦ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻳﻚ رﺷﺘﻪ اﺳﺖ ﻛﻪ در ﻋﺮض ﺻﻔﺤﻪ ﻣﺘﻨﺎوﺑﺎً ﺣﺮﻛﺖ ﻣﻲ ﻛﻨﺪ. ﺳﺮﻋﺖ و راﺳﺘﺎي ﺣﺮﻛﺖ ﺑﻮﺳﻴﻠﻪ‬
    ‫وﺳﻴﻠﻪ )ﺗﻠﻔﻦ ﻫﻤﺮاه( ﻛﻨﺘﺮل ﻣﻲ ﺷﻮد و ﺑﺮﻧﺎﻣﻪ ﻛـﺎرﺑﺮدي ﻣـﻲ ﺗﻮاﻧـﺪ ﺣﺮﻛـﺖ آن را ﺑـﺮاي ﺟﻠـﻮﮔﻴﺮي از ﻫـﺪر رﻓـﺘﻦ‬
                               ‫اﻧﺮژي، زﻣﺎﻧﻲ ﻛﻪ ﻛﺎرﺑﺮ ﻏﻴﺮ ﻓﻌﺎل اﺳﺖ، در ﻳﻚ ﻣﺪت زﻣﺎن ﻣﺸﺨﺺ ﻣﺘﻮﻗﻒ ﻧﻤﺎﻳﺪ.‬


                                                              ‫1-31- ﺗﻨﻈﻴﻢ ﺧﺎﺻﻴﺖ ﻫﺎ در ‪MIDP‬‬


                                                                ‫1-31-1- ﺗﻨﻈﻴﻢ ‪Preferred Size‬‬
    ‫ﻳﻚ ‪ MIDP Item‬ﻳﺎ ﻳﻚ ﻛﺎﻣﭙﻮﻧﻨﺖ، ﻳـﻚ ﺧﺎﺻـﻴﺖ ‪ Preferred Size‬در 0.2 ‪ MIDP‬دارد ﻛـﻪ ﻗﺎﺑـﻞ‬
    ‫ﺗﻨﻈﻴﻢ ﻣﻲ ﺑﺎﺷﺪ. ‪ Preferred Size‬ﺑﻪ ﻛﻞ ﻧﺎﺣﻴﻪ ﻣﻮرد ﻧﻴﺎز ﺑﺮاي ﻛﺎﻣﭙﻮﻧﻨﺖ اﺷـﺎره دارد ﻛـﻪ ﻓـﻀﺎ ﺑـﺮاي ﮔﻨﺠـﺎﻳﺶ‬
    ‫ﻛﺎﻣﭙﻮﻧﻨﺖ، ﺑﺮﭼﺴﺐ واﺑﺴﺘﻪ و ﻫـﺮ ﻓـﻀﺎي اﺿـﺎﻓﻲ ﻻزم ﺑـﺮاي آراﻳـﺶ آن را ﺷـﺎﻣﻞ ﻣـﻲ ﺷـﻮد. ‪Preferred Size‬‬
    ‫ﻣﻌﻤﻮﻻً ﻛﻮﭼﻜﺘﺮﻳﻦ اﻧﺪازه ﻳﻚ ﻛﺎﻣﭙﻮﻧﻨﺖ اﺳﺖ ﻛﻪ ﻣـﻲ ﺗﻮاﻧـﺪ ﺑـﺪون ﻣﺤﺘـﻮي ‪ Clipping‬و ‪Wrapping text‬‬
                                                   ‫ﺑﺎﺷﺪ و اﮔﺮ ﻣﺤﺘﻮا ﺗﻐﻴﻴﺮ ﻛﻨﺪ ﻣﻤﻜﻦ اﺳﺖ دوﺑﺎره ﻣﺤﺎﺳﺒﻪ ﺷﻮد.‬
    ‫ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ‪ Preferred size‬ﻳﻚ ﻛﺎﻣﭙﻮﻧﻨﺖ را ﺑﺎ ﻳﻚ ﻣﻘﺪار ﻋﺪدي ﻣﺜﺒﺖ ﺑﺮاي ﻋﺮض و ارﺗﻔـﺎع ﻳـﺎ ﻫـﺮ‬
    ‫دو ﻣﺸﺨﺺ ﻧﻤﺎﻳﻴﺪ. اﮔﺮ ﺷﻤﺎ در ﺧﺎﺻﻴﺖ ‪ Prefereed size‬ﮔﺰﻳﻨﻪ ‪ Unlocked‬را ﺗﻴﻚ ﺑﺰﻧﻴﺪ، ﺳـﺎﻳﺰ ﻛﺎﻣﭙﻮﻧﻨـﺖ‬
    ‫ﺑﻪ ﻃﻮر ﺧﻮدﻛﺎر و ﺑﺴﺘﻪ ﺑﻪ اﻧﺪازه آن ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد و ﻣﺜﻼً ﺑـﺮاي ﻛﺎﻣﭙﻮﻧﻨـﺖ ‪ TextField‬اﮔـﺮ اﻳـﻦ ﮔﺰﻳﻨـﻪ ﺗﻴـﻚ‬
    ‫ﺧﻮرده ﺑﺎﺷﺪ، ﻛﺎرﺑﺮ ﻣﻲ ﺗﻮاﻧﺪ ﺑـﻪ ﺗﺎﻳـﭗ ﺧـﻮد اداﻣـﻪ داده و اﻧـﺪازه ‪ TextField‬ﻣﺘﻨﺎﺳـﺐ ﺑـﺎ ﻣـﺘﻦ ﺗـﺎ ‪MaxSize‬‬
                                                                                    ‫ﻣﺸﺨﺺ ﺷﺪه اداﻣﻪ ﻳﺎﺑﺪ.‬




                                    ‫ﺷﻜﻞ 1-11- ﺗﻨﻈﻴﻢ ﺧﺎﺻﻴﺖ ‪Prefereed size‬‬




                                                    ‫42‬
  ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬           ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                   ‫‪www.txt.ir‬‬



                                                       ‫1-31-2-ﺗﻨﻈﻴﻢ ﺧﺎﺻﻴﺖ ‪Appearance‬‬
    ‫دو ﻛﺎﻣﭙﻮﻧﻨــﺖ ‪ StringItem‬و ‪ ImageItem‬ﻳــﻚ ﺻــﻔﺖ ‪ Appearance‬دارﻧــﺪ ﻛــﻪ ﻣــﻲ ﺗﻮاﻧــﺪ در‬
                               ‫ﺳﺎزﻧﺪﺷﺎن ﻣﻘﺪار دﻫﻲ ﺷﻮد. اﻳﻦ ﺻﻔﺖ ﻣﻲ ﺗﻮاﻧﺪ ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ زﻳﺮ را داﺷﺘﻪ ﺑﺎﺷﺪ:‬
                                                                                 ‫• ‪PLAIN‬‬
                                                                        ‫• ‪HYPERLINK‬‬
                                                                             ‫• ‪BUTTON‬‬
    ‫اﻳﻦ ﻣﻘﺎدﻳﺮ را ﻣﻲ ﺗﻮاﻧﻴﺪ در ﺧﺎﺻﻴﺖ ‪ Appearance‬ﻛﺎﻣﭙﻮﻧﻨﺖ ﻣﺮﺑﻮﻃﻪ اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ ﻳـﺎ ﺑـﻪ ﻃـﻮر دﺳـﺘﻲ در‬
    ‫ﻛﺪ وارد ﻧﻤﺎﻳﻴﺪ. ﺑﺮاي ﻣﺜﺎل ﺑﺮاي ﻣﻘﺪاردﻫﻲ ﻛﺮدن اﻳﻦ ﺧﺎﺻﻴﺖ ﺑﺮاي ﻳـﻚ ﻛﺎﻣﭙﻮﻧﻨـﺖ ‪ StringItem‬ﺷـﺒﻴﻪ ﻳـﻚ‬
                                                                  ‫ﻛﻠﻴﺪ، ﺳﺎزﻧﺪه آن ﺑﺎﻳﺪ ﺑﻪ ﺻﻮرت زﻳﺮ ﺑﺎﺷﺪ.‬
        ‫;)‪stringItem1 = new StringItem("Button","Button",Item.BUTTON‬‬

    ‫ﺗﻮﺟﻪ : ﺑﺮاي ﺳﺎﺧﺘﻦ ﻳﻚ آﻳﺘﻢ ﺗﻌﺎﻣﻠﻲ ﺑﻪ ﻋﻨﻮان ﻳﻚ دﻛﻤﻪ ﻳﺎ ﻳﻚ ﻫﺎﻳﭙﺮ ﻟﻴﻨﻚ1، آن ﺑﺎﻳﺪ ﻳﻚ ﻳﺎ ﭼﻨﺪ دﺳﺘﻮر‬
                           ‫داﺷﺘﻪ ﺑﺎﺷﺪ و ﺑﺎﻳﺪ ‪ CommandListener‬را ﺑﺮاي ﺷﻨﻴﺪن آن دﺳﺘﻮرات ﺗﻨﻈﻴﻢ ﻧﻤﺎﻳﻴﺪ.‬


                                                           ‫1-31-3- اﻳﺠﺎد ‪Text Wrapping‬‬
    ‫ﺑﺮاي اﻳﻦ ﻛﻪ ﻳﻚ ﺟﻤﻠﻪ از ﻳﻚ ﻣﻜﺎن ﻣﺸﺨﺺ را وادار ﻧﻤﺎﻳﻴﻢ ﻛﻪ ﺑﻪ ﺧـﻂ ﺑﻌـﺪ ﺑـﺮود، ﻳﻜـﻲ از ﻣـﻮارد زﻳـﺮ را‬
                                                                                          ‫اﻧﺠﺎم ﻣﻲ دﻫﻴﻢ:‬
    ‫• ﺑﻪ ﻃﻮر دﺳﺘﻲ ‪ \n‬را ﻣﺴﺘﻘﻴﻤﺎً در ﻣﺤﺘﻮي ‪ StringItem‬در ﺳﻮرس ﻛﺪ وارد ﻣﻲ ﻧﻤﺎﻳﻴﻢ. ﺑﺮاي ﻣﺜﺎل ﺑﻪ‬
                                                                           ‫ﻛﺪ زﻳﺮ ﺗﻮﺟﻪ ﻧﻤﺎﻳﻴﺪ:‬

       ‫;)"‪stringItem3 = new StringItem("stringItem3", "test\nText Warpping‬‬

                                  ‫• ﺑﺎ ﺗﺎﻳﭗ ﻣﺘﻦ ﻣﻮرد ﻧﻈﺮ در ﻣﺤﻴﻂ وﻳﮋوال و در ﺧﺎﺻﻴﺖ ‪ Text‬آن.‬
    ‫ﻛﺎراﻛﺘﺮ ﺧﻂ ﺟﺪﻳﺪ )‪ (\n‬در ﻳﻚ ‪ StringItem‬ﺗﻨﻬﺎ ﻳﺎ در ‪ StringItem‬ﻫﺎي ﻣﺠﺎور، ﺷﻜﺴﺖ ﻫﺎي ردﻳﻔﻲ‬
                                                       ‫زﻳﺎدي ﺑﻪ ﺗﻌﺪاد ﻛﺎراﻛﺘﺮﻫﺎي ﺧﻂ ﺟﺪﻳﺪ اﻳﺠﺎد ﻣﻲ ﻛﻨﺪ.‬




       ‫1‬
           ‫‪HyperLink‬‬

                                                  ‫52‬
  ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬




                                  ‫ﺷﻜﻞ 1-21- ورود ﻣﺘﻦ در ﺧﺎﺻﻴﺖ ‪Text‬‬




                                                                        ‫1-31-4- ﺧﺎﺻﻴﺖ ‪Layout‬‬
    ‫ﺷﻤﺎ اوﻟﻴﻦ ﻛﺎﻣﭙﻮﻧﻨﺘﻲ ﻛﻪ ﺑﻪ ﻣﺤﻴﻂ ﻃﺮاﺣﻲ اﺿﺎﻓﻪ ﻣﻲ ﻛﻨﻴﺪ در ﺷﺮوع ﺳﻄﺮ ﻗﺮار ﻣﻲ ﮔﻴﺮد. ﻫـﺮ ﻛـﺎﻣﭙﻮﻧﻨﺘﻲ ﻛـﻪ‬
    ‫ﺑﻌﺪ از اﻳﻦ اﺿﺎﻓﻪ ﺷﻮد، در ﺳﻄﺮ ﺑﻌﺪي ﻗﺮار ﻣﻲ ﮔﻴﺮد. ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﺎ اﺳﺘﻔﺎده ازﺧﺎﺻﻴﺖ ‪ Layout‬ﺑﻪ ﺗﺮاز ﺑﻨـﺪي‬
    ‫ﻛﺎﻣﭙﻮﻧﻨﺖ ﻫﺎ ﺑﺮ روي ﺻﻔﺤﻪ ﺑﭙﺮدازﻳﺪ. ﺑﻌﻀﻲ رﻓﺘﺎرﻫﺎي اﻳﻦ ﺧﺎﺻـﻴﺖ ﺑـﻪ ﻃـﻮر اﺗﻮﻣﺎﺗﻴـﻚ، ﺑـﺎ ﭘﻴـﺎده ﺳـﺎزي وﺳـﻴﻠﻪ‬
    ‫ﻣﺸﺨﺺ ﺑﺮاي ﻣﻮارد ﺧﺎص ﺗﻌﻴﻴﻦ ﻣﻲ ﮔﺮدﻧﺪ. در ﺷﻜﻞ زﻳﺮ ﮔﺰﻳﻨﻪ ﻫﺎي ﻣﺨﺘﻠﻒ ﻣﻮﺟﻮد ﺑﺮاي ﺗﺮازﺑﻨﺪي ﻛﺎﻣﭙﻮﻧﻨـﺖ‬
                                                                                    ‫ﻫﺎ را ﻣﺸﺎﻫﺪه ﻣﻲ ﻧﻤﺎﻳﻴﺪ.‬




                                       ‫ﺷﻜﻞ 1-31- ﭘﻨﺠﺮه ﺗﻨﻈﻴﻤﺎت ‪Layout‬‬




                                                     ‫62‬
  ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬



                                                             ‫1-41- اﻳﺠﺎد ﻳﻚ ﺗﻴﻜﺮ1 در ﺣﺎﻟﺖ ‪VMD‬‬
      ‫ﺗﻴﻜﺮ ﻳﻚ ﺧﺎﺻﻴﺖ ﺻﻔﺤﻪ اﺳﺖ و ﻣﻮﻗﻌﻴﺘﺶ ﺑﺎ وﺳﻴﻠﻪ ﻣﻘﺼﺪ ﻣﺸﺨﺺ ﻣﻲ ﮔﺮدد. اﻳﺠﺎد ﺗﻴﻜﺮ دو ﻣﺮﺣﻠﻪ دارد:‬
                                                                              ‫1- ﻣﻌﺮﻓﻲ ﻳﻚ ﺗﻴﻜﺮ ﺟﺪﻳﺪ‬
                                          ‫2-ﻣﺸﺨﺺ ﻛﺮدن آن ﺗﻴﻜﺮ در ﺧﺎﺻﻴﺖ ﺗﻴﻜﺮ ﻛﻼس ‪Displayable‬‬
                                              ‫ﻣﺮاﺣﻞ زﻳﺮ ﺑﺮاي اﻳﺠﺎد ﻳﻚ ﺗﻴﻜﺮ در ﻃﺮاح ‪ UI‬اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد:‬
    ‫1. ﺑﺮ روي ﻛﺎﻣﭙﻮﻧﻨﺖ ﺗﻴﻜﺮ در ﭘﺎﻟﺖ ﻛﻠﻴﻚ ﻧﻤﻮده وآن را ﺑﺮ روي ﺻﻔﺤﻪ ﻗـﺮار ﻣـﻲ دﻫـﻴﻢ. ﻛﺎﻣﭙﻮﻧﻨـﺖ ﺗﻴﻜـﺮ‬
                                       ‫ﺟﺪﻳﺪ در ﭘﻨﺠﺮه ‪ Inspector‬در ﭘﻮﺷﻪ ‪ Resources‬ﻗﺮار ﻣﻲ ﮔﻴﺮد.‬
                    ‫2. ﺗﻴﻜﺮ ﺟﺪﻳﺪ را اﻧﺘﺨﺎب ﻛﺮده و در ﺧﺎﺻﻴﺖ ‪ String‬آن ﻣﺘﻦ ﻣﻮرد ﻧﻈﺮ ﺧﻮد را وارد ﻧﻤﺎﻳﻴﺪ.‬
    ‫3. ﺑﺮ روي ﺻﻔﺤﻪ ﻣﻮرد ﻧﻈﺮ داﺑـﻞ ﻛﻠﻴـﻚ ﻛـﺮده و 1‪ Ticker‬را از ﻟﻴـﺴﺖ ﻛـﺸﻮﻳﻲ آن در ﺧﺎﺻـﻴﺖ ﺗﻴﻜـﺮ‬
                                                                                    ‫اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ.‬
    ‫اﻧﺠﺎم اﻳﻦ ﻣﺮﺣﻠﻪ ﺑﺮاي ﻛﻼس ‪ Displayable‬ﺑﺮاي ﻧﻤﺎﻳﺶ ﻻزم اﺳﺖ و ﺑﻪ ﻛﻼس ﻣـﻲ ﮔﻮﻳـﺪ ﻛـﻪ ﻳـﻚ‬
    ‫ﺗﻴﻜﺮ ﺑﺮاي ﻧﻤﺎﻳﺶ وﺟﻮد دارد و ﻣﺸﺨﺺ ﻣﻲ ﻧﻤﺎﻳﺪ ﻛﻪ ﺑﺎﻳﺪ ﻧﻤﺎﻳﺶ داده ﺷﻮد. ﻛﺪ ﺗﻮﻟﻴﺪ ﺷﺪه ﺑﺮاي اﻧﺠـﺎم اﻳـﻦ‬
                                                                              ‫ﻋﻤﻞ ﺑﻪ ﺻﻮرت زﻳﺮ اﺳﺖ:‬
              ‫;)1‪This.setTicker(ticker‬‬




                                             ‫ﺷﻜﻞ 1-41- اﻳﺠﺎد ﻳﻚ ‪Ticker‬‬




       ‫1‬
           ‫‪Ticker‬‬

                                                        ‫72‬
  ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬           ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬



                                                ‫1-51- ﻓﺎﻳﻞ ﺗﻮﺻﻴﻒ ﻛﻨﻨﺪه ﺑﺮﻧﺎﻣﻪ ﺟﺎوا )‪(JAD‬‬
    ‫ﻫﺮ ﻓﺎﻳﻞ ‪ MIDlet suite‬ﺑﺎ ﻳﻚ ﻓﺎﻳﻞ ﺗﻮﺻﻴﻒ ﻛﻨﻨﺪه ﺑﺮﻧﺎﻣﻪ ﺟﺎوا ﻫﻤـﺮاه ﻣـﻲ ﮔـﺮدد. اﻳـﻦ ﻓﺎﻳـﻞ ﺷـﺎﻣﻞ ﻳـﻚ‬
    ‫ﻣﺠﻤﻮﻋﻪ ﺻﻔﺎت از ﻗﺒﻞ ﺗﻌﻴﻴﻦ ﺷﺪه ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ ﺑﻪ ﻧﺮم اﻓﺰار ﻣـﺪﻳﺮﻳﺖ ﺑﺮﻧﺎﻣـﻪ ﻫـﺎي ﺟـﺎوا1 اﺟـﺎزه ﻣـﻲ دﻫـﺪ ﻛـﻪ ﺑـﻪ‬
    ‫ﺷﻨﺎﺳﺎﻳﻲ، ﺑﺎزﻳﺎﺑﻲ و ﻧﺼﺐ ‪ MIDlet‬ﺑﭙﺮدازد. ﻓﺎﻳﻞ ‪ ،JAD‬ﻧﺮم اﻓﺰار ﻣﺪﻳﺮﻳﺖ ﺑﺮﻧﺎﻣﻪ ﻛـﺎرﺑﺮدي را ﻗـﺎدر ﻣـﻲ ﺳـﺎزد‬
    ‫ﻛﻪ ﺑﺮ روي ﻳﻚ دﺳﺘﮕﺎه ﺗﻠﻔﻦ ﻫﻤﺮاه ﺑﻪ ﺷﻨﺎﺳﺎﻳﻲ ‪ MIDlet Suite‬دﺳـﺘﮕﺎه، ﻗﺒـﻞ از ﺑﺎرﮔـﺬاري ﻓﺎﻳـﻞ ‪ JAR‬ﺑـﻪ‬
                                                                                          ‫ﻃﻮر ﻛﺎﻣﻞ ﺑﭙﺮدازد.‬
    ‫در ‪ ،IDE‬ﻓﺎﻳﻞ ‪ JAD‬ﺑﻪ ﻃﻮر اﺗﻮﻣﺎﺗﻴﻚ ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﺷﻤﺎ ﻳﻚ ‪ MIDlet Suite‬را اﻳﺠﺎد ﻣﻲ ﻧﻤﺎﻳـﺪ، ﺳـﺎﺧﺘﻪ‬
    ‫ﻣﻲ ﺷﻮد. ﻣﺤﺘﻮاي ﻓﺎﻳﻞ ‪ JAR‬را ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﺎ داﺑﻞ ﻛﻠﻴﻚ ﺑﺮ روي ﻓﺎﻳﻞ ‪ JAR‬ﻣﻮﺟﻮد در ﭘﻨﺠﺮه ﻓﺎﻳﻞ ﻣﺸﺎﻫﺪه‬
                      ‫ﻧﻤﺎﻳﻴﺪ و در ﺻﻮرت ﻧﻴﺎز آن را اﺻﻼح ﻧﻤﺎﻳﻴﺪ. ﺻﻔﺎت ﻣﻮرد ﻧﻴﺎز در ﻳﻚ ﻓﺎﻳﻞ ‪ JAD‬ﻋﺒﺎرﺗﻨﺪ از:‬
                                 ‫‪ :MIDlet-Name‬اﻳﻦ ﺧﺎﺻﻴﺖ ﻧﺎم ‪ MIDlet suite‬را ﻣﺸﺨﺺ ﻣﻲ ﻧﻤﺎﻳﺪ.‬
                                 ‫‪ :MIDlet-Version‬ﺷﻤﺎره ﻧﺴﺨﻪ ‪ MIDlet suite‬را ﻣﺸﺨﺺ ﻣﻲ ﻧﻤﺎﻳﺪ.‬
                    ‫‪ :MIDlet-Vendor‬ﺳﺎزﻣﺎﻧﻲ ﻛﻪ ‪ MIDlet suite‬را ﻓﺮاﻫﻢ ﻣﻲ ﻧﻤﺎﻳﺪ، ﻣﺸﺨﺺ ﻣﻲ ﻛﻨﺪ.‬
    ‫ﺻﻔﺎت دﻳﮕﺮي ﺑﺮاي اﺳﺘﻔﺎده در دﺳﺘﺮس ﻣﻲ ﺑﺎﺷـﺪ ﻛـﻪ اﻳـﻦ ﺻـﻔﺎت ﺑـﺴﺘﮕﻲ ﺑـﻪ ﻧـﺴﺨﻪ ‪ MIDP‬اي دارد ﻛـﻪ‬
                                                 ‫ﺗﻮﺳﻂ ﭘﻴﻜﺮﺑﻨﺪي ﭘﺮوژه ﭘﺸﺘﻴﺒﺎﻧﻲ ﻣﻲ ﺷﻮد. اﻳﻦ ﺻﻔﺎت ﻋﺒﺎرﺗﻨﺪ از:‬
                               ‫‪ :MIDlet-JAR-URL‬ﻣﻜﺎن و ﻧﺎم ﻓﺎﻳﻞ ‪ JAR‬ﺑﺮاي اﻳﻦ ‪.MIDlet suite‬‬
    ‫‪ :MIDlet-JAR-Size‬اﻳﻦ ﺻﻔﺖ اﻧﺪازه ﻓﺎﻳﻞ ‪ JAR‬ﺳـﺎﺧﺘﻪ ﺷـﺪه از اﻳـﻦ ‪ MIDlet suite‬را ﻣـﺸﺨﺺ‬
    ‫ﻣﻲ ﻧﻤﺎﻳﺪ. اﻳﻦ ﺧﺎﺻﻴﺖ، ﻳﻚ ﺧﺎﺻﻴﺖ ﻓﻘﻂ ﺧﻮاﻧﺪﻧﻲ ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ ﻫﺮ زﻣـﺎن ﻛـﻪ ﻓﺎﻳـﻞ ‪ JAR‬ﺳـﺎﺧﺘﻪ ﺷـﻮد ﺑـﻪ روز‬
                                                                                            ‫رﺳﺎﻧﻲ ﻣﻲ ﮔﺮدد.‬
    ‫‪ :MicroEdition-Profile‬ﭘﻴﻜﺮﺑﻨﺪي ‪ J2ME‬ﻣﻮرد ﻧﻴﺎز ﻛﻪ از ﻫﻤﺎن ﻓﺮﻣﺖ و ﻣﻘﺪار ﺑﻪ ﻋﻨـﻮان ﺧﺎﺻـﻴﺖ‬
                                                                  ‫ﺳﻴﺴﺘﻢ اﺳﺘﻔﺎده ﻣﻲ ﻧﻤﺎﻳﺪ. ﻣﺜﻼً 0.2-‪MIDP‬‬
                                             ‫‪ :MIDlet-Description‬ﺗﻮﺻﻴﻒ ﻛﻨﻨﺪه ‪.MIDlet suite‬‬
    ‫‪ :MIDlet-Icon‬ﻧﺎم ﻳﻚ ﻓﺎﻳﻞ ‪ PNG‬ﻛﻪ در داﺧﻞ ﻓﺎﻳﻞ ‪ JAR‬ﺑـﺮاي ﻧﻤـﺎﻳﺶ ‪ MIDlet Suite‬اﺳـﺘﻔﺎده‬
                                                                                                   ‫ﻣﻲ ﺷﻮد.‬
    ‫‪ :MIDlet-Info-URL‬ﻳـﻚ ‪ URL‬ﺑـﺮاي ذﺧﻴـﺮه اﻃﻼﻋـﺎت ﺑﻴـﺸﺘﺮ، ﻛـﻪ ‪ MIDlet suite‬را ﺗﻮﺻـﻴﻒ‬
      ‫ـ‬
                                                                                                   ‫ﻣﻲ ﻧﻤﺎﻳﺪ.‬
           ‫‪ :MIDlet-Data-Size‬ﺣﺪاﻗﻞ ﻣﻘﺪار ﺑﺎﻳﺖ داده ﭘﺎﻳﺪار ﻛﻪ ‪ MIDlet‬ﻧﻴﺎز دارد را ﻣﺸﺨﺺ ﻣﻲ ﻧﻤﺎﻳﺪ.‬
                                             ‫در ﺷﻜﻞ 1-51 ﻣﺤﺘﻮﻳﺎت ﻳﻚ ﻓﺎﻳﻞ ‪ JAD‬را ﻣﺸﺎﻫﺪه ﻣﻲ ﻧﻤﺎﻳﻴﺪ.‬


       ‫1‬
           ‫‪Application Management Software‬‬

                                                    ‫82‬
  ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬
www.txt.ir     www.txt.ir            www.txt.ir               www.txt.ir       www.txt.ir




                            JAD ‫ﺷﻜﻞ 1-51- ﻣﺤﺘﻮﻳﺎت ﻓﺎﻳﻞ‬



                                                           JAR ‫1-61- ﻣﺤﺘﻮﻳﺎت ﻓﺎﻳﻞ‬
                          .‫ را در ﺷﻜﻞ زﻳﺮ ﻣﺸﺎﻫﺪه ﻣﻲ ﻧﻤﺎﻳﻴﺪ‬Maze ‫ ﻛﻼس‬JAR ‫ﻣﺤﺘﻮﻳﺎت ﻓﺎﻳﻞ‬




                      Maze ‫ ﻛﻼس‬JAR ‫ﺷﻜﻞ1-61- ﻣﺤﺘﻮﻳﺎت ﻓﺎﻳﻞ‬



                                       29
  www.txt.ir    www.txt.ir           www.txt.ir              www.txt.ir     www.txt.ir
‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬



                                                                        ‫1-71- اﻳﺠﺎد ﻳﻚ ‪Canvas‬‬
    ‫از ﻛﻼس ‪ Canvas‬ﺑﺮاي ﺗﺮﺳﻴﻢ ﻫﺎي ﮔﺮاﻓﻴﻜﻲ در ﺑﺮﻧﺎﻣﻪ ﻫﺎي ﻛﺎرﺑﺮدي ﻣﺜﻞ ﺑﺎزي ﻫﺎ و ﻫﻤﭽﻨـﻴﻦ ﺑـﺮاي اداره‬
    ‫ﻛﺮدن روﻳﺪادﻫﺎي ﺳﻄﺢ ﭘـﺎﻳﻴﻦ اﺳـﺘﻔﺎده ﻣـﻲ ﮔـﺮدد. ‪ Canvas‬ﻛﻨﺘـﺮل ﻛـﺎﻣﻠﻲ ﺑـﺮ روي آﻧﭽـﻪ در ﺻـﻔﺤﻪ ﻛـﺸﻴﺪه‬
    ‫ﻣﻲ ﺷﻮد ﻣﻲ دﻫﺪ. ﺑﺎ اﻳﻦ ﺣﺎل ﺑﺎﻳﺪ ﻫﻤﻪ اﻳﻦ اﻋﻤﺎل را ﺑﻪ ﻃﻮر دﺳﺘﻲ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﻛﻨﻴﺪ، ﭼﻮن اﻳﻦ اﻋﻤﺎل ﻧﻤـﻲ ﺗﻮاﻧـﺪ‬
                                                                                     ‫در ﻃﺮاح ‪ UI‬اﻧﺠﺎم ﺷﻮد.‬
    ‫از آﻧﺠﺎﻳﻲ ﻛﻪ ‪ Canvas‬ﺑﺎ ﻛﺎﻣﭙﻮﻧﻨﺖ ﻫـﺎي ‪ Screen‬در ﺗﻘﺎﺑـﻞ اﺳـﺖ، ﻳـﻚ ﺑﺮﻧﺎﻣـﻪ ﻛـﺎرﺑﺮدي ﻣـﻲ ﺗﻮاﻧـﺪ از‬
    ‫ﺗﺮﻛﻴﺒﻲ از ﻛﺎﻣﭙﻮﻧﻨﺖ ﻫﺎي ‪ Screen‬و ‪ Canvas‬در ﺑﺮﻧﺎﻣﻪ ﻛﺎرﺑﺮدي اﺳﺘﻔﺎده ﻛﻨﺪ. ﺑﺮاي ﻣﺜﺎل ﺷـﻤﺎ ﻣـﻲ ﺗﻮاﻧﻴـﺪ از‬
             ‫ﻟﻴﺴﺖ ﺑﺮاي ﻓﺮاﻫﻢ ﻛﺮدن ﻣﻨﻮي اﻧﺘﺨﺎب ﻳﻚ ﺑﺎزي اﺳﺘﻔﺎده ﻧﻤﺎﻳﻴﺪ و از ‪ Canvas‬ﺑﺮاي اﻳﺠﺎد ﺧﻮد ﺑﺎزي.‬
    ‫ﺑﺮاي اﺳﺘﻔﺎده از ﻛﻼس ‪ Canvas‬ﺑﺎﻳﺪ آن را در ﻳﻚ ﺑﺮﻧﺎﻣﻪ ﻛﺎرﺑﺮدي ﺑﻪ ﺻـﻮرت زﻳـﺮ ﻛـﻼس ﺑـﺴﺎزﻳﺪ و ﻣﺘـﺪ‬
    ‫)(‪ paint‬را در زﻳﺮ ﻛﻼس ﭘﻴﺎده ﺳﺎزي ﻧﻤﺎﻳﻴﺪ. ﺷﻤﺎ ﺑﺎﻳﺪ ﻳﻚ ‪ Displayable‬ﺟﺪﻳـﺪ ﻛـﻪ از ‪ ،Canvas‬ﻣـﺸﺘﻖ‬
    ‫ﻣﻲ ﺷﻮد را اﻳﺠﺎد ﻧﻤﺎﻳﻴﺪ. در ﻛﺪ زﻳﺮﻛﻪ ﺗﻮﺳﻂ ﻣﺤﻴﻂ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﻧﺖ ﺑﻴﻨﺰ ﺗﻮﻟﻴﺪ ﺷﺪه اﺳﺖ، دﺳﺘﻮرات ﻻزم ﺑـﺮاي‬
                                                                    ‫اﻳﺠﺎد ﻳﻚ ‪ Canvas‬را ﻣﺸﺎﻫﺪه ﻣﻲ ﻧﻤﺎﻳﻴﺪ.‬

       ‫;*.‪import javax.microedition.lcdui‬‬


       ‫{ ‪public class MIDPCanvas extends Canvas implements CommandListener‬‬
         ‫**/‬
          ‫‪* constructor‬‬
          ‫/*‬
         ‫{ )(‪public MIDPCanvas‬‬
            ‫{ ‪try‬‬
                 ‫‪// Set up this canvas to listen to command events‬‬
                 ‫;)‪setCommandListener(this‬‬
                ‫‪// Add the Exit command‬‬
                ‫;))1 ,‪addCommand(new Command("Exit", Command.EXIT‬‬
             ‫{ )‪} catch(Exception e‬‬
                ‫;)(‪e.printStackTrace‬‬
             ‫}‬
         ‫}‬


          ‫**/‬
           ‫‪* paint‬‬
           ‫/*‬
          ‫{ )‪public void paint(Graphics g‬‬
             ‫;)‪g.drawString("Sample Text",0,0,Graphics.TOP|Graphics.LEFT‬‬
          ‫}‬


          ‫**/‬
           ‫.‪* Called when a key is pressed‬‬

                                                    ‫03‬
  ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬
www.txt.ir           www.txt.ir               www.txt.ir       www.txt.ir            www.txt.ir



          */
           protected void keyPressed(int keyCode) {
           }


          /**
           * Called when a key is released.
           */
            protected void keyReleased(int keyCode) {
            }


          /**
           * Called when a key is repeated (held down).
           */
            protected void keyRepeated(int keyCode) {
            }


          /**
           * Called when the pointer is dragged.
           */
            protected void pointerDragged(int x, int y) {
            }


          /**
           * Called when the pointer is pressed.
           */
           protected void pointerPressed(int x, int y) {
            }


          /**
           * Called when the pointer is released.
           */
          protected void pointerReleased(int x, int y) {
           }


          /**
           * Called when action should be handled
           */
           public void commandAction(Command command, Displayable displayable) {
            }

      }




                                                 31
  www.txt.ir            www.txt.ir             www.txt.ir     www.txt.ir           www.txt.ir
‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬                   ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬



                                                                     ‫1-81- ﻣﻌﺮﻓﻲ ﻛﻼس ‪Graphics‬‬
    ‫ﻛــــﻼس ﮔﺮاﻓﻴــــﻚ ﻳــــﻚ ﻛــــﻼس ﭘﺎﻳــــﻪ اﺳــــﺖ ﻛــــﻪ ﺑــــﺮاي اﺳــــﺘﻔﺎده از اﻳــــﻦ ﻛــــﻼس ﺑﺎﻳــــﺪ‬
    ‫‪ javax.microedition.lcdui.graphics‬را ﺑﻪ ﺑﺮﻧﺎﻣﻪ وارد ﻧﻤﺎﻳﻴﺪ. اﻳﻦ ﻛﻼس ﺑﺮاي رﺳـﻢ اﺷـﻜﺎل دو ﺑﻌـﺪي‬
    ‫ﻫﻨﺪﺳﻲ ﺳﺎده ﺑﻪ ﻛﺎر ﻣﻲ رود. رﺳﻢ اﺷﻜﺎل ﺳﺎده اي ﻧﻈﻴﺮ داﻳـﺮه، ﺧـﻂ، ﻣـﺴﺘﻄﻴﻞ، ﻛﻤـﺎن، ﻣـﺘﻦ، ﺗـﺼﻮﻳﺮ. ﻫﻤﭽﻨـﻴﻦ‬
    ‫ﻣﺴﺘﻄﻴﻞ ﻫﺎ و ﻛﻤﺎن ﻫﺎ را ﻣﻲ ﺗﻮان ﺑﺎ ﻳﻚ رﻧﮓ ﺳﺎده رﻧﮓ آﻣﻴﺰي ﻧﻤﻮد. ﻫﻤﭽﻨﻴﻦ ﺑﺎ اﺳﺘﻔﺎده از اﻳﻦ ﻛﻼس ﻣﻲ ﺗﻮان‬
    ‫ﺑﻪ ﺗﺮﺳﻴﻢ ﻣﺴﺘﻄﻴﻞ ﻫﺎﻳﻲ ﺑﺎ ﻟﺒﻪ ﮔﺮد ﭘﺮداﺧﺖ. اﻳﻦ ﻛﻼس ﺑﺮاي ﻳﻚ ﻣﺪل رﻧـﮓ از 42 ﺑﻴـﺖ اﺳـﺘﻔﺎده ﻣـﻲ ﻧﻤﺎﻳـﺪ ﻛـﻪ‬
    ‫ﻫﺸﺖ ﺑﻴﺖ آن ﻣﺮﺑﻮط ﺑﻪ رﻧﮓ ﻗﺮﻣﺰ، ﻫﺸﺖ ﺑﻴﺖ دﻳﮕﺮ ﻣﺮﺑﻮط ﺑﻪ رﻧﮓ ﺳﺒﺰ و ﻫﺸﺖ ﺑﻴﺖ ﺑﻘﻴﻪ ﻣﺮﺑﻮط ﺑﻪ رﻧﮓ آﺑـﻲ‬
                                                                                                         ‫ﻣﻲ ﺑﺎﺷﺪ.‬
    ‫اﻳﻦ ﻛﻼس ﻣﺘﺪﻫﺎﻳﻲ را ﺑﺮاي ﺗﺮﺳﻴﻢ اﺷﻜﺎل دو ﺑﻌﺪي و ﻛﺎر ﺑـﺎ آن ﻫـﺎ را در اﺧﺘﻴـﺎر ﻛـﺎرﺑﺮ ﻗـﺮار ﻣـﻲ دﻫـﺪ ﻛـﻪ‬
                                                                                                       ‫ﻋﺒﺎرﺗﻨﺪ از:‬


                                       ‫ﺟﺪول 1-1- ﻟﻴﺴﺖ ﻣﺘﺪﻫﺎي ﻛﻼس ‪Graphics‬‬


                           ‫•‬   ‫‪clipRect‬‬                               ‫•‬   ‫‪getClipHeight‬‬
                           ‫•‬   ‫‪copyArea‬‬                               ‫•‬   ‫‪getClipX‬‬
                           ‫•‬   ‫‪drawArc‬‬                                ‫•‬   ‫‪getClipY‬‬
                           ‫•‬   ‫‪drawChar‬‬                               ‫•‬   ‫‪getColor‬‬
                           ‫•‬   ‫‪drawChars‬‬                              ‫•‬   ‫‪getTranslateX‬‬
                           ‫•‬   ‫‪drawImage‬‬                              ‫•‬   ‫‪getTranslateY‬‬
                           ‫•‬   ‫‪drawLine‬‬                               ‫•‬   ‫‪getDisplayColor‬‬
                           ‫•‬   ‫‪drawRGB‬‬                                ‫•‬   ‫‪getFont‬‬
                           ‫•‬   ‫‪drawRect‬‬                               ‫•‬   ‫‪getGrayScale‬‬
                           ‫•‬   ‫‪drawRegion‬‬                             ‫•‬   ‫‪getGreenComponent‬‬
                           ‫•‬   ‫‪drawRoundRect‬‬                          ‫•‬   ‫‪getRedComponent‬‬
                           ‫•‬   ‫‪drawString‬‬                             ‫•‬   ‫‪getStrokeStyle‬‬
                           ‫•‬   ‫‪drawSubString‬‬                          ‫•‬   ‫‪setClip‬‬
                           ‫•‬   ‫‪fillRect‬‬                               ‫•‬   ‫‪setColor‬‬
                           ‫•‬   ‫‪fillArc‬‬                                ‫•‬   ‫‪setFont‬‬
                           ‫•‬   ‫‪fillRoundRect‬‬                          ‫•‬   ‫‪setGrayScale‬‬
                           ‫•‬   ‫‪fillTriangle‬‬                           ‫•‬   ‫‪setStrokeStyle‬‬
                           ‫•‬   ‫‪getBlueComponent‬‬                       ‫•‬   ‫‪translate‬‬
                           ‫•‬   ‫‪getClipWidth‬‬


                                                                  ‫ﺣﺎل ﺑﻪ ﻣﻌﺮﻓﻲ اﺟﻤﺎﻟﻲ اﻳﻦ ﻣﺘﺪﻫﺎ ﻣﻲ ﭘﺮدازﻳﻢ:‬
    ‫ﻣﺘﺪ ‪ :getColor‬اﻳﻦ ﻣﺘﺪ وﻇﻴﻔﻪ ﺑﺮﮔﺮداﻧﺪن رﻧﮓ ﺟـﺎري را ﺑﺮﻋﻬـﺪه دارد. ﺧﺮوﺟـﻲ اﻳـﻦ ﻣﺘـﺪ ﻳـﻚ ﻣﻘـﺪار‬
                                                                   ‫ﺻﺤﻴﺢ ﺑﻪ ﺷﻜﻞ ‪ 0x00RRGGBB‬ﻣﻲ ﺑﺎﺷﺪ.‬
        ‫)(‪Public int getColor‬‬

                                                       ‫23‬
  ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬                   ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬



     ‫ﻣﺘﺪ )(‪ :getGreenComponent‬اﻳﻦ ﻣﺘﺪ ﻣﻘﺪار ﺗﺮﻛﻴﺐ رﻧﮓ ﺳﺒﺰ در رﻧﮓ ﺟﺎري را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ.‬
        ‫ﻣﺘﺪ )(‪ :getRedComponent‬اﻳﻦ ﻣﺘﺪ ﻣﻘﺪار ﺗﺮﻛﻴﺐ رﻧﮓ ﻗﺮﻣﺰ در رﻧﮓ ﺟﺎري را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ.‬
        ‫ﻣﺘﺪ )(‪ :getBlueComponent‬اﻳﻦ ﻣﺘﺪ ﻣﻘﺪار ﺗﺮﻛﻴﺐ رﻧﮓ آﺑﻲ در رﻧﮓ ﺟﺎري را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ.‬
                                 ‫ﻣﺘﺪ ‪ :setColor‬ﺑﻪ وﺳﻴﻠﻪ اﻳﻦ ﻣﺘﺪ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ رﻧﮓ ﺟﺎري را ﺗﻐﻴﻴﺮ دﻫﻴﺪ.‬
        ‫)‪Public void setColor(int red , int green , int blue‬‬

                                                        ‫ﻣﻘﺎدﻳﺮ ‪ green ،red‬و ‪ blue‬ﺑﺎﻳﺪ ﺑﻴﻦ 0 ﺗﺎ 552 ﺑﺎﺷﺪ.‬
        ‫)‪Public void setColor(int RGB‬‬

         ‫ﻣﺘﺪ ‪ :getFont‬ﺑﺎ اﺳﺘﻔﺎده از اﻳﻦ ﻣﺘﺪ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﻣﺸﺨﺼﺎت ﻓﻮﻧﺖ ﺟﺎري ﺳﻴﺴﺘﻢ را ﺑﻪ دﺳﺖ آورﻳﺪ.‬
        ‫)(‪Public Font getFont‬‬


                         ‫ﻣﺘﺪ ‪ :setFont‬اﻳﻦ ﻣﺘﺪ ﻳﻚ ﺳﺮي ﺧﺼﻮﺻﻴﺎت را ﺑﺮاي ﻓﻮﻧﺖ ﺟﺎري ﺗﻌﻴﻴﻦ ﻣﻲ ﻧﻤﺎﻳﺪ.‬
        ‫)‪Public void setFont(Font font‬‬

      ‫ـﺪ ‪ :getStrokeStyle‬اﻳــﻦ ﻣﺘــﺪ ﻧــﻮع ﺣﺎﻟــﺖ ﺧــﻂ ﺟــﺎري را ﻛــﻪ ﺷــﺎﻣﻞ دو ﺣﺎﻟــﺖ ‪ SOLID‬و‬
                                                                                             ‫ﻣﺘـ‬
                                                                          ‫‪ DOTTED‬ﻣﻲ ﺑﺎﺷﺪ را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ.‬
        ‫)(‪Public void getStrokeStyle‬‬

    ‫ﻣﺘﺪ ‪ :setStrokeStyle‬ﺑﺎ اﺳﺘﻔﺎده از اﻳﻦ ﻣﺘﺪ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﻧﻮع ﺣﺎﻟﺖ ﺧـﻂ را ﺑـﺮاي رﺳـﻢ ﺧـﻂ، داﻳـﺮه،‬
    ‫ﻣــﺴﺘﻄﻴﻞ، ﻣــﺴﺘﻄﻴﻞ ﻟﺒــﻪ ﮔــﺮد و ﻛﻤــﺎن ﺗﻌﻴــﻴﻦ ﻧﻤﺎﻳﻴــﺪ. ﭘــﺎراﻣﺘﺮ ‪ Style‬ﻣــﻲ ﺗﻮاﻧــﺪ داراي دو ﺣﺎﻟــﺖ ‪ SOLID‬و‬
                                                                                              ‫‪ DOTTED‬ﺑﺎﺷﺪ.‬
        ‫)‪Public void setStrokeStyle(int style‬‬

    ‫ﻣﺘﺪ ‪ :drawLine‬از اﻳﻦ ﻣﺘﺪ ﺑﺮاي رﺳﻢ ﻳﻚ ﺧﻂ ﺳﺎده اﺳﺘﻔﺎده ﻣﻲ ﮔﺮدد. اﻳﻦ ﺧﻂ ﺑﻴﻦ ﻣﺨﺘﺼﺎت دو ﻧﻘﻄـﻪ‬
                                                    ‫)1‪ (x1,y‬و )2‪ (x2,y‬ﺑﺎ ﻧﻮع ﺣﺎﻟﺖ ﺧﻂ ﺟﺎري رﺳﻢ ﻣﻲ ﮔﺮدد.‬
        ‫)2‪Public void drawLine(int x1 , int y1 , int x2 , int y‬‬

    ‫ﻣﺘﺪ ‪ :fillRect‬از اﻳﻦ ﻣﺘﺪ ﺑﺮاي رﺳﻢ ﻳﻚ ﻣﺴﺘﻄﻴﻞ ﺗﻮﭘﺮ ﺑﺎ رﻧﮓ ﺟﺎري اﺳﺘﻔﺎده ﻣﻲ ﮔﺮدد. اﮔﺮ اﻧـﺪازه ﻃـﻮل‬
                                                                  ‫ﻳﺎ ﻋﺮض ﺻﻔﺮ ﺑﺎﺷﺪ، ﻫﻴﭻ ﭼﻴﺰي رﺳﻢ ﻧﻤﻲ ﮔﺮدد.‬
        ‫)‪Public void fillRect(int x , int y , int width , int height‬‬

    ‫ﻣﺘﺪ ‪ :drawRect‬از اﻳﻦ ﻣﺘﺪ ﺑﺮاي ﺗﺮﺳﻴﻢ ﺧﻄﻮط اﻃﺮاف ﻳﻚ ﻣﺴﺘﻄﻴﻞ ﺑﺎ ﺣﺎﻟﺖ ﺧﻂ و رﻧﮓ ﺟﺎري ﺑﻪ ﻛﺎر‬
                                                                                                         ‫ﻣﻲ رود.‬

                                                       ‫33‬
  ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬            ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬



       ‫)‪Public void drawRect(int x , int y , int width , int height‬‬

    ‫ﻣﺘﺪ ‪ :drawRounRect‬از اﻳﻦ ﻣﺘﺪ ﺑﺮاي ﺗﺮﺳﻴﻢ ﺧﻄﻮط اﻃﺮاف ﻳﻚ ﻣﺴﺘﻄﻴﻞ ﻟﺒـﻪ ﮔـﺮد ﺑـﺎ ﺣﺎﻟـﺖ ﺧـﻂ و‬
                                                                                 ‫رﻧﮓ ﺟﺎري ﺑﻪ ﻛﺎر ﻣﻲ رود.‬
       ‫‪Public void drawRounRect(int x , int y , int width , int height , int arcWidth‬‬
                                                                        ‫)‪, int arcHeight‬‬

    ‫ﻣﺘﺪ ‪ :fillRoundRect‬از اﻳﻦ ﻣﺘﺪ ﺑﺮاي ﺗﺮﺳﻴﻢ ﻳﻚ ﻣﺴﺘﻄﻴﻞ ﺗﻮﭘﺮ ﺑﺎ ﻟﺒﻪ ﻫﺎي ﮔﺮد و ﺑﺎ رﻧﮓ ﺟﺎري اﺳﺘﻔﺎده‬
                                                                                                   ‫ﻣﻲ ﮔﺮدد.‬
       ‫, ‪Public void fillRounRect(int x , int y , int width , int height‬‬
                                                ‫)‪int arcWidth , int arcHeight‬‬

    ‫ﻣﺘﺪ ‪ :fillArc‬از اﻳﻦ ﻣﺘﺪ ﺑﺮاي ﺗﺮﺳﻴﻢ ﻳﻚ ﻗﺴﻤﺘﻲ از داﻳﺮه ﻳﺎ ﺑﻴﻀﻲ ﺑﻪ ﺻﻮرت ﺗﻮﭘﺮ ﺑﺎ رﻧﮓ ﺟـﺎري اﺳـﺘﻔﺎده‬
                                                                                                   ‫ﻣﻲ ﮔﺮدد.‬
       ‫, ‪Public void fillArc(int x , int y , int width , int height‬‬
                                  ‫)‪int startAngle , int endAngle‬‬


    ‫ﻣﺘﺪ ‪ :drawArc‬از اﻳﻦ ﻣﺘﺪ ﺑﺮاي ﺗﺮﺳﻴﻢ ﻳﻚ ﻛﻤﺎن از داﻳﺮه ﻳﺎ ﺑﻴﻀﻲ ﺑﺎ ﺣﺎﻟﺖ ﺧﻂ و رﻧﮓ ﺟـﺎري اﺳـﺘﻔﺎده‬
                                                  ‫ﻣﻲ ﮔﺮدد. ﭘﺎراﻣﺘﺮﻫﺎي اﻳﻦ ﻣﺘﺪ ﻫﻤﺎﻧﻨﺪ ﻣﺘﺪ ‪ fillArc‬ﻣﻲ ﺑﺎﺷﺪ.‬


    ‫ﻣﺘﺪ ‪ :drawString‬از اﻳﻦ ﻣﺘﺪ ﺑﺮاي ﺗﺮﺳﻴﻢ ﻳﻚ ﻣﺘﻦ ﺳﺎده ﺑﺎ رﻧﮓ و ﻓﻮﻧـﺖ ﺟـﺎري در ﻣﻮﻗﻌﻴـﺖ )‪ ( x,y‬و‬
    ‫در ﻧﻘﻄﻪ ﻟﻨﮕﺮ داده ﺷﺪه ﺑﻪ ﻛﺎر ﻣﻲ ﮔﺮدد. اﻳﻦ ﻣﺘﺪ ﻳﻚ ﺳﺮي ﻣﻘﺎدﻳﺮ ﺛﺎﺑﺖ ﺑﺮاي ﺗﻌﻴـﻴﻦ ﻣﻮﻗﻌﻴـﺖ ﻣـﺘﻦ ﺗﻮﺳـﻂ ﻧﻘـﺎط‬
                                                        ‫ﻟﻨﮕﺮ دارد ﻛﻪ در زﻳﺮ ﻟﻴﺴﺖ آن ﻫﺎ را ﻣﺸﺎﻫﺪه ﻣﻲ ﻧﻤﺎﻳﻴﺪ.‬
                                                                                ‫‪HCENTER‬‬           ‫•‬
                                                                                ‫‪VCENTER‬‬           ‫•‬
                                                                                     ‫‪TOP‬‬          ‫•‬
                                                                                    ‫‪LEFT‬‬          ‫•‬
                                                                                   ‫‪RIGHT‬‬          ‫•‬
                                                                                 ‫‪BOTTOM‬‬           ‫•‬
                                                                                ‫‪BASELINE‬‬          ‫•‬



                                                   ‫در زﻳﺮ دو ﻧﻤﻮﻧﻪ از ﻛﺎرﺑﺮد اﻳﻦ ﻣﺘﺪ را ﻣﺸﺎﻫﺪه ﻣﻲ ﻧﻤﺎﻳﻴﺪ:‬
       ‫)‪g.drawString("Test" , 10, 20 , TOP | LEFT‬‬
       ‫)‪g.drawString("Ali", 100 , 42 , BASELINE | HCENTER‬‬


                                                   ‫43‬
  ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬            ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬



    ‫ﻣﺘﺪ ‪ :drawSubString‬از اﻳﻦ ﻣﺘﺪ ﺑﺮاي رﺳﻢ ﻳﻚ زﻳﺮ رﺷﺘﻪ از ﻳﻚ رﺷﺘﻪ اﺻﻠﻲ ﺑﺮ روي ﺻـﻔﺤﻪ ﻧﻤـﺎﻳﺶ‬
                                                   ‫اﺳﺘﻔﺎده ﻣﻲ ﮔﺮدد. اﻳﻦ ﻣﺘﺪ ﺷﺒﻴﻪ ﺑﻪ ﻣﺘﺪ ‪ drawString‬اﺳﺖ.‬
       ‫, ‪Public void drawSubString( String str , int offset , int len , int x‬‬
                                                            ‫)‪int y , int anchor‬‬

     ‫ﻣﺘﺪ ‪ :drawChar‬از اﻳﻦ ﻣﺘﺪ ﺑﺮاي ﺗﺮﺳﻴﻢ ﻳﻚ ﻛﺎرﻛﺘﺮ ﺧﺎص ﺑﺎ ﻓﻮﻧﺖ و رﻧﮓ ﺟﺎري اﺳﺘﻔﺎده ﻣﻲ ﮔﺮدد.‬
       ‫)‪Public void drawChar(Char character , int x , int y , int anchor‬‬

    ‫ﻣﺘﺪ ‪ :drawChars‬اﻳﻦ ﻣﺘﺪ ﻫﻤﺎﻧﻨﺪ ﻣﺘﺪ ‪ drawSubString‬ﺑﺮاي ﺗﺮﺳﻴﻢ ﻳﻚ ﺳﺮي ﻛﺎرﻛﺘﺮ ﺧﺎص ﭘﺸﺖ‬
                        ‫ﺳﺮ ﻫﻢ از ﻣﻮﻗﻌﻴﺖ داده ﺷﺪه در آراﻳﻪ ﻛﺎرﻛﺘﺮ ﻫﺎ ﺑﺎ ﻓﻮﻧﺖ و رﻧﮓ ﺟﺎري اﺳﺘﻔﺎده ﻣﻲ ﮔﺮدد.‬
       ‫, ‪Public void drawChars(Char[] data , int offset , int len , int x‬‬
                                                        ‫)‪int y , int anchor‬‬


    ‫ﻣﺘﺪ ‪ :translate‬اﻳﻦ ﻣﺘﺪ وﻇﻴﻔﻪ ﺑﺮﮔﺮداﻧﺪن زﻣﻴﻨﻪ ﮔﺮاﻓﻴﻜـﻲ ﻣﺒـﺪا را ﺑـﻪ ﻧﻘﻄـﻪ )‪ ( x,y‬در ﻣﺨﺘـﺼﺎت ﺟـﺎري‬
    ‫ﺳﻴﺴﺘﻢ را ﺑﺮ ﻋﻬﺪه دارد. ﺑﺮاي ﻣﺜﺎل ﻓﺮاﺧـﻮاﻧﻲ )2,1(‪ translate‬و ﺳـﭙﺲ )4,3(‪ translate‬ﻧﺘﻴﺠـﻪ اﻧﺘﻘـﺎل را در‬
                                                                              ‫)6,4(‪ translate‬ﻗﺮار ﻣﻲ دﻫﺪ.‬


    ‫دو ﻣﺘﺪ )(‪ getTranslateX‬و )(‪ :getTranslateY‬اﻳﻦ دو ﻣﺘﺪ وﻇﻴﻔﻪ ﺑﺮﮔﺮداﻧـﺪن ﻣﺨﺘـﺼﺎت ‪ x‬و‬
                                                               ‫‪ y‬اﻧﺘﻘﺎل را در زﻣﻴﻨﻪ ﮔﺮاﻓﻴﻜﻲ ﻣﺒﺪا ﺑﺮ ﻋﻬﺪه دارد.‬


               ‫ﻣﺘﺪ ‪ :fillTriangle‬از اﻳﻦ ﻣﺘﺪ ﺑﺮاي ﺗﺮﺳﻴﻢ ﻳﻚ ﻣﺜﻠﺚ ﺗﻮﭘﺮ ﺑﺎ رﻧﮓ ﺟﺎري اﺳﺘﻔﺎده ﻣﻲ ﮔﺮدد.‬
       ‫)3‪Public void fillTriangle (int x1 , int y1 , int x2 , int y2 , int x3 , int y‬‬

      ‫ﻣﺘﺪ ‪ :drawImage‬از اﻳﻦ ﻣﺘﺪ ﺑﺮاي ﺗﺮﺳﻴﻢ ﻳﻚ ﺗﺼﻮﻳﺮ ﻣﻌﻴﻦ ﺑﺎ اﺳﺘﻔﺎده از ﻧﻘﺎط ﻟﻨﮕﺮ اﺳﺘﻔﺎده ﻣﻲ ﮔﺮدد.‬
       ‫)‪Public void drawImage (Image img , int x , int y , int anchor‬‬

    ‫ﻣﺘﺪ ‪ :drawRegion‬از اﻳﻦ ﻣﺘﺪ ﺑﺮاي ﻛﭙﻲ ﻳﻚ ﻧﺎﺣﻴﻪ ﻣﻌـﻴﻦ از ﺗـﺼﻮﻳﺮ ﻣﺒـﺪا ﺑـﻪ ﻳـﻚ ﻣﻮﻗﻌﻴـﺖ در ﻣﻘـﺼﺪ‬
    ‫اﺳﺘﻔﺎده ﻣﻲ ﮔﺮدد. ﻫﻤﭽﻨﻴﻦ اﻋﻤﺎل ﭼﺮﺧﺶ و ﺑﺎزﺗﺎب ﺗﺼﻮﻳﺮ ﺑﺎ اﺳﺘﻔﺎده از ﺗﻮاﺑﻊ ﺗﻐﻴﻴﺮ ﺷﻜﻞ اﻣﻜﺎن ﭘﺬﻳﺮ ﻣﻲ ﺑﺎﺷﺪ.‬

       ‫, ‪Public void drawRegion( Image src , int x-src , int y-src , int width‬‬
                                ‫)‪int height , int transform , int x-dest , int y-dest , int anchor‬‬




                                                    ‫53‬
  ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬            ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬



                    ‫در زﻳﺮ ﺑﺮﺧﻲ از اﻳﻦ ﺗﻮاﺑﻊ ﺗﻐﻴﻴﺮ ﺷﻜﻞ ﻛﻪ از ﻛﻼس ‪ Sprint‬ﻣﻲ ﺑﺎﺷﺪ را ﻣﺸﺎﻫﺪه ﻣﻲ ﻧﻤﺎﻳﻴﺪ.‬
                                                             ‫‪Sprint.TRNS_NONE‬‬                 ‫•‬
                                                             ‫09‪Sprint.TRNS_ROT‬‬                ‫•‬
                                                            ‫081‪Sprint.TRNS_ROT‬‬                ‫•‬
                                                            ‫072‪Sprint.TRNS_ROT‬‬                ‫•‬
                                                   ‫09‪Sprint.TRNS_MIRROR_ROT‬‬                   ‫•‬
                                                  ‫081‪Sprint.TRNS_MIRROR_ROT‬‬                   ‫•‬


                                                                            ‫1-91-ﻛﻼس ‪Display‬‬
    ‫اﻳﻦ ﻛﻼس ﺑﺮاي ﻧﻤﺎﻳﺶ ﺻﻔﺤﻪ ﻳﺎ ﻓﺮم ﻫﺎﻳﻲ ﻛﻪ در ﺑﺮﻧﺎﻣﻪ اﺳﺘﻔﺎده ﻛﺮدﻳﻢ، اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد. ﺑﺮاي ﻧﺸﺎن دادن‬
    ‫ﻳﻚ ﺻﻔﺤﻪ ﻳﺎ ﻓﺮم ﻗﺎﺑﻞ ﻧﻤﺎﻳﺶ، اﺑﺘﺪا ﺑﺎﻳﺪ ﻳﻚ ﺷـﻲء از ﻧـﻮع ‪ Display‬ﺗﻌﺮﻳـﻒ ﻛﻨـﻴﻢ. ﺳـﭙﺲ ﺑـﺎ اﺳـﺘﻔﺎده از ﻣﺘـﺪ‬
    ‫‪ getDisplay‬آن را ﻣﺠﺎب ﺳﺎزﻳﻢ و ﺳﺮاﻧﺠﺎم ﺑﺎ اﺳﺘﻔﺎده از ﻣﺘﺪ ‪ setcurrent‬ﺻـﻔﺤﻪ ﻳـﺎ ﻓـﺮم دﻟﺨـﻮاه را ﻧﻤـﺎﻳﺶ‬
                                                                                                   ‫دﻫﻴﻢ.‬
                                                             ‫ﺗﻌﺪادي از ﻣﺘﺪﻫﺎي ﻣﻬﻢ اﻳﻦ ﻛﻼس ﻋﺒﺎرﺗﻨﺪ :‬
                      ‫‪ : isColor‬اﻃﻼﻋﺎﺗﻲ درﺑﺎره رﻧﮓ ﻫﺎﻳﻲ ﻛﻪ در وﺳﻴﻠﻪ ﭘﺸﺘﻴﺒﺎﻧﻲ ﻣﻲ ﺷﻮد را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬
                            ‫‪ : numColor‬ﺗﻌﺪاد رﻧﮓ ﻫﺎﻳﻲ ﻛﻪ در اﻳﻦ وﺳﻴﻠﻪ اراﺋﻪ ﻣﻲ ﺷﻮد را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬
                                  ‫‪ : SetCurrent‬ﻳﻚ ﻓﺮم ﻳﺎ ﺻﻔﺤﻪ را ﺑﻪ ﻋﻨﻮان ﭘﻴﺶ ﻓﺮض ﻧﻤﺎﻳﺶ ﻣﻲ دﻫﺪ.‬
                        ‫‪ : getCurrent‬ﺻﻔﺤﻪ ﻳﺎ ﻓﺮم ﭘﻴﺶ ﻓﺮض را ﻛﻪ در ﺣﺎل ﻧﻤﺎﻳﺶ اﺳﺖ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬




                                                   ‫63‬
  ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬
www.txt.ir     www.txt.ir     www.txt.ir     www.txt.ir      www.txt.ir




                        ‫ و ﻧﺤﻮه اﺳﺘﻔﺎده از آن‬RMS ‫ﻓﺼﻞ دوم – ﻣﻌﺮﻓﻲ‬




                               37
  www.txt.ir    www.txt.ir    www.txt.ir     www.txt.ir    www.txt.ir
‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬                   ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬




                                         ‫ﻓﺼﻞ دوم – ﻣﻌﺮﻓﻲ ‪ RMS‬و ﻧﺤﻮه اﺳﺘﻔﺎده از آن‬

                                                                                    ‫1‬
                                                                                        ‫2-1- ﻣﻌﺮﻓﻲ ‪RMS‬‬
    ‫‪ MIDP‬ﻳﻚ ﻣﻜﺎﻧﻴﺰم ﺑﺮاي ‪ MIDlet‬ﺑﻪ ﻣﻨﻈﻮر ذﺧﻴﺮه ﺳﺎزي ﭘﺎﻳﺎ داده ﻫﺎ و ﺑﺎزﻳﺎﺑﻲ آن ﻓﺮاﻫﻢ ﻣـﻲ ﻛﻨـﺪ. اﻳـﻦ‬
    ‫2‬
        ‫ﻣﻜﺎﻧﻴﺰم ﻳﻚ ﭘﺎﻳﮕﺎه داده ﺳﺎده اﺳﺖ ﻛﻪ ‪ RMS‬ﻧﺎﻣﻴﺪه ﻣﻲ ﺷﻮد. ﻳﻚ ﭘﺎﻳﮕﺎه داده ‪ MIDP‬ﻳﺎ ﻳﻚ رﻛﻮرد ‪‬اﺳﺘﻮر‬
    ‫از ﻣﺠﻤﻮﻋﻪ رﻛﻮردﻫﺎﻳﻲ ﺗﺸﻜﻴﻞ ﺷﺪه ﻛـﻪ ﺑﻌـﺪ از ﺧـﺮوج از ‪ ،MIDlet‬ﭘﺎﻳـﺎ ﻣـﻲ ﻣﺎﻧﻨـﺪ. وﻗﺘـﻲ ﺷـﻤﺎ ‪ MIDlet‬را‬
                                         ‫دوﺑﺎره اﺟﺮا ﻣﻲ ﻛﻨﻴﺪ، ﻣﻲ ﺗﻮاﻧﻴﺪ داده ﻫﺎ را از رﻛﻮرد اﺳﺘﻮر ﺑﺎزﻳﺎﺑﻲ ﻧﻤﺎﻳﻴﺪ.‬




                                         ‫ﺷﻜﻞ 2-1- ﺳﻴﺴﺘﻢ ﻣﺪﻳﺮﻳﺖ رﻛﻮرد‬


          ‫1‬
              ‫‪Record Management System‬‬
          ‫2‬
              ‫‪Record Store‬‬

                                                      ‫83‬
  ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬



                                                                                         ‫2-2- رﻛﻮردﻫﺎ‬
    ‫ﻳﻚ رﻛﻮرد، ﻳﻚ داده ﻣﻨﻔﺮد اﺳﺖ. ‪ RMS‬ﻫﻴﭻ ﻣﺤﺪودﻳﺘﻲ روي آﻧﭽﻪ ﻛﻪ در ﻳﻚ رﻛﻮرد ﻗﺮار ﻣـﻲ دﻫﻴـﺪ،‬
    ‫اﻋﻤﺎل ﻧﻤﻲ ﻛﻨﺪ. ﻳﻚ رﻛﻮرد ﻣﻲ ﺗﻮاﻧﺪ ﺷﺎﻣﻞ ﻳﻚ ﻋﺪد، ﻳﻚ رﺷﺘﻪ، ﻳﻚ آراﻳﻪ، ﻳﻚ ﺗﺼﻮﻳﺮ و ﺑﻪ ﻋﺒﺎرت دﻳﮕﺮ ﻫـﺮ‬
    ‫ﭼﻴﺰي ﻛﻪ دﻧﺒﺎﻟﻪ اي از ﺑﺎﻳﺖ ﻫﺎ اﺳﺖ ﺑﺎﺷﺪ. اﮔﺮ ﺑﺘﻮاﻧﻴﺪ ﻳﻚ دﻳﻜﺪر ﺑـﺎﻳﻨﺮي و اﻧﻜـﺪر ﻣﺘﻨﺎﺳـﺐ آن را اﻳﺠـﺎد ﻧﻤﺎﻳﻴـﺪ‬
    ‫ﻣﻲ ﺗﻮاﻧﻴﺪ در ﻳﻚ رﻛﻮرد اﺷﻴﺎﻳﻲ ﺑﺎ ﻫﺮ اﻧﺪازه را ذﺧﻴﺮه ﻛﻨﻴﺪ. اﻟﺒﺘﻪ ﺑﺎ اﻋﻤﺎل ﻣﺤـﺪودﻳﺖ ﻫـﺎﻳﻲ ﻛـﻪ ﺳﻴـﺴﺘﻢ ﺗﺤﻤﻴـﻞ‬
                                                                                                     ‫ﻣﻲ ﻛﻨﺪ.‬
    ‫ﺑﺴﻴﺎري از ﻛﺴﺎﻧﻲ ﻛﻪ ﺗﺎزه ﺷﺮوع ﺑﻪ ﻛﺎر ﺑﺎ ‪ RMS‬ﻧﻤﻮده اﻧﺪ، از اﺻﻄﻼح رﻛﻮرد در آن ﺳﺮدر ﮔﻢ ﻣﻲ ﺷـﻮﻧﺪ.‬
    ‫آن ﻫﺎ ﻣﻲ ﭘﺮﺳﻨﺪ ﻓﻴﻠﺪﻫﺎ ﻛﺠﺎ ﻫﺴﺘﻨﺪ؟ ﭼﮕﻮﻧﻪ ﺳﻴﺴﺘﻢ رﻛﻮردﻫﺎي ﻣﻨﻔـﺮد را ﺑـﻪ ﺗﺮﺗﻴﺒـﻲ از داده ﻫـﺎي ﮔﺴـﺴﺘﻪ ﺗﻘـﺴﻴﻢ‬
    ‫ﻣﻲ ﻛﻨﺪ؟ ﭘﺎﺳﺦ ﺳﺎده اﺳﺖ: در ‪ RMS‬ﻳﻚ رﻛﻮرد ﻫﻴﭻ ﻓﻴﻠﺪي ﻧﺪارد ﻳﺎ ﺑﻪ ﻃﻮر دﻗﻴـﻖ ﻳـﻚ رﻛـﻮرد از ﻳـﻚ ﻓﻴﻠـﺪ‬
                   ‫ﺑﺎﻳﻨﺮي ﺑﺎ اﻧﺪازه ﻣﺘﻐﻴﺮ ﺗﺸﻜﻴﻞ ﺷﺪه اﺳﺖ. ﻣﺴﺌﻮﻟﻴﺖ ﺗﻔﺴﻴﺮ ﻳﻚ رﻛﻮرد ﺑﺮﻋﻬﺪه ﺑﺮﻧﺎﻣﻪ ﻛﺎرﺑﺮدي اﺳﺖ.‬
    ‫‪ RMS‬ﻳﻚ ﻣﺤﻞ ذﺧﻴﺮه ﺳﺎزي و ﻳﻚ ﺷﻨﺎﺳﻪ ﻣﻨﺤﺼﺮ ﺑﻪ ﻓﺮد ﻓﺮاﻫﻢ ﻣﻲ آورد و ﻧﻪ ﭼﻴﺰ دﻳﮕﺮي. در ﺣﺎﻟﻲ ﻛﻪ‬
    ‫اﻳﻦ ﺗﻘﺴﻴﻢ ﺑﻨﺪي ﻛﺎر ﺑﺮاي ﻳﻚ ﺑﺮﻧﺎﻣﻪ ﻛﺎرﺑﺮدي ﭘﻴﭽﻴﺪه اﺳﺖ. ﺑﺎ اﻳـﻦ ﺣـﺎل ‪ RMS‬را ﻛﻮﭼـﻚ و اﻧﻌﻄـﺎف ﭘـﺬﻳﺮ‬
    ‫ﻣﻲ ﺳﺎزد. ﻳﻚ رﻛﻮرد اﺳﺘﻮر، ﻳﻚ ﻣﺠﻤﻮﻋﻪ ﻣﺮﺗﺐ از رﻛﻮرد ﻫﺎﺳﺖ. رﻛﻮردﻫﺎ ﻧﻬﺎدﻫﺎي ﻣﺴﺘﻘﻠﻲ ﻧﻴﺴﺘﻨﺪ ﺑﻠﻜﻪ ﻫﻤﻪ‬
    ‫ﺑﺎﻳﺪ واﺑﺴﺘﻪ ﺑﻪ ﻳﻚ رﻛﻮرد اﺳﺘﻮر ﺑﺎﺷﻨﺪ و دﺳﺘﺮﺳﻲ ﻫﺎي اﻧﺠﺎم ﺷﺪه ﺑﻪ ﻫﻤﻪ رﻛﻮردﻫﺎ از ﻃﺮﻳﻖ رﻛﻮرد اﺳـﺘﻮر اﻧﺠـﺎم‬
    ‫ﻣﻲ ﺷﻮد. در واﻗﻊ رﻛﻮرد اﺳﺘﻮر ﺗﻀﻤﻴﻦ ﻣﻲ ﻛﻨﺪ ﻛﻪ ﻫﻤـﻪ رﻛﻮردﻫـﺎ ﺑـﺪون ﺧﺮاﺑـﻲ اﺣﺘﻤـﺎﻟﻲ در داده ﻫـﺎ، ﻧﻮﺷـﺘﻪ و‬
                                                                                                ‫ﺧﻮاﻧﺪه ﺷﻮﻧﺪ.‬
    ‫وﻗﺘﻲ ﻳﻚ رﻛﻮرد اﻳﺠﺎد ﻣﻲ ﺷﻮد، رﻛﻮرد اﺳﺘﻮر ﻳﻚ ﺷﻨﺎﺳﻪ ﻣﻨﺤﺼﺮ ﺑﻪ ﻓﺮد ﺑﻪ آن ﻧـﺴﺒﺖ ﻣـﻲ دﻫـﺪ، ﻣﻘـﺪاري‬
    ‫ﺻﺤﻴﺢ ﻛﻪ ﺷﻨﺎﺳﻪ رﻛﻮرد1 ﻧﺎﻣﻴﺪه ﻣﻲ ﺷﻮد. اوﻟﻴﻦ ﺷﻨﺎﺳﻪ رﻛﻮرد ﺑﺮاﺑﺮ 1 ﻗـﺮار داده ﻣـﻲ ﺷـﻮد و دوﻣـﻲ ﺑﺮاﺑـﺮ 2 و ....‬
    ‫ﺣﺘﻲ اﮔﺮ رﻛﻮردي ﺣﺬف ﮔﺮدد، ﺑﺎز ﻫﻢ آﺧﺮﻳﻦ ﻣﻘﺪار ﻣﻨﺘﺴﺐ ﺑﻪ ﺷﻨﺎﺳﻪ رﻛﻮرد ﻣﺸﺨﺺ اﺳﺖ و ﺑﻪ رﻛﻮرد ﺟﺪﻳـﺪ‬
                                                          ‫ﻣﻘﺪاري ﺑﻌﺪ از آﺧﺮﻳﻦ اﻧﺘﺴﺎب ﻗﺒﻠﻲ ﻧﺴﺒﺖ داده ﻣﻲ ﺷﻮد.‬




                                            ‫ﺷﻜﻞ2-2- ﺳﺎﺧﺘﺎر رﻛﻮردﻫﺎ‬

       ‫1‬
           ‫‪Record Id‬‬

                                                     ‫93‬
  ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬



    ‫ﻧﺎم ﻫﺎ ﺑﺮاي ﻣﺸﺨﺺ ﻛﺮدن رﻛﻮرد اﺳﺘﻮرﻫﺎ در ‪ MIDlet suite‬ﺑﻪ ﻛﺎر ﻣﻲ روﻧﺪ ﻧﺎم ﻳﻚ رﻛـﻮرد اﺳـﺘﻮر از‬
    ‫1 ﺗﺎ 23 ﻛﺎرﻛﺘﺮ ﻳﻮﻧﻴﻜﺪ ﺗﺸﻜﻴﻞ ﺷﺪه اﺳﺖ و ﺑﺎﻳﺪ در ﻳـﻚ ‪ MIDlet suite‬ﻛـﻪ رﻛـﻮرد اﺳـﺘﻮر را اﻳﺠـﺎد ﻛـﺮده،‬
    ‫ﻣﻨﺤﺼﺮ ﺑﻪ ﻓﺮد ﺑﺎﺷﻨﺪ. در 0.1 ‪ ، MIDP‬رﻛﻮرد اﺳﺘﻮرﻫﺎ ﻧﻤﻲ ﺗﻮاﻧﻨﺪ ﺑﺎ ‪ MIDlet suite‬ﻫﺎي دﻳﮕﺮ ﺑـﻪ اﺷـﺘﺮاك‬
    ‫ﮔﺬاﺷﺘﻪ ﺷﻮﻧﺪ. 0.2 ‪ MIDP‬ﺑﻪ ﻃﻮر اﺧﺘﻴﺎري ﺑﻪ ﻳﻚ ‪ MIDlet suite‬اﺟﺎزه ﺑﻪ اﺷﺘﺮاك ﮔﺬاﺷﺘﻦ رﻛﻮرد اﺳﺘﻮر‬
                                                                       ‫را ﺑﺎ ﺳﺎﻳﺮ ‪ suite‬ﻫﺎ در اﺧﺘﻴﺎر ﻣﻲ ﮔﺬارد.‬
    ‫رﻛﻮرد اﺳﺘﻮر ﻫﺎ ﻫﻤﭽﻨﻴﻦ زﻣﺎن ﻧﻘﺶ ﺑﺴﺘﻦ1، اﻃﻼﻋـﺎت ﻧـﺴﺨﻪ را ﻧﮕﻬـﺪاري ﻣـﻲ ﻛﻨﻨـﺪ ﺗـﺎ ﺑﺮﻧﺎﻣـﻪ ﻛـﺎرﺑﺮدي ﺑﺘﻮاﻧـﺪ‬
                                                              ‫آﺧﺮﻳﻦ زﻣﺎن دﺳﺘﻜﺎري و ﺗﻐﻴﻴﺮ آن را ﻣﺸﺨﺺ ﻛﻨﺪ.‬


                                                                   ‫2-3- ﻣﺤﺪودﻳﺘﻬﺎي ذﺧﻴﺮه ﺳﺎزي‬
    ‫ﻣﻘﺪار ﺣﺎﻓﻈﻪ در دﺳﺘﺮس ﺑﺮاي ذﺧﻴﺮه ﺳﺎزي داده ﻫﺎ، ﺑﺮ ﻣﺒﻨﺎي رﻛﻮرد از ﻳﻚ وﺳﻴﻠﻪ ﺑﻪ وﺳـﻴﻠﻪ دﻳﮕـﺮ ﻣﺘﻔـﺎوت‬
    ‫اﺳﺖ.‪ MIDP‬ﺗﺸﺨﻴﺺ ﻣﻲ دﻫﺪ وﺳﻴﻠﻪ ﻫﺎ ﺑﻪ ﺻﻮرت رزرو، ﺣﺪاﻗﻞ ‪ 8 kB‬ﺣﺎﻓﻈﻪ ﻏﻴﺮ ﻓﺮار ﺑﻪ ﻋﻨـﻮان ﺣﺎﻓﻈـﻪ داده‬
    ‫ﭘﺎﻳﺪار ﻧﻴﺎز دارﻧﺪ. ﻣﺸﺨﺼﻪ ﻫﺎ ﻫﻴﭻ ﻣﺤﺪودﻳﺘﻲ ﺑﺮاي اﻧﺪازه ﻳﻚ رﻛﻮرد ﻣﻨﻔﺮد ﻣﻄﺮح ﻧﻤﻲ ﻛﻨﻨﺪ، اﻣﺎ ﻣﺤـﺪوﻳﺖ ﻓـﻀﺎ‬
    ‫ﺑﻴﻦ وﺳﻴﻠﻪ ﻫﺎ ﻣﺘﻔﺎوت اﺳﺖ. ‪ RMS‬رﻛﻮرد ﻫﺎﻳﻲ را ﺑﺮاي ﺗﻌﻴﻴﻦ اﻧﺪازه ﻳﻚ رﻛﻮرد واﺣﺪ، ﻣﺠﻤﻮع اﻧـﺪازه رﻛـﻮرد‬
    ‫اﺳﺘﻮر و ﻣﻘﺪار ﻓﻀﺎي ﺣﺎﻓﻈﻪ ﺑﺎﻗﻲ ﻣﺎﻧﺪه ﺑﺮاي داده ﻫﺎ ﻓﺮاﻫﻢ ﻣﻲ آورد. ﺑﻪ ﺧـﺎﻃﺮ ﺑـﺴﭙﺎرﻳﺪ ﻛـﻪ ﺣﺎﻓﻈـﻪ ﭘﺎﻳـﺪار، ﻳـﻚ‬
                                                 ‫ﺣﺎﻓﻈﻪ اﺷﺘﺮاﻛﻲ ﺑﺎ ﻣﻨﺎﺑﻊ ﻛﻮﭼﻚ و اﻗﺘﺼﺎدي از ﻧﻈﺮ اﺳﺘﻔﺎده اﺳﺖ.‬
    ‫ﻫﺮ ‪ MIDlet suite‬ﻛﻪ از ‪ RMS‬اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﺪ، ﺑﺎﻳﺪ ﺣﺪاﻗﻞ ﺗﻌﺪاد ﺑﺎﻳﺘﻬﺎي ﺣﺎﻓﻈﻪ داده ﻣـﻮرد ﻧﻴـﺎز ﺧـﻮد‬
    ‫را ﺑﺎ ﺗﻨﻈﻴﻢ ﺻﻔﺖ ‪ MIDlet-Data-Size‬در ‪ JAR manifest‬و ﺗﻮﺻـﻴﻒ ﻛﻨﻨـﺪه ﺑﺮﻧﺎﻣـﻪ ﻛـﺎرﺑﺮدي ﻣـﺸﺨﺺ‬
    ‫ﻛﻨﺪ. اﻳﻦ ﻣﻘﺪار را ﺑﺰرﮔﺘﺮ از ﺣﺪاﻛﺜﺮ ﻓﻀﺎي ﻣﻮرد ﻧﻴﺎز ﻗﺮار ﻧﺪﻫﻴﺪ، ﭼﺮا ﻛﻪ ﻣﻤﻜﻦ اﺳﺖ وﺳﻴﻠﻪ از ﻧﺼﺐ ‪MIDlet‬‬
    ‫‪ suite‬اي ﻛﻪ ﺣﺎﻓﻈﻪ داده ﻣﻮرد ﻧﻴﺎز آن از ﻓﻀﺎي ﻣﻮﺟﻮد ﺗﺠﺎوز ﻛﻨﺪ، ﺳـﺮﺑﺎز زﻧـﺪ. اﮔـﺮ اﻳـﻦ ﺻـﻔﺖ از ﻗﻠـﻢ ﺑﻴﻔﺘـﺪ‬
    ‫وﺳﻴﻠﻪ ﮔﻤﺎن ﻣﻲ ﻛﻨﺪﻛﻪ ‪ MIDlet suite‬ﺑـﺮاي ﺣﺎﻓﻈـﻪ داده ﺧـﻮد ﺑـﻪ ﻫـﻴﭻ ﻓـﻀﺎﻳﻲ ﻧﻴـﺎز ﻧـﺪارد. در ﻋﻤـﻞ ﺑﻴـﺸﺘﺮ‬
    ‫وﺳﻴﻠﻪ ﻫﺎ ﺑﻪ ﻫﺮ ﺑﺮﻧﺎﻣﻪ اﺟﺎزه ﻣﻲ دﻫﻨﺪ ﺗﺎ از ﺣﺪ ﺣﺎﻓﻈﻪ ﻣﻮرد ﻧﻴﺎز ﻣﺸﺨﺺ ﺷﺪه ﺗﺠـﺎوز ﻛﻨﻨـﺪ، اﻣـﺎ واﺑـﺴﺘﮕﻲ ﺑـﻪ اﻳـﻦ‬
                                                                                         ‫رﻓﺘﺎر اﻳﺠﺎد ﻧﻤﻲ ﻛﻨﻨﺪ.‬
    ‫ﺗﻮﺟﻪ: ﺑﺮﺧﻲ ﭘﻴﺎده ﺳﺎزي ﻫﺎي ‪ MIDP‬ﻧﻴﺎز دارﻧﺪ ﻛﻪ ﺻﻔﺎت ﺑﻴﺸﺘﺮي در ارﺗﺒﺎط ﺑﺎ ﻧﻴﺎزﻣﻨﺪﻳﻬﺎي ﻣﺤﻞ ذﺧﻴـﺮه‬
                                                                                             ‫ﺳﺎزي اﻧﺠﺎم دﻫﻨﺪ.‬




       ‫1‬
           ‫‪Time-Stamp‬‬

                                                     ‫04‬
  ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬                   ‫‪www.txt.ir‬‬                   ‫‪www.txt.ir‬‬                   ‫‪www.txt.ir‬‬



                                                                                                      ‫ﭘﻜﻴﺞ ‪rms‬‬
    ‫‪ MIDP‬ﻳﻚ ﻣﺠﻤﻮﻋﻪ از ﻛﻼس ﻫﺎ و راﺑﻂ ﻫﺎ را در ﭘﻜﻴﺞ ‪ javax.microedition.rms‬ﻓﺮاﻫﻢ ﻣﻲ ﻛﻨﺪ‬
                                             ‫ﻛﻪ اﻳﻦ ﻣﺠﻤﻮﻋﻪ از ﻛﻼس ﻫﺎ و راﺑﻂ ﻫﺎ ﭘﻜﻴﺞ ‪ rms‬را ﺗﺸﻜﻴﻞ ﻣﻲ دﻫﻨﺪ.‬


                                                                                         ‫ﻛﻼس رﻛﻮرد اﺳﺘﻮر‬
    ‫اﻳﻦ ﻛﻼس ﺑﺮاي ﺑﻪ وﺟﻮد آوردن رﻛﻮرد اﺳﺘﻮر، ﺣﺬف رﻛﻮرد اﺳﺘﻮر، اﺿﺎﻓﻪ ﻛﺮدن رﻛﻮرد، ﺣﺬف رﻛـﻮرد،‬
                                                 ‫ﺧﻮاﻧﺪن رﻛﻮرد و ﺗﻐﻴﻴﺮ رﻛﻮرد از رﻛﻮرد اﺳﺘﻮر ﻫﺎ اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد.‬


                                                          ‫2-4- اﻳﺠﺎد ﻳﺎ ﺑﺎز ﻛﺮدن ﻳﻚ رﻛﻮرد اﺳﺘﻮر‬
    ‫ﺑﻪ ﻣﻨﻈﻮر اﻳﺠﺎد ﻳﺎ ﺑﺎز ﻛﺮدن ﻳﻚ رﻛﻮرد اﺳﺘﻮر از ﻣﺘﺪ ‪ openRecordStore‬ﻛﻼس رﻛﻮرد اﺳﺘﻮر اﺳـﺘﻔﺎده‬
    ‫ﻣﻲ ﺷﻮد. اﻳﻦ ﻣﺘﺪ دو ﭘﺎراﻣﺘﺮ ﻣﻲ ﮔﻴﺮد، ﭘﺎراﻣﺘﺮ اول ﻧﺎم رﻛﻮرد اﺳﺘﻮري اﺳﺖ ﻛﻪ ﻣﻲ ﺧﻮاﻫﻴﻢ آن را ﺑﺎز ﻛﻨـﻴﻢ ﻳـﺎ در‬
    ‫ﺻﻮرت ﻣﻮﺟﻮد ﻧﺒﻮدن آن را اﻳﺠﺎد ﻛﻨﻴﻢ. ﭘﺎراﻣﺘﺮ دوم ﻳﻚ ﭘﺎراﻣﺘﺮ از ﻧﻮع ﺑﻮﻟﻴﻦ اﺳﺖ ﻛﻪ اﮔﺮ ﻣﻘﺪارآن ‪ true‬ﺑﺎﺷـﺪ‬
                                                        ‫در ﺻﻮرت ﻣﻮﺟﻮد ﻧﺒﻮدن رﻛﻮرد اﺳﺘﻮر آن را اﻳﺠﺎد ﻣﻲ ﻛﻨﺪ.‬


    ‫;)‪RecordStore rs = RecordStore.openRecordStore("test_rms",true‬‬


                                                                             ‫2-5- اﺿﺎﻓﻪ ﻛﺮدن رﻛﻮردﻫﺎ‬
    ‫ﺑﻪ ﻣﻨﻈﻮر اﺿﺎﻓﻪ ﻛﺮدن رﻛﻮردﻫﺎ ﺑﻪ رﻛﻮرد اﺳﺘﻮر، از ﻣﺘﺪ ‪ addRecord‬اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد. اﻳﻦ ﻣﺘﺪ ﺳﻪ ﭘﺎراﻣﺘﺮ‬
    ‫ﻣﻲ ﮔﻴﺮد، ﭘﺎراﻣﺘﺮ اول آراﻳﻪ اي از ﺑﺎﻳﺘﻬﺎﺳﺖ ﻛﻪ ﻣﻲ ﺧﻮاﻫﻴﺪ آن را در رﻛﻮرد اﺳﺘﻮر درج ﻛﻨﻴﺪ. ﭘﺎراﻣﺘﺮ دوم آﻓﺴﺖ‬
    ‫ﺷﺮوع ﺛﺒﺖ در آراﻳﻪ )ﺷﻤﺎره اوﻟﻴﻦ ﺑﺎﻳﺖ ﻛﻪ ﺛﺒﺖ ﺑﺎﻳﺪ از آﻧﺠﺎ ﺷﺮوع ﺷﻮد( را ﻣﺸﺨﺺ ﻣﻲ ﻛﻨﺪ، ﭘﺎراﻣﺘﺮ ﺳﻮم ﺗﻌـﺪاد‬
    ‫ﺑﺎﻳﺘﻬﺎﻳﻲ ﻛﻪ ﺑﺎﻳﺪ ﭘﺲ از ﻧﻘﻄﻪ ﺷﺮوع ﺑﻪ رﻛﻮرد اﺳﺘﻮر ﻣﻨﺘﻘﻞ ﺷﻮﻧﺪ را ﻣﺸﺨﺺ ﻣﻲ ﻛﻨﺪ. اﮔﺮ ﻋﻤﻞ ﺛﺒﺖ ﻣﻮﻓﻘﻴﺖ آﻣﻴﺰ‬
    ‫ﺑﺎﺷـــﺪ ﻣﻘـــﺪار ﺷﻨﺎﺳـــﻪ رﻛـــﻮرد ﺑﺮﮔﺮداﻧـــﺪه ﻣـــﻲ ﺷـــﻮد و در ﻏﻴـــﺮ اﻳـــﻦ ﺻـــﻮرت ﻳـــﻚ اﺳـــﺘﺜﻨﺎء ﻣﺎﻧﻨـــﺪ‬
                                                              ‫‪ RecordStoreFullException‬روي ﺧﻮاﻫﺪ داد.‬


            ‫;"‪String recordString = "Hello, RMS WORLD‬‬
            ‫;)(‪byte []recordBytes = recordString.getBytes‬‬
            ‫;)‪intrecId= rs.addRecord(recordBytes,0,recordBytes.length‬‬




                                                        ‫14‬
  ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬
‫‪www.txt.ir‬‬             ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬



                                                                             ‫2-6- ﺧﻮاﻧﺪن رﻛﻮردﻫﺎ‬
    ‫ﺑﺮاي ﺧﻮاﻧﺪن ﻳﻚ رﻛﻮرد ﺑﺎﻳﺪ ﺷﻨﺎﺳﻪ رﻛﻮرد،آن رﻛﻮرد را ﺑﺪاﻧﻴﻢ. ﺳـﭙﺲ ﺑـﺎ اﺳـﺘﻔﺎده از ﻣﺘـﺪ ‪getRecord‬‬
    ‫ﻣﻲ ﺗﻮاﻧﻴﻢ ﻣﺤﺘﻮﻳﺎت آن رﻛﻮرد را ﺑﺨﻮاﻧﻴﻢ. اﻳﻦ ﻣﺘﺪ ﻳﻚ ﭘﺎراﻣﺘﺮ ﺑﻪ ﻋﻨـﻮان ورودي ﻣـﻲ ﮔﻴـﺮد ﻛـﻪ ﺑﺮاﺑـﺮ ﺑـﺎ ﺷﻨﺎﺳـﻪ‬
    ‫رﻛـﻮرد اﺳـﺖ. رﻛـﻮردي ﻛـﻪ ﻣـﻲ ﺧـﻮاﻫﻴﻢ ﻣﺤﺘﻮﻳـﺎت آن را ﺑﺨـﻮاﻧﻴﻢ، ﺧﺮوﺟـﻲ آن آراﻳـﻪ اي از ﺑﺎﻳﺘﻬﺎﺳـﺖ ﻛـﻪ‬
     ‫ـ ـ‬                 ‫ـ‬         ‫ـ‬           ‫ـ‬           ‫ـ‬           ‫ـ ـ ـ‬          ‫ـ‬     ‫ـ‬      ‫ـ‬
                                                                           ‫ﻣﺤﺘﻮﻳﺎت رﻛﻮرد ﺧﻮاﻧﺪه ﺷﺪه اﺳﺖ.‬


              ‫;)‪byte [] readRecord = rs.getRecord(recId‬‬




                                                                       ‫2-7- ﺑﻪ روز رﺳﺎﻧﻲ رﻛﻮردﻫﺎ‬
    ‫ﺑﻪ ﻣﻨﻈﻮر ﺑﻪ روز رﺳﺎﻧﻲ رﻛﻮردﻫﺎ از ﻣﺘﺪ ‪ setRecord‬اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد. اﻳـﻦ ﻣﺘـﺪ ﭼﻬـﺎر ﭘـﺎراﻣﺘﺮ ﻣـﻲ ﮔﻴـﺮد.‬
    ‫ﭘﺎراﻣﺘﺮ اول، ﺷﻨﺎﺳﻪ رﻛﻮردي اﺳﺖ ﻛﻪ ﻣﻲ ﺧﻮاﻫﻴﻢ ﻣﺤﺘﻮﻳﺎت آن را ﺗﻐﻴﻴﺮ دﻫﻴﻢ و ﺑﻘﻴـﻪ ﭘﺎراﻣﺘﺮﻫـﺎي آن ﻫﻤﺎﻧﻨـﺪ ﻣﺘـﺪ‬
                                                                                         ‫‪ addRecord‬اﺳﺖ.‬

               ‫;"‪recordString = "new data‬‬
               ‫;)(‪recordBytes = recordString.getBytes‬‬
               ‫;)‪rs.setRecord(recId,recordBytes,0,recordBytes.length‬‬


                                                                             ‫2-8- ﺣﺬف ﻳﻚ رﻛﻮرد‬
    ‫ﺑﺎ داﺷﺘﻦ ﺷﻨﺎﺳﻪ ﻳﻚ رﻛﻮرد و ﺑﺎ اﺳﺘﻔﺎده از ﻣﺘﺪ ‪ deleteRecord‬ﻣﻲ ﺗﻮان آن را ﺣﺬف ﻛﺮد. اﻳﻦ ﻣﺘﺪ ﻳـﻚ‬
              ‫ﭘﺎراﻣﺘﺮ ﺑﻪ ﻋﻨﻮان ورودي ﻣﻲ ﮔﻴﺮد ﻛﻪ ﺑﺮاﺑﺮ ﺑﺎ ﺷﻨﺎﺳﻪ رﻛﻮردي اﺳﺖ ﻛﻪ ﻣﻲ ﺧﻮاﻫﻴﻢ آن را ﺣﺬف ﻛﻨﻴﻢ.‬

              ‫;)‪rs.deleteRecord(recId‬‬


                                                                       ‫2-9- ﺑﺴﺘﻦ ﻳﻚ رﻛﻮرد اﺳﺘﻮر‬
    ‫ﺑﻌﺪ از اﻧﺠﺎم ﻋﻤﻠﻴﺎت ﻣﻮرد ﻧﻈﺮ ﻣﺎﻧﻨﺪ ﺣﺬف رﻛﻮرد، ﺧﻮاﻧﺪن رﻛـﻮرد و ﻏﻴـﺮه ﻣـﻲ ﺗـﻮان رﻛـﻮرد اﺳـﺘﻮر را ﺑـﺎ‬
                                                                  ‫اﺳﺘﻔﺎده از ﻣﺘﺪ ‪ closeRecordStore‬ﺑﺴﺖ.‬


             ‫;)(‪rs.closeRecordStore‬‬




                                                     ‫24‬
  ‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬
www.txt.ir     www.txt.ir         www.txt.ir                     www.txt.ir         www.txt.ir



                            .‫ﺷﻜﻞ زﻳﺮ ﺣﺎﻟﺖ ﻫﺎي ﻣﺨﺘﻠﻒ ﻳﻚ رﻛﻮرد اﺳﺘﻮر را ﻧﺸﺎن ﻣﻲ دﻫﺪ‬




                               ‫ﺷﻜﻞ 2-3- ﺣﺎﻟﺘﻬﺎي ﻣﺨﺘﻠﻒ ﻳﻚ رﻛﻮرد اﺳﺘﻮر‬




                                     43
  www.txt.ir    www.txt.ir         www.txt.ir                  www.txt.ir     www.txt.ir
‫‪www.txt.ir‬‬              ‫‪www.txt.ir‬‬                   ‫‪www.txt.ir‬‬                  ‫‪www.txt.ir‬‬                      ‫‪www.txt.ir‬‬



                                                                               ‫2-01- اﺳﺘﺜﻨﺎﺀﻫﺎي ‪RMS‬‬
                  ‫ﻳﻚ ﺳﺮي از اﺳﺘﺜﻨﺎءﻫﺎ ﻛﻪ در ﻫﻨﮕﺎم ﻛﺎر ﺑﺎ رﻛﻮرد اﺳﺘﻮرﻫﺎ ﻣﻤﻜﻦ اﺳﺖ روي دﻫﻨﺪ ﻋﺒﺎرﺗﻨﺪ از:‬
    ‫1- ‪ :InvalidRecordIDException‬اﻳﻦ اﺳﺘﺜﻨﺎء زﻣﺎﻧﻲ روي ﻣﻲ دﻫﺪ ﻛﻪ ﺷﻨﺎﺳـﻪ رﻛـﻮرد اﺳـﺘﻔﺎده ﺷـﺪه‬
                                                                                                       ‫ﻣﻌﺘﺒﺮ ﻧﺒﺎﺷﺪ.‬
    ‫2- ‪ :RecordStoreFullException‬زﻣﺎﻧﻲ ﻛﻪ ﻋﻤﻠﻴﺎت ﺑﻪ دﻟﻴﻞ ﻛﺎﻓﻲ ﻧﺒﻮدن ﻓﻀﺎي ﻣﻮﺟـﻮد در رﻛـﻮرد‬
                                                                          ‫اﺳﺘﻮر ﻧﻤﻲ ﺗﻮاﻧﺪﻛﺎﻣﻞ ﺷﻮد، رخ ﻣﻲ دﻫﺪ.‬
    ‫3- ‪ :RecordStoreNotFoundException‬زﻣﺎﻧﻲ روي ﻣﻲ دﻫﺪ ﻛﻪ ﺑﺮﻧﺎﻣﻪ ﺳﻌﻲ در ﺑﺎز ﻛﺮدن رﻛـﻮرد‬
                                                                                 ‫اﺳﺘﻮري ﻛﻨﺪﻛﻪ اﻳﺠﺎد ﻧﺸﺪه اﺳﺖ.‬
    ‫4-‪ :RecordStoreNotOpenException‬زﻣﺎﻧﻲ روي ﻣﻲ دﻫﺪ ﻛﻪ ﺳﻌﻲ در ﺑﺴﺘﻦ ﻳﻚ رﻛـﻮرد اﺳـﺘﻮر‬
                                                                               ‫را دارﻳﻢ، در ﺣﺎﻟﻲ ﻛﻪ آن ﺑﺎز ﻧﻴﺴﺖ.‬


                                                                          ‫راﺑﻂ ‪RecordComparator‬‬
    ‫از اﻳﻦ راﺑﻂ ﻣﻲ ﺗﻮان ﺑﺮاي ﻣﻘﺎﻳﺴﻪ دو رﻛﻮرد از ﻧﻈﺮ اﻳﻦ ﻛﻪ ﺑﺎ ﻫﻢ ﺑﺮاﺑﺮ ﻫﺴﺘﻨﺪ و ﻳﺎ ﭼﻪ ارﺗﺒـﺎﻃﻲ ﺑـﺎ ﻫـﻢ دارﻧـﺪ‬
    ‫)رﻛﻮرد اول ﺑﺰرﮔﺘﺮ از رﻛﻮرد دوم اﺳﺖ ﻳﺎ ﺑﺮ ﻋﻜﺲ( اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد. ﺑﻪ اﻳﻦ ﺗﺮﺗﻴﺐ ﻣﻲ ﺗـﻮان ﺑـﻪ ﻧﻈـﻢ و ﺗﺮﺗﻴـﺐ‬
                                                                                                ‫رﻛﻮردﻫﺎ ﭘﺮداﺧﺖ.‬


                                                                                     ‫راﺑﻂ ‪RecordFilter‬‬
    ‫ﺑﺎ اﺳﺘﻔﺎده از اﻳﻦ راﺑﻂ ﻣﻲ ﺗﻮان ﺑﺎ ﺗﻌﻴﻴﻦ ﻳﻚ ﻓﻴﻠﺘﺮ، ﺑﺮاي ﺗﻌﻴﻴﻦ اﻳﻦ ﻛﻪ آﻳﺎ رﻛﻮردﻫﺎ ﺑﺎ ﻓﻴﻠﺘﺮ ﮔﺬاﺷﺘﻪ ﺷﺪه ﺑﺮاﺑـﺮ‬
                           ‫ﻫﺴﺘﻨﺪ ﻳﺎ ﺧﻴﺮ اﺳﺘﻔﺎده ﻛﺮد. )ﻓﻴﻠﺘﺮ ﮔﺬاﺷﺘﻪ ﺷﺪه ﺑﺮ اﺳﺎس ﻛﺎرﺑﺮد ﻣﻮرد ﻧﻈﺮ ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد(.‬


                                                                                 ‫راﺑﻂ ‪RecordListener‬‬
    ‫ﻳﻚ راﺑﻂ ﺷﻨﻮﻧﺪه ﺑﺮاي روﻳﺪادﻫﺎي اﺿﺎﻓﻪ ﻛﺮدن رﻛﻮرد، ﺣﺬف رﻛﻮرد، ﺗﻐﻴﻴﺮ رﻛﻮرد از رﻛﻮرد اﺳﺘﻮر اﺳﺖ.‬


                                                         ‫2-11- ﻣﺮﺗﺐ ﻛﺮدن و ﺟﺴﺘﺠﻮي رﻛﻮردﻫﺎ‬
    ‫ﺑﺮاي ﻣﺮﺗﺐ ﻛﺮدن و ﺟﺴﺘﺠﻮي رﻛﻮردﻫﺎ ﻣﻲ ﺗﻮان از راﺑﻂ ‪ RecordEnumration‬اﺳﺘﻔﺎده ﻛﺮد. اﻳﻦ راﺑﻂ‬
    ‫ﺑﻴﻦ رﻛﻮردﻫﺎ ﺣﺮﻛﺖ ﻣﻲ ﻛﻨﺪ و ﻣﻲ ﺗﻮان ﺑﻪ اﻳﻦ ﻃﺮﻳﻖ ﻣﺤﺘﻮﻳﺎت آن رﻛﻮرد ﻳﺎ ﺷﻨﺎﺳﻪ آن را ﺑـﻪ دﺳـﺖ آورد و ﻳـﺎ‬
    ‫ﺑﺎ اﺳﺘﻔﺎده از راﺑـﻂ ﻫـﺎي ‪ RecordFilter‬و ‪ RecordComparator‬ﺑـﻪ ﻣﺮﺗـﺐ ﻛـﺮدن وﺟـﺴﺘﺠﻮي رﻛﻮردﻫـﺎ‬
                                                            ‫ﭘﺮداﺧﺖ. اﻳﻦ راﺑﻂ ﺳﻪ ﭘﺎراﻣﺘﺮ ﺑﻪ ﻋﻨﻮان ورودي ﻣﻲ ﮔﻴﺮد.‬


                                                       ‫44‬
  ‫‪www.txt.ir‬‬               ‫‪www.txt.ir‬‬                 ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬                ‫‪www.txt.ir‬‬
www.txt.ir              www.txt.ir                   www.txt.ir                   www.txt.ir                   www.txt.ir



    ‫ ﻧﺒﺎﺷﺪ ﺑﺮاي ﺗﻌﻴﻴﻦ اﻳﻦ ﻛﻪ ﻛـﺪام زﻳـﺮ ﻣﺠﻤﻮﻋـﻪ از ﻣﺠﻤﻮﻋـﻪ‬null ‫: اﮔﺮ اﻳﻦ ﭘﺎراﻣﺘﺮ ﺑﺮاﺑﺮ‬RecordFilter-1
                                                           .‫رﻛﻮردﻫﺎي رﻛﻮرد اﺳﺘﻮر اﺳﺘﻔﺎده ﺷﻮﻧﺪ، اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد‬
    ‫ ﻧﺒﺎﺷﺪ ﺑﻪ ﻣﻨﻈﻮر ﺗﻌﻴﻴﻦ ﺗﺮﺗﻴﺐ رﻛﻮردﻫـﺎ در رﻛـﻮرد‬null ‫: اﮔﺮ اﻳﻦ ﭘﺎراﻣﺘﺮ ﺑﺮاﺑﺮ‬RecordComparator-2
                                                                                             .‫اﺳﺘﻮر اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد‬
    ‫ ﺑﺎﺷﺪ ﺷﻤﺎرﺷﮕﺮ ﺷﻤﺎره ﻓﻌﻠﻲ را ﺑﻪ ﻫﻤﺮاه ﻫﺮ ﮔﻮﻧـﻪ ﺗﻐﻴﻴـﺮات‬true ‫3- ﭘﺎراﻣﺘﺮ ﺳﻮم از ﻧﻮع ﺑﻮﻟﻴﻦ اﺳﺖ ﻛﻪ اﮔﺮ‬
                                                                         .‫در رﻛﻮردﻫﺎي رﻛﻮرد اﺳﺘﻮر ﻧﮕﻪ ﻣﻲ دارد‬


                                           RecordEnumration ‫2-21- ﺧﻮاﻧﺪن رﻛﻮردﻫﺎ از‬
    ‫ اﻳﻦ راﺑﻂ اﺳﺘﻔﺎده ﻛﺮد اﻳـﻦ ﻣﺘـﺪ‬nextRecord ‫ﺑﺮاي ﺧﻮاﻧﺪن رﻛﻮرد ﺑﻌﺪي از رﻛﻮرد اﺳﺘﻮر ﻣﻲ ﺗﻮان از ﻣﺘﺪ‬
    ‫ﻳــﻚ ﻛﭙــﻲ از ﻣﺤﺘﻮﻳــﺎت رﻛــﻮرد را ﺑــﺮ ﻣــﻲ ﮔﺮداﻧــﺪ. ﺑــﺮاي ﺧﻮاﻧــﺪن رﻛــﻮرد ﻗﺒﻠــﻲ ﻧﻴــﺰ ﻣــﻲ ﺗــﻮان از ﻣﺘــﺪ‬
                                                                                .‫ اﺳﺘﻔﺎده ﻛﺮد‬previousRecord


        Recordnumeration re = rs.enumerateRecords(null,null,true);
        byte [] readRecord = re.nextRecord ();


             .‫ﻛﺪ زﻳﺮ ﺑﻪ ﻣﻨﻈﻮر ﻣﺮﺗﺐ ﻛﺮدن رﻛﻮردﻫﺎ اﺳﺘﻔﺎده ﺷﺪه اﺳﺖ و ﻛﺎرﺑﺮد ﻣﻄﺎﻟﺐ ﮔﻔﺘﻪ ﺷﺪه را ﻧﺸﺎن ﻣﻲ دﻫﺪ‬


    import      javax.microedition.rms.*;
    import      javax.microedition.midlet.*;
    import      javax.microedition.lcdui.*;
    import      java.io.*;

    public class SortExample extends MIDlet implements CommandListener
    {
         private Display display;
         private Alert alert;
         private Form form;
         private Command exit;
         private Command start;
         private RecordStore recordstore = null;
         private Recordnumeration recordnumeration = null;
         private Comparator comparator = null;
         public SortExample ()
         {
           display = Display.getDisplay(this);
           exit = new Command("Exit", Command.SCREEN, 1);
           start = new Command("Start", Command.SCREEN, 1);
           form = new Form("Mixed Recordnumeration", null);
           form.addCommand(exit);

                                                        45
  www.txt.ir               www.txt.ir                 www.txt.ir                 www.txt.ir                www.txt.ir
www.txt.ir       www.txt.ir       www.txt.ir        www.txt.ir       www.txt.ir



          form.addCommand(start);
          form.setCommandListener(this);
      }
      public void startApp()
      {
          display.setCurrent(form);
      }
      public void pauseApp()
        {
        }
      public void destroyApp( boolean unconditional )
        {
        }
     public void commandAction(Command command, Displayable displayable)
      {
          if (command == exit)
          {
            destroyApp(true);
            notifyDestroyed();
          }
          else if (command == start)
          {
            try
            {
              recordstore = RecordStore.openRecordStore(
                            "myRecordStore", true );
            }
            catch (Exception error)
            {
              alert = new Alert("Error Creating",
                   error.toString(), null, AlertType.WARNING);
              alert.setTimeout(Alert.FOREVER);
              display.setCurrent(alert);
            }
            try
            {
              String outputData[] = {"Mary", "Bob", "Adam"};
              for (int x = 0; x < 3; x++)
              {
                byte[] byteOutputData = outputData[x].getBytes();
                recordstore.addRecord(byteOutputData, 0,
                         byteOutputData.length);
              }
            }
            catch ( Exception error)
            {
              alert = new Alert("Error Writing",
                      error.toString(), null, AlertType.WARNING);
              alert.setTimeout(Alert.FOREVER);
              display.setCurrent(alert);

                                    46
  www.txt.ir       www.txt.ir     www.txt.ir       www.txt.ir      www.txt.ir
www.txt.ir        www.txt.ir       www.txt.ir        www.txt.ir        www.txt.ir



         }
         try
         {
           StringBuffer buffer = new StringBuffer();
           Comparator comparator = new Comparator();
           recordnumeration = recordstore.enumerateRecords(
                             null, comparator, false);
           while (recordnumeration.hasNextElement())
           {
               buffer.append(new String(recordnumeration.nextRecord ()));
               buffer.append("\n");
             }
             alert = new Alert("Reading", buffer.toString() ,
                       null, AlertType.WARNING);
             alert.setTimeout(Alert.FOREVER);
               display.setCurrent(alert);
         }
         catch (Exception error)
         {
             alert = new Alert("Error Reading",
                      error.toString(), null, AlertType.WARNING);
             alert.setTimeout(Alert.FOREVER);
             display.setCurrent(alert);
         }
         try
         {
           recordstore.closeRecordStore();
         }
         catch (Exception error)
         {
             alert = new Alert("Error Closing",
                      error.toString(), null, AlertType.WARNING);
             alert.setTimeout(Alert.FOREVER);
             display.setCurrent(alert);
         }
         if (RecordStore.listRecordStores() != null)
         {
           try
           {
               RecordStore.deleteRecordStore("myRecordStore");
               recordnumeration.destroy();
           }
           catch (Exception error)
           {
              alert = new Alert("Error Removing",
                    error.toString(), null, AlertType.WARNING);
              alert.setTimeout(Alert.FOREVER);
              display.setCurrent(alert);
           }
         }

                                      47
  www.txt.ir       www.txt.ir       www.txt.ir      www.txt.ir      www.txt.ir
www.txt.ir            www.txt.ir               www.txt.ir               www.txt.ir                www.txt.ir



          }
      }
    }
    class Comparator implements RecordComparator
    {
      public int compare(byte[] record1, byte[] record2)
      {
         String string1 = new String(record1),
                   string2= new String(record2);
         int comparison = string1.compareTo(string2);
         if (comparison == 0)
           return RecordComparator.EQUIVALENT;
         else if (comparison < 0)
           return RecordComparator.PRECEDES;
         else
           return RecordComparator.FOLLOWS;
      }



                                                                         ‫2-31- ﺗﻮاﺑﻊ ﻣﻔﻴﺪ دﻳﮕﺮ‬
                                  .‫: ﺗﻌﺪاد رﻛﻮردﻫﺎي ﻳﻚ رﻛﻮرد اﺳﺘﻮر را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ‬getNumRecord
                                                        .‫: ﻧﺎم ﻳﻚ رﻛﻮرد اﺳﺘﻮر را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ‬getname
                         .‫: اﻳﻦ ﻣﺘﺪ ﻳﻚ آراﻳﻪ از ﻧﺎم ﺗﻤﺎم رﻛﻮرد اﺳﺘﻮر ﻫﺎ را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ‬ListRecordStore
                                       .‫: ﺳﺎﻳﺰ ﻳﻚ رﻛﻮرد را ﺑﺮ ﺣﺴﺐ ﺑﺎﻳﺖ ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ‬getRecordSize
                 .‫: ﻣﻘﺪار ﻓﻀﺎﻳﻲ را ﻛﻪ ﻣﺠﻤﻮع رﻛﻮردﻫﺎي ﻳﻚ رﻛﻮرد اﺳﺘﻮر ﮔﺮﻓﺘﻪ اﻧﺪ را ﻧﺸﺎن ﻣﻲ دﻫﺪ‬getsize
    ‫: ﻣﻘﺪار ﻓﻀﺎي ﺧﺎﻟﻲ ﻣﻮﺟﻮد در رﻛﻮرد اﺳـﺘﻮر را ﻛـﻪ رﻛﻮردﻫـﺎ ﻣـﻲ ﺗﻮاﻧﻨـﺪ ﺑـﻪ آن اﺿـﺎﻓﻪ‬getsizeAvailable
                                                                                  .‫ﺷﻮﻧﺪ را ﻧﺸﺎن ﻣﻲ دﻫﺪ‬




                                                 48
  www.txt.ir            www.txt.ir             www.txt.ir              www.txt.ir             www.txt.ir
www.txt.ir         www.txt.ir               www.txt.ir           www.txt.ir              www.txt.ir



                                                                               ‫ﻣﻨﺎﺑﻊ و ﻣﺮاﺟﻊ‬

             1. Martin de Jode, Jonathan Allin, Darren Holland, Alan Newman and Colin
                Turfus, Programming Java 2 Micro Edition on Symbian OS ,
                Copyright @ 2004 Symbian

             2. James Keogh, J2ME: The Complete Reference

             3. Michael Juntao Yuan, Enterprise J2ME: Developing Mobile Java
                Applications

             4. http://www.symbian.com

             5. http://www.netbeans.org

             6. http://www.symbiandevnet.com

             7. http://java.sun.com/j2me

             8. http://www.forum.nokia.com

             9. http://www.uiq.com/developer

             10. http://www.eclipse.org

             11. http://www.borland.com/products/downloads/download jbuilder.html

             12. http://www.symbian.com/phones

             13. http://www.bluetooth.com

             14. http://java.sun.com/products/j2mewtoolkit/download-2 1.html

             15. http://www.sun.com

             16. http://developer.java.sun.com/developer/onlineTraining/Programming/
                 JDCBook/index.htm

             17. http://www.jackwind.net

             18. http://www.javasoft.com

             19. http://www.Developer.com

             20. http://bdn.borland.com

             21. http://www.sonyericsson.com

             22. http://www.Nokia.com

                                             49
  www.txt.ir         www.txt.ir             www.txt.ir          www.txt.ir             www.txt.ir
www.txt.ir         www.txt.ir             www.txt.ir              www.txt.ir             www.txt.ir




             23. http://developer.java.sun.com/developer/J2METechTips/2001/tt0220.html

             24. http://developer.java.sun.com/developer/J2METechTips/2001/tt0622.html

             25. http://www.coolarchive.com/icons.php

             26. http://www.symbian.com/developer/sdks_series60.asp

             27. http://www.smartphone.net

             28. http://www.plamsource.com/includes/midp/articles/databasemap

             29. http://www.microjava.com/articles/techtalk/rms

             30. http://www.java.about.com/od/mobilej2meprogramming/




                                              50
  www.txt.ir         www.txt.ir              www.txt.ir           www.txt.ir        www.txt.ir

				
DOCUMENT INFO
Shared By:
Stats:
views:6
posted:5/13/2012
language:
pages:51