‫‪http://www.alshater.

net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬

‫ﺑﺴﻢ ﺍﷲ ﺍﻟﺮﲪﻦ ﺍﻟﺮﺣﻴﻢ‬

‫ﻟﻐﺔ ﺍﻟﱪﳎﺔ ﺩﻟﻔﻲ‬

‫ﻣﻮﻗﻊ ﺍﻟ ِﻜﺘﺎﺏ ﻋﻠﻰ ﺍﻹﻧﺘﺮﻧﺖ‬

‫‪http://www.alshater.net‬‬

‫ﻳﺴﻤﺢ ﺑﺎﻟﻨﺸﺮ ﺍﻹﻟﻜﺘﺮﻭﱐ ﺃﻭ ﺍﻻﻗﺘﺒﺎﺱ ﺃﻭ ﺍﻟﻨﻘﻞ‬

‫ﻋﻠﻰ ﺃﻥ ﻳﺘﻢ ﺍﻹﺷﺎﺭﺓ ﺇﱃ ﺍﳌﺆﻟﻒ ﻭﻣﻮﻗﻊ ﺍﻟ ِﻜﺘﺎﺏ ﻋﻠﻰ ﺍﻻﻧﺘﺮﻧﺖ‬

‫ﻭﻻ ﻳﺴﻤﺢ ﺑﺄﻱ ﺷﻜﻞ ﻣﻦ ﺍﻷﺷﻜﺎﻝ ﺍﻟﻨﺸﺮ ﺍﻟﻮﺭﻗﻲ ﻟﻠﻜﺘﺎﺏ‬

‫ﺇﻋﺪﺍﺩ‬
‫ﳏﻤﺪ ﺧﺎﻟﺪ ﻧﺎﺻﺮ ﺁﻏﺎ‬
‫‪Support@alshater.net‬‬

‫‪1‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬

‫ﺇﻟﻰ ﺃﻤﻲ‪ ،‬ﺇﻟﻰ ﺃﺒﻲ ﺍﻟﺫﻴﻥ ﻟﻭﻻ ﺴﻬﺭﻫﻤﺎ ﻭﺘﻌﺒﻬﻤﺎ ﻟﻡ ﺃﻜﻥ ﻫﻨﺎ ﻷﻜﺘﺏ‬
‫ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ‪.‬‬

‫ﺇﻟﻰ ﺃﻨﺎﺱ ﻻ ﺃﻋﺭﻓﻬﻡ ﻭﻻ ﻴﻌﺭﻓﻭﻨﻨﻲ ﻭﻟﻜﻨﻬﻡ ﻗﺩﻤﻭﺍ ﻟﻲ ﺍﻟﻜﺜﻴﺭ ﻭﺨﺎﺼﺔ‬

‫ﻓﻲ ﻤﺠﺎل ﺍﻟﺒﺭﻤﺠﺔ ﻜﻨﺕ ﻗﺩ ﺍﻟﺘﻘﻴﺕ ﺒﻬﻡ ﻋﻠﻰ ﺍﻻﻨﺘﺭﻨﺕ ﻓﻲ ﺍﻟﻤﻨﺘﺩﻴﺎﺕ‬
‫ﻭﺴﺎﺤﺎﺕ ﺍﻟﺤﻭﺍﺭ ﻭﻜﺎﻥ ﻋﻁﺎﺌﻬﻡ ﻤﻥ ﺩﻭﻥ ﻁﻠﺏ ﺤﺘﻰ ﺃﻨﻬﻡ ﻟﻡ ﻴﻁﻠﺒﻭﺍ‬
‫ﺍﻟﺸﻜﺭ ﻋﻠﻰ ﺍﻟﻤﺴﺎﻋﺩﺓ‪.‬‬

‫‪2‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬

‫ﺍﻟﻔﻬﺮﺱ‬
‫ﺍﻟﺼﻔﺤﺔ‬ ‫ﺍﻟﻤﻭﻀﻭﻉ‬
‫ﺍﻟﻤﻘﺩﻤﺔ ‪5 ................................................................................‬‬
‫ﻨﺒﺫﻩ ﻋﻥ ﺩﻟﻔﻲ ‪7 ..........................................................................‬‬
‫ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻷﻭل ‪10 .........................................................................‬‬
‫ﺍﻟﻭﺤﺩﺓ ‪15 .......................................................................... unit‬‬
‫ﺍﻟﺘﻌﺭﻑ ﻋﻠﻰ ﺍﻟﻌﻨﺎﺼﺭ ‪16 .................................................................‬‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻷﺤﺩﺍﺙ ) ‪18 ..................................................... ( Events‬‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻭﺍﺠﻬﺔ ﺍﻟﺩﻟﻔﻲ ‪20 ...............................................................‬‬
‫ﺍﻟﺘﻌﺭﻑ ﻋﻠﻰ ﻋﻨﺼﺭ ﺍﻟﻤﺫﻜﺭﺓ ‪24 ................................................. Memo‬‬
‫‪27‬‬ ‫ﺇﻨﺸﺎﺀ ﻗﻭﺍﺌﻡ ﻟﻠﻨﻤﺎﺫﺝ ‪....................................................................‬‬
‫ﺃﻨﻭﺍﻉ ﺍﻟﻤﻌﻁﻴﺎﺕ ‪29 ........................................................ Data Type‬‬
‫ﺍﻹﺠﺭﺍﺀﺍﺕ ﻭﺍﻟﺘﻭﺍﺒﻊ ‪35 ...................................................................‬‬
‫ﺒﻌﺽ ﺍﻟﺘﻭﺍﺒﻊ ﺍﻟﻤﻌﺭﻓﺔ ﻓﻲ ﺩﻟﻔﻲ ‪43 .........................................................‬‬
‫ﺼﻨﺎﺩﻴﻕ ﺍﻟﺤﻭﺍﺭ ‪48 .............................................................. Dialog‬‬
‫ﺍﻟﺘﻌﺭﻑ ﻋﻠﻰ ﺍﻟﻌﻨﺼﺭ ‪52 ..................................................... MaskEdit‬‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺴﻼﺴل ﺍﻟﻨﺼﻴﺔ ‪55 ...........................................................‬‬
‫‪60‬‬ ‫ﻤﻌﺎﻟﺠﺔ ﺍﻷﺨﻁﺎﺀ ﻓﻲ ﺩﻟﻔﻲ ‪..............................................................‬‬
‫‪69‬‬ ‫ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪........................................................................‬‬
‫ﺒﻨﺎﺀ ﺘﻁﺒﻴﻘﺎﺕ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪77 ............................................................‬‬
‫ﺒﻨﺎﺀ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪86 .......................................... Database Desktop‬‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ ﺨﻼل ﺩﻟﻔﻲ ‪100 ...............................................‬‬
‫‪111‬‬ ‫ﺍﻟﺒﺤﺙ ﻓﻲ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪..............................................................‬‬
‫ﺍﻟﺤﻘﻭل ﺍﻟﺤﺴﺎﺒﻴﺔ ‪117 .......................................................................‬‬
‫ﻟﻐﺔ ﺍﻻﺴﺘﻔﺴﺎﺭﺍﺕ ﺍﻟﺒﻨﻴﻭﻴﺔ ‪118 .................................................... SQL :‬‬
‫‪123‬‬ ‫ﺭﺒﻁ ﺍﻟﺠﺩﺍﻭل ‪.........................................................................‬‬
‫‪131‬‬ ‫ﺇﻨﺸﺎﺀ ﺍﻟﺠﺩﺍﻭل ﺒﺒﺭﻨﺎﻤﺞ ‪...................................................... Access‬‬

‫‪3‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪137‬‬ ‫‪................................................................................ ADO‬‬
‫‪140‬‬ ‫ﺒﺭﻨﺎﻤﺞ ﺩﻟﻴل ﺍﻟﻬﺎﺘﻑ ‪...................................................................‬‬
‫‪146‬‬ ‫ﺍﻟﻁﺒﺎﻋﺔ ‪...............................................................................‬‬
‫ﻟﻤﺴﺎﺕ ﺒﺭﻤﺠﻴﺔ ‪147 ........................................................................‬‬
‫ﻤﺴﺠل ﺍﻟﻨﻅﺎﻡ ‪150 ................................................ Windows Registry‬‬
‫‪154‬‬ ‫ﺘﻭﺍﺒﻊ ﻭﺜﻭﺍﺒﺕ ﺍﻟﻭﻴﻨﺩﻭﺯ ‪............................................. Windows API‬‬
‫ﺇﻀﺎﻓﺔ ﻋﻨﺎﺼﺭ ﺠﺩﻴﺩﺓ ‪158 ..................................................................‬‬
‫ﺍﻟﺴﺤﺏ ﻭﺍﻹﻓﻼﺕ‪167 .......................................................................‬‬
‫‪169‬‬ ‫ﺍﻟﺭﺴﻡ ﻓﻲ ﺩﻟﻔﻲ ‪........................................................................‬‬
‫ﺒﺭﻤﺠﺔ ﺍﻷﻭﺴﺎﻁ ﺍﻟﻤﺘﻌﺩﺩﺓ ‪182 ...............................................................‬‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻤﻠﻔﺎﺕ ‪184 ....................................................................‬‬
‫ﺒﺭﻨﺎﻤﺞ ﺍﻟﻤﻔﻜﺭﺓ ‪183 ........................................................................‬‬
‫‪197‬‬ ‫ﺍﻟﺒﺭﻨﺎﻤﺞ ‪............................................. Install Shelled Express‬‬

‫‪4‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬

‫ﺍﳌﻘﺪﻣﺔ‬
‫ﺒﺴﻡ ﺍﷲ ﻭﺍﻟﺤﻤﺩ ﷲ ﻭﺍﻟﺼﻼﺓ ﻭﺍﻟﺴﻼﻡ ﻋﻠﻰ ﺭﺴﻭل ﺍﷲ ﺃﻤﺎ ﺒﻌﺩ‪:‬‬
‫ﻫﺫﻩ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﻤﺤﺎﻀﺭﺍﺕ ﻜﻨﺕ ﻗﺩ ﺍﻋﺩﺩﺘﻬﺎ ﺃﺜﻨﺎﺀ ﺘﺩﺭﻴﺴﻲ ﻟﻠﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ﺩﻟﻔﻲ ﺴﻨﺔ ‪ 2003‬ﻓﻲ ﻤﺭﻜﺯ ﺍﻟﺸﺒﻴﺒﺔ‬
‫ﻟﻠﻌﻠﻭﻡ ﻭﺍﻟﺤﺎﺴﻭﺏ‪ ،‬ﻭﻤﻥ ﺫﻟﻙ ﺍﻟﻭﻗﺕ ﻭﺃﻨﺎ ﺃﻓﻜﺭ ﺒﻨﺸﺭ ﻫﺫﻩ ﺍﻟﻤﺤﺎﻀﺭﺍﺕ ﻋﻠﻰ ﺍﻹﻨﺘﺭﻨﺕ ﻭﻟﻜﻥ ﺍﻟﻌﻤل ﺃﺨﺫ ﻜل ﻭﻗﺘﻲ ﻤﻨﺫ‬
‫ﺫﻟﻙ ﺍﻟﺤﻴﻥ ﻭﻟﻡ ﺃﺠﺩ ﺍﻟﻭﻗﺕ ﺍﻟﻜﺎﻓﻲ ﻹﺘﻤﺎﻡ ﺫﻟﻙ‪.‬‬
‫ﻭﻜﻨﺕ ﻗﺩ ﻓﻜﺭﺕ ﺤﻴﻨﻬﺎ ﺃﻨﻪ ﻴﺠﺏ ﺘﻨﻘﻴﺢ ﻫﺫﻩ ﺍﻟﻤﺤﺎﻀﺭﺍﺕ ﻟﻐﻭﻴﹰﺎ ﻭﻋﻠﻤﻴﹰﺎ ﻗﺒل ﻨﺸﺭﻫﺎ ﺍﻷﻤﺭ ﺍﻟﺫﻱ ﺠﻌﻠﻨﻲ ﺃﺠﺩ ﻤﻥ ﻨﺸﺭﻫﺎ‬
‫ﻼ ﺸﺎﻗﹰﺎ ﻭﻴﺄﺨﺫ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﻟﺠﻬﺩ ﻭﻟﺫﻟﻙ ﻗﺭﺭﺕ ﻫﺫﻩ ﺍﻟﻌﺎﻡ ‪ 2006‬ﺃﻥ ﺃﻁﺭﺤﻬﺎ ﻜﻤﺎ ﻫﻲ ﻤﻊ ﺍﻟﻘﻠﻴل ﺍﻟﻘﻠﻴل ﻤﻥ ﺍﻟﺘﻨﻘﻴﺢ‬
‫ﻋﻤ ﹰ‬
‫ﻓﻼ ﺍﻋﺘﻘﺩ ﺃﻨﻲ ﺴﺄﺠﺩ ﺍﻟﻭﻗﺕ ﺍﻟﻤﻨﺎﺴﺏ ﻟﻨﺸﺭ ﻫﺫﻩ ﺍﻟﻤﺤﺎﻀﺭﺍﺕ ﻓﻲ ﺍﻟﻤﺴﺘﻘﺒل‪.‬‬
‫ﻟﻤﺎﺫﺍ ﺩﻟﻔﻲ؟‬
‫ﻅﻬﺭ ﻜﺜﻴﺭﹰﺍ ﻤﻥ ﺍﻟﻨﺯﺍﻉ ﻓﻲ ﻤﻭﺍﻗﻊ ﺍﻹﻨﺘﺭﻨﺕ ﺤﻭل ﺃﻴﻬﻤﺎ ﺃﻓﻀل ﻓﻴﺠﻭل ﺒﻴﺴﻙ ﺃﻡ ﺩﻟﻔﻲ ﻭﻻ ﺃﺭﻴﺩ ﻫﻨﺎ ﺃﻥ ﺃﺩﺨل ﻓﻲ ﻫﺫﻩ‬
‫ﺍﻟﻤﻨﺎﻗﺸﺎﺕ ﻭﻟﻜﻨﻲ ﺍﺨﺘﺭﺕ ﺍﻟﺩﻟﻔﻲ ﻟﺴﺒﺒﻴﻥ ‪:‬‬
‫‪ – 1‬ﻴﺩﺭﺱ ﻜل ﻁﻼﺏ ﺍﻟﻬﻨﺩﺴﺔ ﺍﻟﻤﻌﻠﻭﻤﺎﺘﻴﺔ ﻓﻲ ﺴﻭﺭﻴﺔ ﻟﻐﺔ ﺍﻟﺒﺎﺴﻜﺎل ﻭﺍﻟﺘﻲ ﻫﻲ ﺍﻟﻠﻐﺔ ﺍﻷﻡ ﻟﻠﺩﻟﻔﻲ ﻭﺒﺎﻟﺘﺎﻟﻲ ﻴﻜﻭﻥ‬
‫ﺍﻻﻨﺘﻘﺎل ﺇﻟﻰ ﺩﻟﻔﻲ ﺴﻠﺱ ﻭﺴﻬل‪.‬‬
‫‪ – 2‬ﺍﻟﻤﻭﻀﺔ ‪ :‬ﻗﺩ ﻴﻔﺎﺠﺊ ﺍﻟﺒﻌﺽ ﻤﻥ ﻫﺫﺍ ﺍﻟﺴﺒﺏ ﻭﻟﻜﻥ ﻭﺒﻜل ﺼﺭﺍﺤﺔ ﺍﻗﺘﻨﻴﺕ ﺤﺎﺴﺒﹰﺎ ﺴﻨﺔ ‪ 1997‬ﻭﻜﻨﺕ ﻓﻲ ﺍﻟﺴﻨﺔ‬
‫ﺍﻟﺜﺎﻨﻴﺔ ﻓﻲ ﺍﻟﻜﻠﻴﺔ ﻭﻜﺎﻨﺕ ﻨﺴﺨﺔ ﺍﻟﺩﻟﻔﻲ ‪ 2‬ﻗﺩ ﻅﻬﺭﺕ ﻷﻭل ﻤﺭﺓ ﻭﻜﺎﻥ ﺍﻟﻜﺜﻴﺭ ﻴﺩﺭﺱ ﺍﻟﺩﻟﻔﻲ ﻓﻲ ﺍﻟﻜﻠﻴﺔ ﺒﺎﻟﺭﻏﻡ ﻤﻥ ﺃﻨﻬﺎ‬
‫ﻏﻴﺭ ﻤﻘﺭﺭﺓ ﻓﻲ ﺍﻟﻤﻨﻬﺎﺝ ﺍﻷﻤﺭ ﺍﻟﺫﻱ ﺠﻌل ﺍﻟﺩﻟﻔﻲ ﺘﻨﺘﺸﺭ ﻜﻤﺎ ﺘﻨﺘﺸﺭ ﺍﻟﻤﻭﻀﺔ ﺍﻟﺠﺩﻴﺩﺓ ﺒﻴﻥ ﺍﻟﻨﺴﺎﺀ‪ ،‬ﺒﺎﻟﻨﺴﺒﺔ ﻟﻤﻥ ﻴﺭﻭﻥ ﺃﻥ‬
‫ﺘﻌﺒﻴﺭ ﻤﻭﻀﺔ ﻟﻴﺱ ﻓﻲ ﻤﺤﻠﻪ ﺃﺫﻜﺭﻫﻡ ﺃﻥ ﺍﻟﻤﻭﻀﺔ ﻓﻲ ﻋﺎﻡ ‪ 2005‬ﻜﺎﻨﺕ ‪ C#‬ﻭﻻ ﺃﻋﺭﻑ ﺃﻴﻥ ﺴﺘﺘﺠﻪ ﺍﻟﻤﻭﻀﺔ ﻫﺫﺍ‬
‫ﺍﻟﻌﺎﻡ‪.‬‬
‫ﺭﺤﻠﺘﻲ ﻤﻊ ﺩﻟﻔﻲ‪:‬‬
‫ﺒﺩﺃﺕ ﺒﺩﺍﺭﺴﺔ ﺍﻟﺩﻟﻔﻲ ﻜﻤﺎ ﻗﻠﺕ ﻓﻲ ﻋﺎﻡ ‪ 1997‬ﻭﺒﻌﺩﻫﺎ ﺃﺼﺒﺤﺕ ﻤﺩﻤﻨﹰﺎ ﻟﻠﺩﻟﻔﻲ ﻜﻨﺕ ﺃﻟﻌﺏ ﺍﻟﺩﻟﻔﻲ ﺒﻴﻨﻤﺎ ﻜﺎﻥ ﺃﺼﺩﻗﺎﺌﻲ‬
‫ﻴﻠﻌﺒﻭﻥ ﻓﻴﻔﺎ ‪ 98‬ﺃﻭ ﺭﻭﺩ ﺭﺵ ‪.‬‬
‫ﻭﻟﻜﻥ ﻓﻲ ﻋﺎﻡ ‪ 2004‬ﺒﺩﺃﺕ ﺤﻴﺎﺘﻲ ﺘﺄﺨﺫ ﻤﺴﺎﺭﹰﺍ ﺁﺨﺭ ﻓﻌﻤﻠﻲ ﺃﺼﺒﺢ ﻴﺘﻁﻠﺏ ﺍﻟﻌﻤل ﻋﻠﻰ ﺸﺒﻜﺎﺕ ﻟﻴﻨﻜﺱ ﻭﺍﻟﺘﻲ ﺘﺄﺨﺫ‬
‫ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﻟﻭﻗﺕ ﺒﺎﻹﻀﺎﻓﺔ ﺃﻨﻨﻲ ﺘﻌﺭﻓﺕ ﻋﻠﻰ ﻟﻐﺔ ﺒﺭﻤﺠﺔ ﺠﺩﻴﺩﺓ ﻭﻫﻲ ‪ PHP‬ﻭﺍﻟﺘﻲ ﺃﺼﺒﺤﺕ ﺘﺄﺨﺫ ﺤﻴﺎﺘﻲ ﺸﻴﺌﹰﺎ ﻓﺸﻴﺌﺎﹰ‪،‬‬
‫ﺍﻷﻤﺭ ﺍﻟﺫﻱ ﺠﻌﻠﻨﻲ ﺃﺒﺘﻌﺩ ﻋﻥ ﺍﻟﺩﻟﻔﻲ ﺤﺘﻰ ﺃﻨﻲ ﺘﻭﻗﻔﺕ ﺍﻟﺴﻨﺔ ﺍﻟﻤﺎﻀﻴﺔ ﻋﻥ ﺍﻟﻌﻤل ﺒﻬﺎ ﺃﻭ ﺘﺩﺭﻴﺴﻬﺎ ﺘﻤﺎﻤﹰﺎ‪.‬‬
‫ﻟﻤﻥ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ؟‬
‫ﺒﺎﻟﺭﻏﻡ ﻤﻥ ﺃﻨﻨﻲ ﺤﺎﻭﻟﺕ ﺘﺒﺴﻴﻁ ﺍﻟﻜﺘﺎﺏ ﻤﺎ ﺃﻤﻜﻥ ﻭﻟﻜﻨﻨﻲ ﺘﻭﺠﻬﺕ ﻓﻲ ﺇﻋﺩﺍﺩ ﻫﺫﻩ ﺍﻟﻤﺤﺎﻀﺭﺍﺕ ﺇﻟﻰ ﻁﻼﺏ ﻜﻠﻴﺔ ﺍﻟﻬﻨﺩﺴﺔ‬
‫ﺍﻟﻤﻌﻠﻭﻤﺎﺘﻴﺔ ﻭ ﻜﻠﻴﺔ ﺍﻟﺤﺎﺴﺒﺎﺕ ﺍﻷﻤﺭ ﺍﻟﺫﻱ ﺠﻌﻠﻨﻲ ﺃﻓﺘﺭﺽ ﺃﻥ ﻗﺎﺭﺉ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻟﺩﻴﻪ ﺇﻟﻤﺎﻡ ﻭﻟﻭ ﺒﺴﻴﻁ ﺒﻠﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ‪.‬‬

‫‪5‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬

‫ﻟﻤﺎﺫﺍ ﺃﻨﺸﺭ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ‪:‬‬

‫) ﺍﻗﺘﺒﺱ ﻫﺫﻩ ﺍﻟﻜﻼﻡ ﻤﻥ ﻤﻘﺩﻤﺔ ﻜﺘﺎﺏ ﺍﺤﺘﺭﺍﻑ ‪ Visual Basic.Net‬ﻟﻤﺅﻟﻔﺔ ﻤﺤﻤﺩ ﺤﻤﺩﻱ ﻏﺎﻨﻡ(‪:‬‬
‫ل‬
‫ﻥ ﺴﻴﺘﺴﺎﺀﻟﻭﻥ‪ :‬ﻤﺎ ﻫﻭ ﺍﻟﺩﺍﻓﻊ ﺍﻟﺫﻱ ﺤﺩﺍﻙ ﻟﺒﺫل ﻫﺫﺍ ﺍﻟﻤﺠﻬﻭﺩ؟‪ ..‬ﻭﺇﻨﹼﻲ ﻷﺠﺩﻫﺎ ﻓﺭﺼ ﹰﺔ ﻤﻨﺎﺴـﺒ ﹰﺔ ﻷﻨﻘـ َ‬
‫ﻥ ﺍﻟﻜﺜﻴﺭﻴ ‪‬‬
‫ﻑﺃ‪‬‬
‫ﺃﻋﺭ ﹸ‬
‫ﻥ ﺠﺯﺀ‪‬ﺍ ﻤـﻥ‬
‫ﻥ ﺍﻹﻨﺴﺎ ِ‬ ‫ل ﺍﻟﻭ ‪‬ﺩ ﻭﺍﻻﺤﺘﺭﺍﻡ‪ ..‬ﻫﺫﻩ ﺍﻟﻔﻜﺭ ﹸﺓ ﺘﺩﻭ ‪‬ﺭ ﺤﻭ َ‬
‫ل ﻜﻭ ِ‬ ‫ﻥ ﻟﻬﻡ ﻜ ﱠ‬
‫ﺱ ﺃﻜ ‪‬‬
‫ﻟﻜﻡ ﻓﻜﺭ ﹰﺓ ﺘﻌﻠﻤﺘﻬﺎ ﻤﻥ ﺍﺤﺘﻜﺎﻜﻲ ﺒﺄﻨﺎ ٍ‬
‫ﻥ ﻤﻌﺎ‪.‬‬
‫ﻥ ﻤﻌﺎ ﻭﻴﺸﻘﻴﺎ ِ‬
‫ﻥ ﻤﺼﻴﺭ‪‬ﻩ ﻤﺭﺘﺒﻁ ﺒﻤﺼﻴﺭ ﻫﺫﺍ ﺍﻟﻤﺠﺘﻤﻊ‪ ،‬ﻴﺴﻌﺩﺍ ِ‬
‫ﻤﺠﺘﻤﻌِﻪ‪ ،‬ﻟﻬﺫﺍ ﻓﻤﻬﻤﺎ ﻜﺎﻨﺕ ﺃﻗﺩﺍﺭ ﻫﺫﺍ ﺍﻹﻨﺴﺎﻥ‪ ،‬ﻓﺈ ‪‬‬
‫ﻙ ﻓﻲ ﻤﺠﺘﻤ ٍﻊ ﻤ‪‬ﻌﺩﻡ؟‬
‫ﻓﻤﺎ ﻓﺎﺌﺩ ﹸﺓ ﺃﻥ ﺘﻤِﻠ ‪‬‬
‫ﻭﻤﺎ ﺠﺩﻭﻯ ﺃﻥ ﺘﺸﻌ ‪‬ﺭ ﻓﻲ ﻤﺠﺘﻤ ٍﻊ ﻤﺘﺤﺠ‪‬ﺭ؟‬
‫ﻑ ﻓﻲ ﻤﺠﺘﻤ ٍﻊ ﻴﺠﻬل؟‬
‫ﻭﻤﺎ ﻗﻴﻤ ﹸﺔ ﺃﻥ ﺘﻌﺭ ﹶ‬
‫ﻑ ﺃﻥ ﺘﻔﻬ ‪‬ﻡ ﻓﻲ ﻤﺠﺘﻤ ٍﻊ ﻤﺘﺒﻠﹼﺩ؟‬
‫ﻭﻤﺎ ﻫﺩ ﹸ‬
‫ﻉ ﻓﻲ ﻤﺠﺘﻤ ٍﻊ ﻤﺘﺩﻨﹼﻲ ﺍﻟﺫﺍﺌﻘ ِﺔ ﻭﺍﻟﺜﻘﺎﻓﺔ؟‬
‫ﻭﻤﺎ ﻤﻐﺯﻯ ﺃﻥ ﺘﹸﺒﺩ ‪‬‬
‫ﻥ‬
‫ﺱ ﺁﺨﺭﻭﻥ‪ ،‬ﺒﺤﻴﺙ ﺘﻌ ‪‬ﻡ ﺍﻟﻔﺎﺌﺩﺓ ﻋﻠﻰ ﺍﻟﺠﻤﻴﻊ‪ ،‬ﻓﻲ ﺇﻁﺎ ٍﺭ ﻤﻥ ﺍﻟﺘﻌـﺎﻭ ِ‬
‫ﻙ ﻤﻌﻙ ﻓﻴﻪ ﺃﻨﺎ ‪‬‬
‫ل ﻫﺫﺍ ﻗﻴﻤ ﹲﺔ ﺇﺫﺍ ﻟﻡ ﻴﺘﺸﺎﺭ ‪‬‬
‫ﻥ ﻟﻜ ﱢ‬
‫ﻟﻥ ﻴﻜﻭ ‪‬‬
‫ﻭﺍﻟﻭ ‪‬ﺩ‪.‬‬
‫ﺵ ﺒﺩﻭﻨِﻬﺎ‪ ،‬ﺘﻤﺎﻤﺎ ﻜﺎﻟﻁﻌـﺎ ِﻡ‬
‫ﻥ ﺍﻟﺤﻴﻭ ‪‬ﻴ ِﺔ ﺍﻟﺘﻲ ﻻ ﻴﺴﺘﻁﻴ ‪‬ﻊ ﺍﻟﻌﻴ ﹶ‬
‫ﺕ ﺍﻹﻨﺴﺎ ِ‬
‫ﺱ ﺒﺎﻻﻨﺘﻤﺎ ِﺀ ﻫﻲ ﺤﺎﺠ ﹲﺔ ﻤﻥ ﺤﺎﺠﺎ ِ‬
‫ﻥ ﺍﻟﺤﺎﺠ ﹶﺔ ﻟﻺﺤﺴﺎ ِ‬
‫ﺇ‪‬‬
‫ﻙ ﻭﻤﺒﺎﺩﺌﻙ ﻭﺜﻘﺎﻓﺘِﻙ ﻭﺇﺒﺩﺍﻋﻙ؟؟!!‬
‫ﻥ ﻟﻤﺴﺘﻭﻯ ﺨﹸﻠﻘ ِ‬
‫ﺱ ﻴﺭﻗﻭ ‪‬‬
‫ﻭﺍﻟﺸﺭﺍﺏ!‪ ..‬ﻭﻟﻜﻥ‪ ..‬ﻫل ﻴﻤﻜﻨﹸﻙ ﺃﻥ ﺘﻨﺘﻤﻲ ﺇﻻ ﻷﻨﺎ ٍ‬
‫ل ﺤﺘﹼﻰ ﻴﺠ ‪‬ﺩ ﻤﻥ‬
‫ﻥ ﻓﻲ ﻤﻌﺭﻓﺘِﻪ ﻭﻋﻠﻤِﻪ‪ ،‬ﻋﻠﻰ ﺍﻷﻗ ﱢ‬
‫ﻙ ﺍﻵﺨﺭﻴ ‪‬‬
‫ل ﺃﻥ ﻴﺸﺎﺭ ‪‬‬
‫ﺕ ﺃﻥ ﻴﺤﺎﻭ َ‬
‫ل ﻤﻥ ﻴﻘﺭُﺃ ﻫﺫﻩ ﺍﻟﻜﻠﻤﺎ ِ‬
‫ﻥ ﻫﺫﻩ ﺩﻋﻭ ﹲﺓ ﻟﻜ ﱢ‬
‫ﺇ‪‬‬
‫ل )ﺼـﻠﹼﻰ‬
‫ﻕ ﻋﻠﻴﻪ ﻗﻭل ﺍﻟﺭﺴﻭ ِ‬
‫ل ﺍﻟﻤﻘﺎﻴﻴﺱ!!‪ ،‬ﻭﺤﺘﹼﻰ ﻴﻨﻁﺒ ﹶ‬
‫ﻴﻘﺩ‪ ‬ﺭ ﻫﺫﻩ ﺍﻟﻤﻌﺭﻓ ﹶﺔ ﻭﻴﺤﺘﺭ ‪‬ﻡ ﻫﺫﺍ ﺍﻟﻌﻠﻡ‪ ،‬ﻓﻲ ﻤﺠﺘﻤ ٍﻊ ﺍﺨﺘﻠﹼﺕ ﺒﻪ ﻜ ّ‬
‫ﺱ ﺃﻨﻔﻌ‪‬ﻬﻡ ﻟﻠﻨﺎﺱ"‪.‬‬
‫ﷲ ﻋﻠﻴﻪ ﻭﺴﻠﹼﻡ(‪" :‬ﺨﻴ ‪‬ﺭ ﺍﻟﻨﺎ ِ‬
‫ﺍ ُ‬

‫ﻭﻓﻲ ﺍﻟﻨﻬﺎﻴﺔ ﺃﺭﺠﻭﺍ ﻤﻥ ﻜل ﻤﻥ ﻴﺴﺘﻔﻴﺩ ﻤﻥ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﺃﻥ ﻴﺩﻋﻭ ﻟﻲ ﺒﺎﻟﻬﺩﺍﻴﺔ ﻭﺍﻟﺘﻭﻓﻴﻕ ﻭﺍﻟﻨﺠﺎﺡ ﻭﻟﻸﻤ‪‬ﺔ ﺍﻹﺴﻼﻤﻴ‪‬ﺔ‬
‫ﺒﺎﻟﻨﺼﺭ ﻭﺍﻟﻌﺯ‪‬ﺓ ﻭﺍﻟﺨﺭﻭﺝ ﻤﻤ‪‬ﺎ ﻫﻲ ﻓﻴﻪ ﻤﻥ ﻤﺤﻥ‪..‬‬
‫ﺍﻟﻠﻬﻡ ﻋﻠﻤﻨﺎ ﻤﺎ ﻴﻨﻔﻌﻨﺎ ﻭﺍﻨﻔﻌﻨﺎ ﺒﻤﺎ ﻋﻠﻤﺘﻨﺎ ﻭﺍﻨﻔﻊ ﺍﻟﻨﺎﺱ ﺒﻨﺎ ﻭﺍﻏﻔﺭ ﻟﻨﺎ ﻭﺍﺭﺤﻤﻨﺎ ﺇﻨﻙ ﺃﻨﺕ ﺍﻟﻐﻔﻭﺭ ﺍﻟﺭﺤﻴﻡ‬

‫ﻤﺤﻤﺩ ﺨﺎﻟﺩ ﻨﺎﺼﺭ ﺁﻏﺎ‬

‫ﺴﻭﺭﻴﺔ ‪ -‬ﺠﺎﻤﻌﺔ ﺤﻠﺏ‬
‫ﺍﻟﺤﺭﻡ ﺍﻟﺠﺎﻤﻌﻲ ﺍﻟﺭﻗﻤﻲ ﺍﻟﻔﺭﺍﻨﻜﻔﻭﻨﻲ‬
‫‪Support@alshater.net‬‬

‫‪6‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ﺍﻷﻭﻟﻰ‬
‫ﻨﺒﺫﻩ ﻋﻥ ﺩﻟﻔﻲ ‪:‬‬
‫ﻤﻥ ﺍﻟﻤﻌﺭﻭﻑ ﺃﻥ ﺩﻟﻔﻲ ﻫﻲ ﻤﻨﺘﺞ ﺒﻭﺭﻻﻨﺩ ﺍﻷﻜﺜﺭ ﻤﺒﻴﻌﹰﺎ ﻟﻠﺘﻁﻭﻴﺭ ﺍﻟﺴﺭﻴﻊ ﻟﻠﺘﻁﺒﻴﻘﺎﺕ ‪RAD (Rapid Application‬‬
‫)‪Development‬ﻭﺍﻟﻤﺴﺘﺨﺩﻡ ﻟﻜﺘﺎﺒﺔ ﺘﻁﺒﻴﻘﺎﺕ ﻭﻴﻨﺩﻭﺯ ‪ ،‬ﻭﻴﻤﻜﻥ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﺩﻟﻔﻲ ﺇﻨﺸﺎﺀ ﺘﻁﺒﻴﻘﺎﺕ ﻭﻴﻨـﺩﻭﺯ ﺒـﺴﺭﻋﺔ‬
‫ﺃﻜﺒﺭ ﻭﺒﺴﻬﻭﻟﺔ ﺃﻜﺜﺭ ﻤﻥ ﺃﻱ ﻭﻗﺕ ﻤﻀﻰ‪.‬‬
‫ﻫﺫﺍ ﻴﻌﻨﻲ ﺃﻨﻪ ﻨﺴﺘﻁﻴﻊ ﺇﻨﺸﺎﺀ ﻭﺍﺠﻬﺔ ﺍﻟﻤﺴﺘﺨﺩﻡ ) ﻴﻘﺼﺩ ﺒﻭﺍﺠﻬﺔ ﺍﻟﻤـﺴﺘﺨﺩﻡ ﺍﻟﻘـﻭﺍﺌﻡ ﻭﻤﺭﺒﻌـﺎﺕ ﺍﻟﺤـﻭﺍﺭ ﻭﺍﻹﻁـﺎﺭ‬
‫ﺍﻟﺭﺌﻴﺴﻲ ‪ (..‬ﻟﻠﺒﺭﻨﺎﻤﺞ ﻤﺴﺘﺨﺩﻤﻴﻥ ﺘﻘﻨﻴﺎﺕ ﺍﻟﺴﺤﺏ ﻭﺍﻹﻓﻼﺕ ﻟﻤﻁﻭﺭ ﺘﻁﺒﻴﻘﺎﺕ ﺴﺭﻴﻊ ‪ ،‬ﻭﻴﻤﻜﻥ ﺃﻴﻀﹰﺎ ﻭﻀـﻊ ﺘﺤﻜﻤـﺎﺕ‬
‫ﺃﻜﺘﻴﻑ ﺇﻜﺱ ‪ ) Active X‬ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﻓﻲ ﻓﻴﺠﻭل ﺒﻴﺴﻙ ( ﻋﻠﻰ ﺍﻟﻨﻤﺎﺫﺝ ﻹﻨﺸﺎﺀ ﺒﺭﺍﻤﺞ ﻤﺘﺨﺼﺼﺔ ﻤﺜل ﺒﺭﺍﻤﺞ‬
‫ﺍﺴﺘﻌﺭﺍﺽ ﺍﻟﻭﻴﺏ ﻓﻲ ﺩﻗﺎﺌﻕ‪ ،‬ﺘﻘﻭﻡ ﺩﻟﻔﻲ ﺒﻌﻤل ﺠﻴﺩ ﻭﺫﻟﻙ ﺒﺈﺨﻔﺎﺀ ﺒﻌﺽ ﺍﻟﺘﻔﺼﻴﻼﺕ ﺍﻟﺘﻲ ﺘﺸﻜل ﺃﺤﺸﺎﺀ ﺒﺭﻨﺎﻤﺞ ﺍﻟﻭﻴﻨﺩﻭﺯ‬
‫ﻭﻟﻜﻥ ﻟﻴﺱ ﺒﺈﻤﻜﺎﻨﻬﺎ ﻜﺘﺎﺒﺔ ﺍﻟﺒﺭﺍﻤﺞ ﺒﺸﻜل ﻜﺎﻤل ‪ ،‬ﻟﺫﻟﻙ ﻴﺠﺏ ﻓﻲ ﺍﻟﻨﻬﺎﻴﺔ ﺃﻥ ﻴﻜﻭﻥ ﺍﻟﻤﺒﺭﻤﺞ ﺠﻴﺩﹰﺍ‪ ،‬ﻭﻴﻤﻜﻥ ﻟﻬﺫﻩ ﺍﻟﻌﻤﻠﻴـﺔ‬
‫ﺃﻥ ﺘﻜﻭﻥ ﻁﻭﻴﻠـﺔ ‪ ،‬ﻭﺍﻟﺨﺒـﺭ ﺍﻟﺠﻴـﺩ ﺃﻥ ﺩﻟﻔـﻲ ﺘﺠﻌـل ﺍﻟﺭﺤﻠـﺔ ﻏﻴـﺭ ﻤﺘﻌﺒـﺔ ﻭﺤﺘـﻰ ﺃﻨﻬـﺎ ﺘﺠﻌﻠﻬـﺎ ﻤﻤﺘﻌـﺔ‪.‬‬

‫ﻨﻅﺭﺓ ﺴﺭﻴﻌﺔ ﻋﻠﻰ ﻤﻜﻭﻨﺎﺕ ﺩﻟﻔﻲ ‪IDE‬‬

‫ﺴﻨﺘﻌﺭﻑ ﻓﻲ ﻫﺫﺍ ﺍﻟﻘﺴﻡ ﻋﻠﻰ ﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ ﺍﻟﻤﺘﻜﺎﻤﻠﺔ ﻟﻠﺩﻟﻔﻲ‬
‫‪IDE‬‬ ‫‪(Delphi‬‬ ‫‪Integrated‬‬ ‫‪Development‬‬ ‫‪Environment).‬‬
‫ﻋﻨـﺩﻤﺎ ﺘـﺸﻐل ﺒﺭﻨـﺎﻤﺞ ﺍﻟـﺩﻟﻔﻲ ﺘﻅﻬـﺭ ﺒﻴﺌـﺔ ﺍﻟﺘﻁـﻭﻴﺭ ﻓﻴـﻪ ﻭﺍﻟﺘـﻲ ﺴـﻨﺘﻌﺭﻑ ﻋﻠﻴﻬـﺎ ﻜـل ﻋﻠـﻰ ﺤـﺩﻩ‬
‫ﺍﻹﻁـــﺎﺭ ﺍﻟﻌﻠـــﻭﻱ‪:‬‬ ‫ـ‬ ‫‪1‬‬ ‫‪:‬‬ ‫ﺒﻴﺌـــﺔ ﺩﻟﻔـــﻲ ﻤﻜﻭﻨـــﺔ ﻤـــﻥ ﺜﻼﺜـــﺔ ﺃﻗـــﺴﺎﻡ‬

‫ﻴﻤﻜﻥ ﺍﻋﺘﺒﺎﺭﻩ ﺍﻹﻁﺎﺭ ﺍﻟﺭﺌﻴﺴﻲ ﻴﺤﺘﻭﻱ ﻋﻠﻰ ﺃﺸﺭﻁﺔ ﺍﻷﺩﻭﺍﺕ ﻭﻟﻭﺤﺔ ﺍﻟﻤﻜﻭﻨﺎﺕ ﺘﻭﺼل ﺃﺸـﺭﻁﺔ ﺃﺩﻭﺍﺕ ﺩﻟﻔـﻲ ﺇﻟـﻰ‬
‫ﻭﻅﺎﺌﻑ ﻜﺎﻟﻔﺘﺢ ﻭﺍﻟﺘﺨﺯﻴﻥ ﻭﺍﻟﺒﻨﺎﺀ ﻭﺘﺤﺘﻭﻱ ﻟﻭﺤﺔ ﺍﻟﻤﻜﻭﻨﺎﺕ ﻋﻠﻰ ﻜﺜﻴﺭ ﻤﻥ ﻤﻜﻭﻨﺎﺕ ﺩﻟﻔﻲ ﺍﻟﺘﻲ ﻴﻤﻜـﻥ ﻭﻀـﻌﻬﺎ ﻓـﻲ‬
‫ﺍﻟﺒﺭﻨﺎﻤﺞ ) ﻻﻓﺘﺔ ﻨﺼﻴﺔ ‪ ،‬ﻋﻠﺏ ﺘﺤﺭﻴﺭ ‪ ،‬ﻤﺭﺒﻌﺎﺕ ﺴﺭﺩ ﻭﺃﺯﺭﺍﺭ ﻭﻤﺎ ﺸﺎﺒﻪ ﺫﻟﻙ (‪ ،‬ﻟﺘﻜﻭﻥ ﺃﻜﺜﺭ ﻤﻼﺌﻤﺔ ﻓﺈﻥ ﺍﻟﻤﻜﻭﻨـﺎﺕ‬
‫ﻤﻘﺴﻤﺔ ﺇﻟﻰ ﻤﺠﻤﻭﻋﺎﺕ ‪ ،‬ﺤﺘﻰ ﺘﻀﻊ ﻤﻜﻭﻥ ﻋﻠﻰ ﺒﺭﻨﺎﻤﺠﻙ ﺍﻨﻘﺭ ﻋﻠﻰ ﺍﻟﻤﻜﻭﻥ ﻭﻤﻥ ﺜﻡ ﺍﻨﻘﺭ ﻋﻠﻰ ﺍﻟﻤﻜﺎﻥ ﺤﻴـﺙ ﺘﺭﻴـﺩ‬
‫ﻭﻀﻊ ﺍﻟﻤﻜﻭﻥ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ‪.‬‬

‫‪7‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ 2‬ـ ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ‪ ) :‬ﺴﻨﺘﻌﺭﻑ ﻋﻠﻴﻪ ﺒﺎﻟﺘﻔﺼﻴل ﻓﻲ ﺩﺭﻭﺱ ﻗﺎﺩﻤﺔ (‬
‫ﻭﺍﻟﺫﻱ ﻴﺘﻡ ﺒﻭﺍﺴﻁﺘﻪ ﺘﻌﺩﻴل ﺍﻟﺨﺼﺎﺌﺹ ﻭﺍﻷﺤﺩﺍﺙ ﻟﻠﻌﻨﺼﺭ ﻭﺴﻭﻑ ﻨﺴﺘﺨﺩﻤﻪ ﺒﺸﻜل ﺩﺍﺌﻡ‬
‫ﺨﻼل ﻋﻤﻠﻨﺎ ﻤﻊ ﺩﻟﻔﻲ ﻭﻫﻨﺎﻙ ﺼﻔﺤﺘﻴﻥ ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ﻫﻤﺎ ﺍﻟﺨﺼﺎﺌﺹ ‪Properties‬‬
‫ﻭﺍﻷﺤﺩﺍﺙ‪Events.‬‬

‫ﻤﺼﻁﻠﺢ ﺍﻟﺨﺎﺼﺔ ‪ Property‬ﻴﺤﺘﻭﻱ ﻋﻠﻰ ﺨﺼﺎﺌﺹ ﻟﻬﺎ ﻗﻴﻡ ﺘﺤﺩﺩ ﻋﻤل ﺍﻟﻌﻨﺼﺭ‬
‫ﻴﺘﻀﻤﻥ ﺒﺎﺏ ﺍﻷﺤﺩﺍﺙ ‪ Events‬ﻗﺎﺌﻤﺔ ﺃﺤﺩﺍﺙ ﺍﻟﻌﻨﺼﺭ‪ ،‬ﺘﺘﺸﻜل ﺍﻷﺤﺩﺍﺙ ﻨﺘﻴﺠﺔ ﻟﺘﻔﺎﻋل‬
‫ﺍﻟﻤﺴﺘﺨﺩﻡ ﻤﻊ ﺍﻟﻤﻜﻭﻥ ﻤﺜﻼ ﻋﻨﺩ ﻨﻘﺭ ﺍﻟﻤﻜﻭﻥ ﻴﺘﻭﻟﺩ ﺤﺩﺙ ﻴﺨﺒﺭﻙ ﺒﺄﻥ ﺍﻟﻤﻜﻭﻥ ﻗﺩ ﻨﻘﺭ‬
‫ﺒﺈﻤﻜﺎﻨﻙ ﻜﺘﺎﺒﺔ ﺃﻭﺍﻤﺭ ﺘﺴﺘﺠﻴﺏ ﻟﻬﺫﻩ ﺍﻷﺤﺩﺍﺙ‪.‬‬
‫ﻤﺼﻁﻠﺢ ﺍﻟﺤﺩﺙ ‪ Event‬ﻫﻭ ﺸﻲﺀ ﻤﺎ ﻴﺤﺼل ﻜﻨﺘﻴﺠﺔ ﻟﺘﻔﺎﻋل ﺍﻟﻌﻨﺼﺭ ﻤﻊ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺃﻭ‬
‫ﻼ(‬
‫) ﺤﺩﺙ ﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﻤﺜ ﹰ‬ ‫ﻤﻊ ﻭﻴﻨﺩﻭﺯ‬
‫ﻤﺼﻁﻠﺢ ﻤﻌﺎﻤل ﺍﻟﺤﺩﺙ ‪ Event Handler‬ﻫﻭ ﻤﻘﻁﻊ ﻤﻥ ﺍﻟﺒﺭﻤﺠﺔ ﻴﻨﻔﺫ ﺍﺴﺘﺠﺎﺒﺔ ﻟﻠﺤﺩﺙ‪.‬‬
‫‪ 3‬ـ ﻤﻨﻁﻘﺔ ﻋﻤل ﺩﻟﻔﻲ ‪:‬‬
‫ﺍﻟﺠﺯﺀ ﺍﻟﺜﺎﻟﺙ ﻫﻭ ﻤﻨﻁﻘﺔ ﻋﻤل ﺩﻟﻔﻲ ﻭﻋﺎﺩﺓ ﻤﺎ ﻴﻅﻬﺭ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ‪،‬ﻓﻲ ﺍﻟﻤﻘﺩﻤﺔ ﻤﺼﻤﻡ ﺍﻟﻨﻤﻭﺫﺝ ﻭﺨﻠﻔﻪ ﻤﺤﺭﺭ‬
‫ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﺫﻱ ﺘﺩﺨل ﻋﺒﺭﻩ ﺍﻟﺒﺭﻤﺠﺔ ﻋﻨﺩ ﻜﺘﺎﺒﺔ ﺒﺭﺍﻤﺠﻙ‪.‬‬
‫ﻼ ﻤﻥ ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ﻭﻤﺼﻤﻡ ﺍﻟﻨﻤﻭﺫﺝ ﻭﻤﺤﺭﺭ ﺍﻟﺸﻴﻔﺭﺓ ﺘﺘﻔﺎﻋل ﻓﻴﻤﺎ‬
‫ﻭﻜ ﹰ‬
‫ﺒﻴﻨﻬﺎ ﻋﻨﺩ ﺒﻨﺎﺀ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﻟﺘﻭﻟﺩ ﺍﻟﺒﺭﻨﺎﻤﺞ‪.‬‬

‫‪ 4‬ـ ﺸﺠﺭﺓ ﺍﻟﻌﻨﺎﺼﺭ ‪:‬‬

‫ﺘﻅﻬﺭ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﻤﻭﻀﻭﻋﺔ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﻋﻠﻰ ﺸﻜل ﺸﺠﺭﺓ ﻤﻥ ﺍﻟﻌﻨﺎﺼﺭ‬

‫ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺭﺌﻴﺴﻴﺔ ‪:‬‬

‫‪8‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺃ ـ ﺍﻟﻘﻭﺍﺌﻡ ‪ :‬ﺴﻨﺘﻌﺭﻑ ﻋﻠﻰ ﺍﻟﻘﺎﺌﻤﺔ ‪ File‬ﺒﺎﻟﺘﻔﺼﻴل ﻷﻨﻬﺎ ﺃﺴﺎﺱ ﺍﻟﻌﻤل ﻤﻊ ﺍﻟﺒﻴﺌﺔ ﻭﻤﻥ ﺜﻡ ﺒﺎﻗﻲ ﺍﻟﻘﻭﺍﺌﻡ ﺴﺘﺸﺭﺡ ﻓﻲ‬
‫ﺤﻴﻨﻬﺎ ‪:‬‬
‫‪ 1‬ـ ‪ : File Menu‬ﻭﺘﺤﺘﻭﻱ ﻋﻠﻰ ﺍﻷﻭﺍﻤﺭ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ـ ‪ : New‬ﻭﺘﻅﻬﺭ ﻋﻨﻪ ﻗﺎﺌﻤﺔ ﻓﺭﻋﻴﺔ‬
‫‪ : Application‬ﺍﻟﺒﺩﺀ ﺒﻜﺘﺎﺒﺔ ﺒﺭﻨﺎﻤﺞ ﺠﺩﻴﺩ ) ﻴﻌﻤل ﺘﺤﺕ ﻨﻅﺎﻡ ﻭﻴﻨﺩﻭﺯ ( ‪.‬‬ ‫)‪(1‬‬
‫‪ : CLX‬ﺍﻟﺒﺩﺀ ﺒﻜﺘﺎﺒﺔ ﺒﺭﻨﺎﻤﺞ ﺠﺩﻴﺩ ) ﻴﻌﻤل ﺘﺤﺕ ﻨﻅﺎﻡ ﻟﻴﻨﻜﺱ ﻭﻭﻴﻨﺩﻭﺯ ( ‪.‬‬ ‫)‪(2‬‬
‫‪ :Data Model‬ﺇﻨﺸﺎﺀ ﻭﺤﺩﺓ ﺠﺩﻴﺩﺓ )ﻴﺘﻡ ﺍﻟﻭﺼﻭل ﻟﻬﺎ ﻤﻥ ﺠﻤﻴﻊ ﻨﻤﺎﺫﺝ ﺍﻟﻤﺸﺭﻭﻉ(‪.‬‬ ‫)‪(3‬‬
‫‪ : Form‬ﺇﻀﺎﻓﺔ ﻨﻤﻭﺩﺝ ﺠﺩﻴﺩ ﻟﻠﻤﺸﺭﻭﻉ ‪.‬‬ ‫)‪(4‬‬
‫‪ : Frame‬ﺘﺼﻤﻴﻡ ﻋﻨﺼﺭ ﻴﺤﻭﻱ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﻌﻨﺎﺼﺭ ﻟﻼﺴﺘﺨﺩﺍﻡ ﻤﻊ ﻨﻤﺎﺫﺝ ﺍﻟﻤﺸﺭﻭﻉ ) ﺴﻴﺘﻡ‬ ‫)‪(5‬‬
‫ﺸﺭﺤﺔ ﻓﻴﻤﺎ ﺒﻌﺩ ﺒﻤﺜﺎل ﺨﺎﺹ ‪.‬‬
‫‪ : Others‬ﺴﻴﺘﻡ ﺸﺭﺤﻬﺎ ﻓﻲ ﺤﻴﻨﻬﺎ ‪.‬‬ ‫)‪(6‬‬
‫ـ ‪ : Open‬ﻟﻔﺘﺢ ﻤﻠﻑ ﻭﺤﺩﺓ ) ‪ ( *.Pas‬ﺃﻭ ﻤﻠﻑ ﻤﺸﺭﻭﻉ ) ‪ ( *.dpr‬ﻤﻭﺠﻭﺩﻴﻥ ﻤﺴﺒﻘﹰﺎ ‪.‬‬
‫ـ ‪ : Open Project‬ﻟﻔﺘﺢ ﻤﺸﺭﻭﻉ ﻤﻭﺠﻭﺩ ﻤﺴﺒﻘﹰﺎ ‪.‬‬
‫ـ ‪ : Reopen‬ﻴﻘﺩﻡ ﻻﺌﺤﺔ ﺒﺂﺨﺭ ﻋﺩﺓ ﻤﻠﻔﺎﺕ ﺘﻡ ﻓﺘﺤﻬﺎ ﻟﺴﻬﻭﻟﺔ ﺇﻋﺎﺩﺓ ﻓﺘﺤﻬﺎ ﻤﻥ ﺠﺩﻴﺩ‪.‬‬
‫ـ ‪ : Save‬ﺘﺨﺯﻴﻥ ﺁﺨﺭ ﺘﻌﺩﻴل ‪.‬‬
‫ـ ‪ : Save As‬ﺘﺨﺯﻴﻥ ﺍﻟﻭﺤﺩﺓ ‪ Unit‬ﺍﻟﺤﺎﻟﻴﺔ ﺒﺎﺴﻡ ﺠﺩﻴﺩ ‪.‬‬
‫ـ ‪ : Save Project As‬ﺘﺨﺯﻴﻥ ﻤﻠﻑ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﺭﺌﻴﺴﻲ ‪ Main Program‬ﺒﺎﺴﻡ ﺠﺩﻴﺩ ‪.‬‬
‫ـ ‪ : Save All‬ﺇﻋﺎﺩﺓ ﺘﺨﺯﻴﻥ ﺠﻤﻴﻊ ﻤﻠﻔﺎﺕ ﺍﻟﻤﺸﺭﻭﻉ ‪.‬‬
‫ـ ‪ : Close‬ﺇﻏﻼﻕ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻔﻌﺎﻟﺔ ‪.‬‬
‫ـ ‪ : Close All‬ﺇﻏﻼﻕ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒﺎﻟﻜﺎﻤل ‪.‬‬
‫ـ ‪ : Use Unit‬ﻻﺴﺘﺨﺩﺍﻡ ﻭﺤﺩﺓ ﺃﻱ ﻭﻀﻊ ﺍﺴﻤﻬﺎ ﺒﻌﺩ ﺘﻌﻠﻴﻤﺔ ‪ ) Use‬ﺴﺘﺸﺭﺡ ﺘﻌﻠﻴﻤﺔ ‪ Use‬ﻻﺤﻘﹰﺎ ( ‪.‬‬
‫ـ ‪ : print‬ﻟﻁﺒﺎﻋﺔ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺤﺎﻟﻴﺔ ﺃﻭ ﻟﻁﺒﺎﻋﺔ ﺍﻟﻭﺤﺩﺓ ﺍﻟﺤﺎﻟﻴﺔ‪.‬‬

‫‪9‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ﺍﻟﺜﺎﻨﻴﺔ‬
‫ﺴﻨﻘﻭﻡ ﺍﻵﻥ ﺒﻜﺘﺎﺒﺔ ﺒﺭﻨﺎﻤﺞ ﻴﻘﻭﻡ ﺒﺘﻐﻴﺭ ﻟﻭﻥ ﺍﻟﻨﺎﻓﺫﺓ‪:‬‬
‫ﺃ ـ ﻤﺭﺤﻠﺔ ﺍﻟﺘﺼﻤﻴﻡ ‪:‬‬
‫‪ 1‬ـ ﺇﺒﺩﺃ ﻤﺸﺭﻭﻋﺎ ﺠﺩﻴﺩﺍ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﻘﺎﺌﻤﺔ ‪. File Æ New Æ Application‬‬
‫‪ 2‬ـ ﻟﻨﻌﻁﻲ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺠﺩﻴﺩ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫ﺸﺭﺡ ﺍﻟﺨﺎﺼﺔ‬ ‫ﺍﻟﻘﻴﻤﺔ‬ ‫ﺃﺴﻡ ﺍﻟﺨﺎﺼﺔ‬

‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺒﺘﺤﻭﻴل ﺍﺘﺠﺎﻩ ﺍﻟﻨﺹ ﻭﺍﻟﻌﻨﺎﺼﺭ ﻓﻲ ﺍﻟﻨﻤﻭﺫﺝ ﻤﻥ ﺍﻟﻴﻤﻴﻥ‬ ‫‪bdRightToLeft BiDiMode‬‬
‫ﺇﻟﻰ ﺍﻟﻴﺴﺎﺭ ) ﻟﻤﻭﺍﻓﻘﺔ ﺍﻟﺒﺭﺍﻤﺞ ﺍﻟﻌﺭﺒﻴﺔ (‬
‫ﺘﺤﺩﻴﺩ ﺍﺭﺘﻔﺎﻉ ﺍﻟﻨﻤﻭﺫﺝ‬ ‫‪280‬‬ ‫‪Height‬‬
‫ﺘﺤﺩﻴﺩ ﻋﺭﺽ ﺍﻟﻨﻤﻭﺫﺝ‬ ‫‪350‬‬ ‫‪Width‬‬
‫ﺘﺤﺩﻴﺩ ﻋﻨﻭﺍﻥ ﻟﻠﻨﻤﻭﺫﺝ ﻴﻅﻬﺭ ﻓﻲ ﺸﺭﻴﻁ ﺍﻟﻌﻨﻭﺍﻥ‬ ‫ﺘﻐﻴﺭ ﺍﻷﻟﻭﺍﻥ‬ ‫‪Caption‬‬
‫‪ poDesktopCenter‬ﺘﺤﺩﻴﺩ ﻤﻜﺎﻥ ﻅﻬﻭﺭ ﺍﻟﻨﻤﻭﺫﺝ ) ﺴﺘﺸﺭﺡ ﻗﻴﻤﻬﺎ ﻓﻴﻤﺎ ﺒﻌﺩ (‬ ‫‪Position‬‬
‫‪ 2‬ـ ﻨﻀﻊ ﺜﻼﺜﺔ ﺃﺯﺭﺍﺭ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ )‪ ( Button‬ﻤﻥ ﺼﻔﺤﺔ ﺍﻟﻌﻨﺎﺼﺭ ‪ Standard‬ﻭﻨﻌﻁﻲ ﻟﻜل ﻤﻨﻬﻡ ﺍﻟﺨﺼﺎﺌﺹ‬
‫ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪: Button1‬‬
‫ﺇﻋﻁﺎﺀ ﺍﺴﻡ ﺠﺩﻴﺩ ﻟﻠﻌﻨﺼﺭ ﻏﻴﺭ ﺍﻻﺴﻡ ﺍﻻﻓﺘﺭﺍﻀﻲ‬ ‫‪RedButton‬‬ ‫‪Name‬‬
‫ﺘﺤﺩﻴﺩ ﻋﻨﻭﺍﻥ ﻟﻠﺯﺭ‬ ‫ﺃﺤﻤﺭ‬ ‫‪Caption‬‬
‫ﺘﺤﺩﻴﺩ ﺒﻌﺩ ﺍﻟﺯﺭ ﻋﻥ ﺃﻋﻠﻰ ﺍﻟﻨﺎﻓﺫﺓ ) ﺒﻜﺴل(‬ ‫‪160‬‬ ‫‪Top‬‬
‫ﺘﺤﺩﻴﺩ ﺒﻌﺩ ﺍﻟﺯﺭ ﻋﻥ ﻴﺴﺎﺭ ﺍﻟﻨﺎﻓﺫﺓ ) ﺒﻜﺴل (‬ ‫‪230‬‬ ‫‪Left‬‬
‫‪Button2‬‬
‫ﺇﻋﻁﺎﺀ ﺍﺴﻡ ﺠﺩﻴﺩ ﻟﻠﻌﻨﺼﺭ ﻏﻴﺭ ﺍﻻﺴﻡ ﺍﻻﻓﺘﺭﺍﻀﻲ‬ ‫‪GreenButton‬‬ ‫‪Name‬‬
‫ﺘﺤﺩﻴﺩ ﻋﻨﻭﺍﻥ ﻟﻠﺯﺭ‬ ‫ﺃﺨﻀﺭ‬ ‫‪Caption‬‬
‫ﺘﺤﺩﻴﺩ ﺒﻌﺩ ﺍﻟﺯﺭ ﻋﻥ ﺃﻋﻠﻰ ﺍﻟﻨﺎﻓﺫﺓ ) ﺒﻜﺴل(‬ ‫‪190‬‬ ‫‪Top‬‬
‫ﺘﺤﺩﻴﺩ ﺒﻌﺩ ﺍﻟﺯﺭ ﻋﻥ ﻴﺴﺎﺭ ﺍﻟﻨﺎﻓﺫﺓ ) ﺒﻜﺴل (‬ ‫‪203‬‬ ‫‪Left‬‬
‫‪Button3‬‬
‫ﺇﻋﻁﺎﺀ ﺍﺴﻡ ﺠﺩﻴﺩ ﻟﻠﻌﻨﺼﺭ ﻏﻴﺭ ﺍﻻﺴﻡ ﺍﻻﻓﺘﺭﺍﻀﻲ‬ ‫‪CloseButton‬‬ ‫‪Name‬‬
‫ﺘﺤﺩﻴﺩ ﻋﻨﻭﺍﻥ ﻟﻠﺯﺭ‬ ‫ﺇﻏﻼﻕ‬ ‫‪Caption‬‬
‫ﺘﺤﺩﻴﺩ ﺒﻌﺩ ﺍﻟﺯﺭ ﻋﻥ ﺃﻋﻠﻰ ﺍﻟﻨﺎﻓﺫﺓ ) ﺒﻜﺴل(‬ ‫‪200‬‬ ‫‪Top‬‬
‫ﺘﺤﺩﻴﺩ ﺒﻌﺩ ﺍﻟﺯﺭ ﻋﻥ ﻴﺴﺎﺭ ﺍﻟﻨﺎﻓﺫﺓ ) ﺒﻜﺴل (‬ ‫‪24‬‬ ‫‪Left‬‬

‫‪10‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬

‫ﺏ ـ ﻜﺘﺎﺒﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ‪:‬‬

‫‪ 1‬ـ ﻨﻀﻐﻁ ﻤﺭﺘﻴﻥ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻷﻭل ﻓﻴﻅﻬﺭ ﻤﺤﺭﺭ ﺍﻟﺸﻴﻔﺭﺓ ﻨﻜﺘﺏ ﻓﻴﻪ ﻤﺎﻴﻠﻲ ‪:‬‬
‫; ‪form1.Color := clred‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﻌﻤﻠﻴﺔ ﺒﺘﻐﻴﺭ ﻟﻭﻥ ﺍﻟﻨﻤﻭﺫﺝ ﺇﻟﻰ ﺍﻟﻠﻭﻥ ﺍﻷﺤﻤﺭ ﻋﻥ ﻁﺭﻴﻕ ﺇﻋﻁﺎﺀ ﺨﺎﺼﺔ ﺍﻟﻠﻭﻥ ‪ Color‬ﺍﻟﻘﻴﻤﺔ ‪ clred‬ﻭﻫﻲ‬
‫ﻗﻴﻤﺔ ﻤﺤﺠﻭﺯﺓ ﻓﻲ ﺍﻟﺩﻟﻔﻲ ﻭﺘﺩل ﻋﻠﻰ ﺍﻟﻠﻭﻥ ﺍﻷﺤﻤﺭ‪.‬‬
‫‪ 2‬ـ ﻨﻀﻐﻁ ﻤﺭﺘﻴﻥ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺜﺎﻨﻲ ﻓﻴﻅﻬﺭ ﻤﺤﺭﺭ ﺍﻟﺸﻴﻔﺭﺓ ﻨﻜﺘﺏ ﻓﻴﻪ ﻤﺎﻴﻠﻲ ‪:‬‬
‫;‪form1.Color := clgreen‬‬
‫‪ 3‬ـ ﻨﻀﻐﻁ ﻤﺭﺘﻴﻥ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺜﺎﻟﺙ ﻓﻴﻅﻬﺭ ﻤﺤﺭﺭ ﺍﻟﺸﻴﻔﺭﺓ ﻨﻜﺘﺏ ﻓﻴﻪ ﻤﺎﻴﻠﻲ ‪:‬‬
‫;‪close‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺈﻏﻼﻕ ﺍﻟﻨﺎﻓﺫﺓ‬

‫ﻭﺒﺫﻟﻙ ﻨﻜﻭﻥ ﻗﺩ ﺃﻨﻬﻴﻨﺎ ﻜﺘﺎﺒﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻟﺤﻔﻅﻪ ﻨﺨﺘﺎﺭ ﺍﻷﻤﺭ‬

‫‪File ÆSave Project As‬‬
‫ﻟﻨﻌﻁﻲ ﺍﻟﻭﺤﺩﺓ ﺍﻻﺴﻡ ‪ NewCloors‬ﻭﺍﻟﻤﺸﺭﻭﻉ ﺍﻷﺴﻡ‬
‫‪ChangeCloros‬‬
‫ﻭﻟﺘﻨﻔﻴﺫﻩ ﻨﻀﻐﻁ ﻋﻠﻰ ‪ F9‬ﺃﻭ ﻨﺨﺘﺎﺭ ﺍﻷﻤﺭ ‪ Run‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ‬
‫‪Run‬‬
‫) ‪( Run ÆRun‬‬
‫ﺴﻨﻘﻭﻡ ﺍﻵﻥ ﺒﺘﻐﻴﺭ ﺒﻌﺽ ﺨﻭﺍﺹ ﺍﻟﻌﻨﺎﺼﺭ ﻟﻠﺘﻌﺭﻑ ﻋﻠﻰ‬
‫ﺨﺼﺎﺌﺹ ﺠﺩﻴﺩﺓ ‪:‬‬
‫‪ 1‬ـ ﺨﺼﺎﺌﺹ ﺍﻟﻨﻤﻭﺫﺝ ‪:‬‬
‫ﻨﺨﺘﺎﺭ ﺍﻟﻨﻤﻭﺫﺝ ﺒﺎﻟﻨﻘﺭ ﻋﻠﻴﻪ ﺃﻭ ﺒﺎﺨﺘﻴﺎﺭ ﺍﺴﻤﻪ ) ‪ ( Form1‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺃﻋﻠﻰ ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ‪:‬‬
‫ﺃ ـ ‪ : BorderIcons‬ﺘﻅﻬﺭ ﺃﻤﺎﻡ ﻫﺫﻩ ﺍﻟﻘﺎﺌﻤﺔ ﺇﺸﺎﺭﺓ ‪ +‬ﺒﺎﻟﻨﻘﺭ ﻋﻠﻴﻬﺎ ﺘﻅﻬﺭ ﻟﻬﺎ ﺃﺭﺒﻊ ﺨﻴﺎﺭﺍﺕ ﺘﺄﺨﺫ ﻜل ﻤﻨﻬﺎ ﺍﻟﻘﻴﻤﺔ‬
‫‪:‬‬ ‫ﺼﺢ ﺃﻭ ﺨﻁﺄ ﻭﺘﺘﺤﻜﻡ ﻫﺫﻩ ﺍﻟﺨﻭﺍﺹ ﺒﺄﺯﺭﺍﺭ ﺸﺭﻴﻁ ﺍﻟﻌﻨﻭﺍﻥ‬
‫‪ : Bisystemmenu‬ﺒﺈﻋﻁﺎﺀ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﻟﻘﻴﻤﺔ ‪ False‬ﺘﺨﺘﻔﻲ ﺍﻷﺯﺭﺍﺭ ﺍﻟﺜﻼﺜﺔ ‪.‬‬
‫‪ : BiMinimize‬ﺒﺈﻋﻁﺎﺀ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﻟﻘﻴﻤﺔ ‪ False‬ﻴﺨﺘﻔﻲ ﺯﺭ ﺍﻟﺘﺼﻐﻴﺭ ـ ‪.‬‬
‫‪ : BiMaximize‬ﺒﺈﻋﻁﺎﺀ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﻟﻘﻴﻤﺔ ‪ False‬ﻴﺨﺘﻔﻲ ﺯﺭ … ‪.‬‬
‫‪ : BiHelp‬ﺒﺈﻋﻁﺎﺀ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻴﻅﻬﺭ ﺍﻟﺯﺭ ؟ ) ﻻ ﻴﻅﻬﺭ ﻫﺫﺍ ﺍﻟﺯﺭ ﻤﻊ ﺍﻟﻨﻭﺍﻓﺫ ﺍﻟﻌﺎﺩﻴﺔ‬
‫ﺴﺘﺸﺭﺡ ﻤﻊ ﺍﻟﺨﺎﺼﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻨﺘﺎﺌﺞ ﺍﻟﺘﻌﺩﻴل ﻓﻲ ﻫﺫﻩ ﺍﻟﺨﻭﺍﺹ ﻻ ﺘﻅﻬﺭ ﺇﻻ ﻓﻲ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ‪.‬‬
‫ﺏ ـ ‪ : Borderstyle‬ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺒﺎﻟﺘﺤﻜﻡ ﺒﺸﻜل ﺍﻟﻨﺎﻓﺫﺓ ﻭﺸﺭﻴﻁ ﺍﻟﻌﻨﻭﺍﻥ ﻭﺘﺄﺨﺫ ﺇﺤﺩﻯ ﺍﻟﻘﻴﻡ ﺍﻟﺘﺎﻟﻴﺔ ‪.‬‬

‫‪11‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ : bsDialog‬ﺘﻘﻭﻡ ﺒﺈﺨﻔﺎﺀ ﺃﺯﺭﺍﺭ ﺍﻟﺘﻜﺒﻴﺭ ﻭﺍﻟﺘﺼﻐﻴﺭ ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﻤﻨﻊ ﺘﻐﻴﺭ ﺤﺠﻡ ﺍﻟﻨﻤﻭﺫﺝ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ‬
‫ﻭﻴﻅﻬﺭ ﻓﻘﻁ ﺯﺭ ﺍﻹﻏﻼﻕ ﻭﺍﻟﺯﺭ ؟ ﻓﻲ ﺤﺎل ﺘﻡ ﺇﻋﻁﺎﺀ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻟﻠﺨﺎﺼﺔ ‪. Bihelp‬‬
‫‪ : bsNone‬ﻴﻅﻬﺭ ﺍﻟﻨﻤﻭﺫﺝ ﺒﺩﻭﻥ ﺸﺭﻴﻁ ﻋﻨﻭﺍﻥ ﻭﻻ ﻴﻤﻜﻥ ﺘﻐﻴﺭ ﺤﺠﻤﻪ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ‪.‬‬
‫‪ : bsSingle‬ﺘﻅﻬﺭ ﺠﻤﻴﻊ ﺃﺯﺭﺍﺭ ﺸﺭﻴﻁ ﺍﻟﻌﻨﻭﺍﻥ ﻭﻻ ﻴﻤﻜﻥ ﺘﻐﻴﺭ ﺤﺠﻤﻪ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ‪.‬‬
‫‪ : bsSizeable‬ﻭﻫﻲ ﺍﻟﻘﻴﻤﺔ ﺍﻻﻓﺘﺭﺍﻀﻴﺔ ﻭﻴﻅﻬﺭ ﺍﻟﻨﻤﻭﺫﺝ ﺒﺸﻜﻠﻪ ﺍﻟﻁﺒﻴﻌﻲ ﻤﻊ ﺇﻤﻜﺎﻨﻴﺔ ﺍﻟﺘﻜﺒﻴﺭ ﻭﺍﻟﺘﺼﻐﻴﺭ ﻭﺍﻟﺘﺤﺠﻴﻡ‪.‬‬
‫‪ bsSizeToolWin‬ﻭ ‪ : bsToolWindow‬ﻴﻅﻬﺭ ﺸﺭﻴﻁ ﻋﻨﻭﺍﻥ ﺼﻐﻴﺭ ﻤﻊ ﺯﺭ × ﻓﻘﻁ ﻭﺘﺨﺘﻠﻑ ﺍﻷﻭﻟﻰ ﻋﻥ ﺍﻟﺜﺎﻨﻴﺔ‬
‫ﺒﺈﻤﻜﺎﻨﻴﺔ ﺘﻐﻴﺭ ﺍﻟﺤﺠﻡ ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻨﺘﺎﺌﺞ ﺍﻟﺘﻌﺩﻴل ﻓﻲ ﻫﺫﻩ ﺍﻟﺨﻭﺍﺹ ﻻ ﺘﻅﻬﺭ ﺇﻻ ﻓﻲ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ‪.‬‬
‫ﺝ ـ ‪ : Position‬ﻹﻅﻬﺎﺭ ﺍﻟﻨﻤﻭﺫﺝ ﻓﻲ ﻤﻜﺎﻥ ﻤﺎ ﻋﻠﻰ ﺍﻟﺸﺎﺸﺔ ﻭﺃﻫﻡ ﻗﻴﻤﻬﺎ ‪:‬‬
‫‪ : poDesigned‬ﻴﻅﻬﺭ ﺍﻟﻨﻤﻭﺫﺝ ﻓﻲ ﺍﻟﻤﻜﺎﻥ ﺍﻟﺫﻱ ﺤﺩﺩ ﻟﻪ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ‪.‬‬
‫‪ : poDesktopCenter‬ﻴﻅﻬﺭ ﺍﻟﻨﻤﻭﺫﺝ ﻓﻲ ﻭﺴﻁ ﺍﻟﺸﺎﺸﺔ‪.‬‬
‫‪ : poScreenCenter‬ﻴﻅﻬﺭ ﺍﻟﻨﻤﻭﺫﺝ ﻓﻲ ﻭﺴﻁ ﺍﻟﺸﺎﺸﺔ ) ﻓﻲ ﺤﺎل ﻭﺠﻭﺩ ﺸﺎﺸﺔ ﻭﺍﺤﺩﺓ ﻟﻬﺫﻩ‬
‫ﺍﻟﺨﺎﺼﺔ ﻨﻔﺱ ﻨﺘﻴﺠﺔ ﺍﻟﺨﺎﺼﺔ ﺍﻟﺴﺎﺒﻘﺔ ( ‪.‬‬
‫ﺩ ـ ‪ : Icon‬ﺘﺘﺤﻜﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺒﺸﻜل ﺃﻴﻘﻭﻨﺔ ﺍﻟﻨﺎﻓﺫﺓ ‪ ،‬ﻭﻋﻨﺩ ﺘﺤﺩﻴﺩ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﻴﻅﻬﺭ ﺯﺭ ﻋﻠﻴﻪ ﺜﻼﺙ ﻨﻘﺎﻁ ‪...‬‬
‫ﺒﺎﻟﻨﻘﺭ ﻋﻠﻴﻪ ﻴﻅﻬﺭ ﺼﻨﺩﻭﻕ ﺤﻭﺍﺭ ﻻﺨﺘﻴﺎﺭ ﺃﻴﻘﻭﻨﺔ ) ﻴﺘﻡ ﻋﺎﺩﺓ ﺠﻠﺏ ﺍﻷﻴﻘﻭﻨﺎﺕ ﻤﻥ ﺍﻻﻨﺘﺭﻨﺕ ﺃﻭ ﻴﺘﻡ ﺭﺴﻤﻬﺎ‬
‫ﻴﺩﻭﻴﹰﺎ ﻜﻤﺎ ﺴﻨﺭﻯ ﻻﺤﻘﹰﺎ ( ﻴﻤﻜﻥ ﺍﺨﺘﻴﺎﺭ ﺃﺤﺩﻯ ﺍﻷﻴﻘﻭﻨﺎﺕ ﻤﻥ ﺍﻟﺩﻟﻴل ‪:‬‬
‫‪C:\Program Files\Common Files\Borland Shared\Images\Icons‬‬
‫ﻫﺫﻩ ﻫﻲ ﺍﻟﺨﻭﺍﺹ ﺍﻷﺴﺎﺴﻴﺔ ﻟﻠﻨﻤﻭﺫﺝ ﻭﺴﻨﺘﻌﺭﻑ ﻋﻠﻰ ﺒﺎﻗﻲ ﺍﻟﺨﻭﺍﺹ ﻻﺤﻘﹰﺎ ‪.‬‬
‫‪ 1‬ـ ﺨﺼﺎﺌﺹ ﺍﻟﺯﺭ ‪:‬‬
‫ﺒﺎﻹﻀﺎﻓﺔ ﻟﻠﺨﺼﺎﺌﺹ ﺍﻟﻤﻌﺭﻭﻓﺔ ) ‪ ( Top, Left, Width, Height, Caption‬ﻫﻨﺎﻙ ﺒﻌﺽ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﻤﻬﻤﺔ ‪:‬‬
‫‪ : BiDiMode‬ﺘﻡ ﺸﺭﺡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺴﺎﺒﻘﹰﺎ ﺒﺎﻟﻨﺴﺒﺔ ﻟﻠﻨﻤﻭﺫﺝ ﻭﻟﻜﻥ ﻤﻥ ﺍﻟﻤﻬﻡ ﺃﻥ ﻨﻌﻠﻡ ﺃﻨﻪ ﻋﻨﺩ ﺘﻐﻴﺭ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ‬
‫ﻓﻲ ﺍﻟﻨﻤﻭﺫﺝ ﺘﺘﻐﻴﺭ ﺒﺸﻜل ﺘﻠﻘﺎﺌﻲ ﻓﻲ ﺍﻟﺯﺭ ‪.‬‬
‫‪ : Font‬ﺘﺘﺤﻜﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺒﻨﻭﻉ ﺨﻁ ﻋﻨﻭﺍﻥ ﺍﻟﺯﺭ ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﻟﻭﻥ ﺍﻟﻌﻨﻭﺍﻥ ﻭﺤﺠﻤﻪ‪.‬‬
‫‪ : Hint‬ﺘﻅﻬﺭ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﻤﻼﺤﻅﺔ ﻋﻨﺩ ﻭﻗﻭﻑ ﻤﺅﺸﺭ ﺍﻟﻔﺄﺭﺓ ﻓﻭﻕ ﺍﻟﺯﺭ‬
‫‪ : Showhint‬ﻴﺠﺏ ﺃﻥ ﺘﺄﺨﺫ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﺤﺘﻰ ﻴﺘﻡ ﺘﻔﻌﻴل ﺍﻟﺨﺎﺼﺔ ﺍﻟﺴﺎﺒﻘﺔ ‪.‬‬
‫ﻤﺜﺎل ‪ :‬ﺃﺨﺘﺭ ﺍﻟﺯﺭ ‪ RedButton‬ﺜﻡ ﺍﺨﺘﺭ ﺍﻟﺨﺎﺼﺔ ‪ Hint‬ﻤﻥ ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ﻭﺍﻜﺘﺏ ﺍﻟﻨﺹ‬
‫ﺍﻟﺘﺎﻟﻲ ) ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﻫﺫﺍ ﺍﻟﺯﺭ ﺴﻴﺘﺤﻭل ﻟﻭﻥ ﺍﻟﻨﺎﻓﺫﺓ ﺇﻟﻰ ﺍﻟﻠﻭﻥ ﺍﻷﺤﻤﺭ ( ﺜﻡ ﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ‬
‫‪ ShowHint‬ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻭﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪.‬‬
‫‪ : Visible‬ﻋﻨﺩ ﺇﻋﻁﺎﺀ ﺍﻟﻘﻴﻤﺔ ‪ False‬ﻟﻬﺫﻩ ﺍﻟﺨﺎﺼﺔ ﻟﻥ ﻴﻅﻬﺭ ﺍﻟﺯﺭ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ‪.‬‬
‫‪ : Enable‬ﻋﻨﺩ ﺇﻋﻁﺎﺀ ﺍﻟﻘﻴﻤﺔ ‪ False‬ﻟﻬﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺴﻴﻅﻬﺭ ﺍﻟﺯﺭ ﺒﺸﻜل ﺒﺎﻫﺕ ﻭﻻ ﻴﻤﻜﻥ ﺍﻟﻀﻐﻁ ﻋﻠﻴﻪ‪.‬‬

‫‪12‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ : TabOrder‬ﺃﺜﻨﺎﺀ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Tab‬ﻓﻲ ﻟﻭﺤﺔ ﺍﻟﻤﻔﺎﺘﻴﺢ ﻴﻅﻬﺭ ﺇﻁﺎﺭ ﻤﺭﺒﻊ‬
‫ﺩﺍﺨل ﺍﻟﺯﺭ ﻭﻴﻨﺘﻘل ﻫﺫﺍ ﺍﻹﻁﺎﺭ ﻤﻥ ﺯﺭ ﺇﻟﻰ ﺁﺨﺭ ﺒﺎﻟﻨﻘﺭ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Tab‬ﻭﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ‬
‫ﺒﺘﺤﺩﻴﺩ ﺘﺭﺘﻴﺏ ﺍﻨﺘﻘﺎل ﺍﻹﻁﺎﺭ ﻋﻨﺩ ﺍﻟﺘﻨﻘل ﺒﻴﻥ ﺍﻟﻌﻨﺎﺼﺭ‪.‬‬
‫‪ 1‬ـ ﻟﻨﻀﻴﻑ ﺍﻵﻥ ﺯﺭ ﺠﺩﻴﺩ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺴﺎﺒﻕ ﻭﻟﻨﻌﻁﻪ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﺇﻋﻁﺎﺀ ﺍﺴﻡ ﺠﺩﻴﺩ ﻟﻠﻌﻨﺼﺭ ﻏﻴﺭ ﺍﻻﺴﻡ ﺍﻻﻓﺘﺭﺍﻀﻲ‬ ‫‪BtnAbout‬‬ ‫‪Name‬‬
‫ﺘﺤﺩﻴﺩ ﻋﻨﻭﺍﻥ ﻟﻠﺯﺭ‬ ‫‪ Caption‬ﺤﻭ‪‬ل‬
‫ﺘﺤﺩﻴﺩ ﺒﻌﺩ ﺍﻟﺯﺭ ﻋﻥ ﺃﻋﻠﻰ ﺍﻟﻨﺎﻓﺫﺓ ) ﺒﻜﺴل(‬ ‫‪0‬‬ ‫‪Top‬‬
‫ﺘﺤﺩﻴﺩ ﺒﻌﺩ ﺍﻟﺯﺭ ﻋﻥ ﻴﺴﺎﺭ ﺍﻟﻨﺎﻓﺫﺓ ) ﺒﻜﺴل (‬ ‫‪0‬‬ ‫‪Left‬‬
‫ﺘﺤﺩﻴﺩ ﻋﺭﺽ ﺍﻟﺯﺭ‬ ‫‪40‬‬ ‫‪Width‬‬
‫ﺜﻡ ﻨﻀﻴﻑ ﻨﻤﻭﺫﺝ ﺠﺩﻴﺩ ﻟﻠﻤﺸﺭﻭﻉ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﻘﺎﺌﻤﺔ ‪: File Æ New ÆForm‬‬
‫ﻭﺒﺫﻟﻙ ﻴﻅﻬﺭ ﻨﻤﻭﺫﺝ ﺠﺩﻴﺩ ﻟﻨﻌﻁﻪ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﺇﻋﻁﺎﺀ ﺃﺴﻡ ﺠﺩﻴﺩ ﻟﻠﻨﻤﻭﺫﺝ‬ ‫‪About‬‬ ‫‪Name‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺒﺘﺤﻭﻴل ﺍﺘﺠﺎﻩ ﺍﻟﻨﺹ ﻭﺍﻟﻌﻨﺎﺼﺭ ﻓﻲ ﺍﻟﻨﻤﻭﺫﺝ ﻤﻥ‬ ‫‪bdRightToLeft BiDiMode‬‬
‫ﺍﻟﻴﻤﻴﻥ ﺇﻟﻰ ﺍﻟﻴﺴﺎﺭ ) ﻟﻤﻭﺍﻓﻘﺔ ﺍﻟﺒﺭﺍﻤﺞ ﺍﻟﻌﺭﺒﻴﺔ (‬
‫ﺘﺤﺩﻴﺩ ﺍﺭﺘﻔﺎﻉ ﺍﻟﻨﻤﻭﺫﺝ‬ ‫‪250‬‬ ‫‪Height‬‬
‫ﺘﺤﺩﻴﺩ ﻋﺭﺽ ﺍﻟﻨﻤﻭﺫﺝ‬ ‫‪300‬‬ ‫‪Width‬‬
‫ﺘﺤﺩﻴﺩ ﻋﻨﻭﺍﻥ ﻟﻠﻨﻤﻭﺫﺝ ﻴﻅﻬﺭ ﻓﻲ ﺸﺭﻴﻁ ﺍﻟﻌﻨﻭﺍﻥ‬ ‫ﻤﻌﻠﻭﻤﺎﺕ ﺤﻭل ﺍﻟﺒﺭﻨﺎﻤﺞ‬ ‫‪Caption‬‬
‫ﺘﺤﺩﻴﺩ ﻤﻜﺎﻥ ﻅﻬﻭﺭ ﺍﻟﻨﻤﻭﺫﺝ‬ ‫‪poDesigned‬‬ ‫‪Position‬‬
‫ﺍﻵﻥ ﻴﻤﻜﻥ ﺤﻔﻅ ﺍﻟﻨﻤﻭﺫﺝ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Save‬ﻤﻥ ﺃﺯﺭﺍﺭ ﺍﻟﺴﺭﻋﺔ ﺃﻭ ﺒﺎﺨﺘﻴﺎﺭ ﻨﻔﺱ ﺍﻷﻤﺭ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ‬
‫‪ File‬ﺃﻭ ﺒﺎﻟﻀﻐﻁ ﻋﻠﻰ ‪ Ctrl + s‬ﻤﻥ ﻟﻭﺤﺔ ﺍﻟﻤﻔﺎﺘﻴﺢ ‪ ،‬ﻟﻨﻌﻁ ﺍﻟﻭﺤﺩﺓ ﺃﺴﻡ ‪aboutunit‬‬
‫ﻋﻨﺩ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻻ ﻴﻅﻬﺭ ﺇﻻ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻷﻭل ) ‪ ( Form1‬ﻭﺍﻵﻥ ﻋﻠﻴﻨﺎ ﻜﺘﺎﺒﺔ ﺍﻟﺸﻴﻔﺭ ﺍﻟﻤﻨﺎﺴﺒﺔ ﻻﺴﺘﺩﻋﺎﺀ ﺍﻟﻨﻤﻭﺫﺝ‬
‫‪ About‬ﻤﻥ ﺍﻟﻨﻤﻭﺫﺝ ‪. Form1‬‬
‫ﻻﺴﺘﺩﻋﺎﺀ ﻨﻤﻭﺫﺝ ﺜﺎﻨﻲ ﻤﻥ ﻨﻤﻭﺫﺝ ﺃﻭل ﻴﺠﺏ ﻋﻠﻴﻨﺎ ﺃﻥ ﻨﻌﻠﻡ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻷﻭل ﺒﺎﺴﻡ ﺍﻟﻭﺤﺩﺓ ﺍﻟﺘﺎﺒﻊ ﻟﻬﺎ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺜﺎﻨﻲ ﻭﻴﺘﻡ‬
‫ﺫﻟﻙ ﺒﺈﻀﺎﻓﺔ ﺍﺴﻡ ﻭﺤﺩﺓ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺜﺎﻨﻲ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ implementation‬ﻟﻭﺤﺩﺓ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻷﻭل ﺒﻌﺩ ﻋﺒﺎﺭﺓ ‪: Uses‬‬
‫ﻭﺍﻵﻥ ﺃﻀﻑ ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ ﻜﻤﺎ ﻴﻠﻲ ‪:‬‬
‫‪implementation‬‬

‫; ‪uses aboutunit‬‬
‫ﺍﻵﻥ ﻨﻀﻐﻁ ﻤﺭﺘﻴﻥ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ BtnAbout‬ﺍﻟﻤﻭﺠﻭﺩ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻷﻭل ﻭﻨﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪about.Show‬‬
‫ﻴﻘﻭﻡ ﺍﻷﻤﺭ ‪ Show‬ﺒﺈﻅﻬﺎﺭ ﺍﻟﻨﺎﻓﺫﺓ ‪ ) About‬ﺃﺤﻔﻅ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺤﻭل ﻟﻤﺸﺎﻫﺩﺓ ﺍﻟﻨﺘﺎﺌﺞ (‪.‬‬
‫ﻟﻨﻜﻤل ﺍﻵﻥ ﺘﺼﻤﻴﻡ ﺍﻟﻨﻤﻭﺫﺝ ‪: About‬‬

‫‪13‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ 1‬ـ ﻨﻀﻴﻑ ﺍﻟﻌﻨﺼﺭ ‪ ) Panel‬ﻟﻭﺡ ( ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪ Standard‬ﻭﻟﻨﻌﻁﻪ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﺘﺠﻌل ﺍﻟﻌﻨﺼﺭ ﻴﺘﻭﻀﻊ ﻓﻲ ﺃﻋﻠﻰ ﺍﻟﻨﺎﻓﺫﺓ ﻭﻋﻠﻰ ﻋﺭﻀﻬﺎ ﺒﺸﻜل ﻜﺎﻤل‬ ‫‪AlTop‬‬ ‫‪Align‬‬
‫) ﺴﻴﺘﻡ ﺸﺭﺡ ﻗﻴﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﻗﺭﻴﺒﹰﺎ (‬
‫ﺘﺤﺩﻴﺩ ﻋﻨﻭﺍﻥ ﻟﻠﺯﺭ‬ ‫""‬ ‫‪Caption‬‬
‫ﺘﺤﺩﻴﺩ ﺍﺭﺘﻔﺎﻉ ﺍﻟﻠﻭﺡ‬ ‫‪185‬‬ ‫‪Height‬‬
‫ﺘﺤﺩﻴﺩ ﻁﺭﻴﻘﺔ ﻋﺭﺽ ﺍﻟﺤﺩ ﺍﻟﺨﺎﺭﺠﻲ ﻟﻠﻭﺡ‬ ‫‪bvLowered BevelOuter‬‬
‫ﺤﺎﻭل ﺇﻋﻁﺎﺀ ﻗﻴﻤﺔ ﻤﺎ ﻟﺨﺎﺼﺔ ‪ Width‬ﺴﺘﻼﺤﻅ ﺃﻨﻬﺎ ﻻ ﺘﺘﻐﻴﺭ ﻭﺫﻟﻙ ﻷﻥ ﺍﻟﺨﺎﺼﺔ ‪ Align‬ﻤﻔﻌﻠﺔ‬
‫‪ 2‬ـ ﻨﻀﻴﻑ ﺯﺭ ‪ Button‬ﻭﻨﻌﻁﻪ ﺍﻟﺨﻭﺍﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﺇﻋﻁﺎﺀ ﺍﺴﻡ ﺠﺩﻴﺩ ﻟﻠﻌﻨﺼﺭ ﻏﻴﺭ ﺍﻻﺴﻡ ﺍﻻﻓﺘﺭﺍﻀﻲ‬ ‫‪BtnClose‬‬ ‫‪Name‬‬
‫ﺘﺤﺩﻴﺩ ﻋﻨﻭﺍﻥ ﻟﻠﺯﺭ‬ ‫‪ Caption‬ﺇﻏﻼﻕ‬
‫ﺘﺤﺩﻴﺩ ﺒﻌﺩ ﺍﻟﺯﺭ ﻋﻥ ﺃﻋﻠﻰ ﺍﻟﻨﺎﻓﺫﺓ ) ﺒﻜﺴل(‬ ‫‪192‬‬ ‫‪Top‬‬
‫ﺘﺤﺩﻴﺩ ﺒﻌﺩ ﺍﻟﺯﺭ ﻋﻥ ﻴﺴﺎﺭ ﺍﻟﻨﺎﻓﺫﺓ ) ﺒﻜﺴل (‬ ‫‪112‬‬ ‫‪Left‬‬
‫‪ 3‬ـ ﻨﻀﻴﻑ ﻋﻨﺼﺭ ﺍﻟﺼﻭﺭﺓ ‪ Image‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪ Additional‬ﻓﻭﻕ ﺍﻟﻌﻨﺼﺭ ‪Panel‬‬
‫ﺇﻋﻁﺎﺀ ﺼﻭﺭﺓ ﻟﻠﻌﻨﺼﺭ ﻴﻤﻜﻥ ﺃﺨﺘﻴﺎﺭ ﺃﻱ ﺼﻭﺭﺓ ﻤﺭﻏﻭﺒﺔ ) ﻴﻤﻜﻥ ﺃﺨﺫ‬ ‫ﺃﻱ ﺼﻭﺭﺓ‬ ‫‪picture‬‬
‫ﺼﻭﺭﺓ ﻤﻥ ﺍﻟﻤﺠﻠﺩ ‪:‬‬
‫‪C:\Program Files\Common Files\Borland Shared\Images‬‬
‫‪\Splash\256Color‬‬
‫ﺇﻅﻬﺎﺭ ﻜﺎﻤل ﺍﻟﺼﻭﺭﺓ ﺩﺍﺨل ﺍﻟﻌﻨﺼﺭ ‪Image‬‬ ‫‪True‬‬ ‫‪Stretch‬‬
‫ﺘﺤﺩﻴﺩ ﺒﻌﺩ ﺍﻟﺯﺭ ﻋﻥ ﺃﻋﻠﻰ ﺍﻟﻨﺎﻓﺫﺓ ) ﺒﻜﺴل(‬ ‫‪0‬‬ ‫‪Top‬‬
‫ﺘﺤﺩﻴﺩ ﺒﻌﺩ ﺍﻟﺯﺭ ﻋﻥ ﻴﺴﺎﺭ ﺍﻟﻨﺎﻓﺫﺓ ) ﺒﻜﺴل (‬ ‫‪0‬‬ ‫‪Left‬‬
‫‪ 3‬ـ ﻨﻀﻴﻑ ﻋﻨﺼﺭﻴﻥ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Label‬ﻓﻭﻕ ﺍﻟﻌﻨﺼﺭ ‪ Panel‬ﻭﻨﻌﻁﻲ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬
‫‪Label1‬‬
‫‪ Caption‬ﺘﻐﻴﺭ ﺍﻷﻟﻭﺍﻥ‬
‫‪24‬‬ ‫‪Top‬‬
‫‪168‬‬ ‫‪Left‬‬
‫ﻨﻐﻴﺭ ﺍﻟﺨﻁ ﻭﻨﻌﻁﻴﻪ ﺍﻟﻠﻭﻥ ﺍﻷﺯﺭﻕ‬ ‫‪font‬‬
‫‪Label2‬‬
‫‪ Caption‬ﺇﻋﺩﺍﺩ ﻭﺘﻨﻔﻴﺫ ‪:‬‬
‫‪88‬‬ ‫‪Top‬‬
‫‪212‬‬ ‫‪Left‬‬
‫ﻨﻌﻁﻲ ﺍﻟﺨﻁ ﺍﻟﻠﻭﻥ ﺍﻷﺤﻤﺭ‬ ‫‪Font‬‬
‫ﻨﻀﻐﻁ ﻤﺭﺘﻴﻥ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ BtnClose‬ﻭﻨﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ Close‬ﻓﻲ ﻤﺤﺭﺭ ﺸﻴﻔﺭﺓ ‪ ،‬ﺜﻡ ﻨﺤﻔﻅ ﺍﻟﻤﺸﺭﻭﻉ ﻭﻨﻨﻔﺫﻩ ‪.‬‬

‫‪14‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬

‫ﺍﻟﺠﻠﺴﺔ ﺍﻟﺜﺎﻟﺜﺔ‬
‫ﺃﺼﺒﺢ ﺍﻟﻭﻗﺕ ﻤﻼﺌﻤﹰﺎ ﺍﻵﻥ ﻟﻠﺘﻌﺭﻑ ﻋﻠﻰ ﺍﻟﻭﺤﺩﺓ ‪ Unit‬ﺒﺸﻜل ﻤﻔﺼل ‪.‬‬
‫ﺘﺘﺄﻟﻑ ﺍﻟﻭﺤﺩﺓ ﺴﻭﺍﺀ ﻜﺎﻨﺕ ﻤﺭﺘﺒﻁﺔ ﺒﺸﻜل ﺃﻡ ﻻ ﻤﻥ ﺍﻷﺠﺯﺍﺀ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; ‪unit Unit Name‬‬
‫‪interface‬‬
‫‪uses‬‬
‫‪Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,‬‬
‫;‪Dialogs‬‬
‫‪type‬‬
‫)‪TForm1 = class(TForm‬‬
‫‪private‬‬
‫} ‪{ Private declarations‬‬
‫‪public‬‬
‫} ‪{ Public declarations‬‬
‫;‪end‬‬
‫‪var‬‬
‫;‪Form1: TForm1‬‬
‫‪implementation‬‬
‫‪end.‬‬
‫‪ 1‬ـ ﻴﺒﺩﺃ ﺭﺃﺱ ﺍﻟﻭﺤﺩﺓ ﺒﺎﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Unit‬ﻴﻠﻴﻬﺎ ﻤﺒﺎﺸﺭﺓ ﺃﺴﻡ ﺍﻟﻭﺤﺩﺓ ) ﻓﻲ ﻤﺜﺎﻟﻨﺎ ‪. ( NewColors‬‬
‫ﻗﺴﻡ ﺍﻻﺘﺼﺎل ﺍﻟﺨﺎﺭﺠﻲ ‪: Interface‬‬
‫ﺍﻟﺫﻱ ﻴﺤﺩﺩ ﺒﺩﺍﻴﺔ ﻤﻨﻁﻘﺔ ﺍﻻﺘﺼﺎل ﺍﻟﺨﺎﺭﺠﻲ ‪ ،‬ﺃﻱ ﺍﻟﻤﻨﻁﻘﺔ ﻤﻥ ﺍﻟﻭﺤﺩﺓ ﺍﻟﺘﻲ ﻴﻤﻜﻥ ﺃﻥ ﺘﺭﺍﻫﺎ ﻭﺤﺩﺍﺕ ﺃﺨﺭﻯ ﻤﻥ ﻭﺤﺩﺍﺕ‬
‫ﺍﻟﺘﻁﺒﻴﻕ ﻭﻓﻴﻪ ‪:‬‬
‫ﺃ ـ ﺍﻟﻘﺴﻡ ‪ : Uses‬ﺘﻭﻀﻊ ﻓﻴﻪ ﺠﻤﻴﻊ ﺃﺴﻤﺎﺀ ﺍﻟﻭﺤﺩﺍﺕ ﺍﻟﺘﻲ ﺘﺘﻌﺎﻤل ﻤﻌﻬﺎ ﺍﻟﻭﺤﺩﺓ ﺴﻭﺍﺀ ﻜﺎﻨﺕ ﺍﻟﻭﺤﺩﺍﺕ ﺍﻟﺨﺎﺼﺔ‬
‫ﺒﺎﻟﺩﻟﻔﻲ ﺃﻭ ﺍﻟﻭﺤﺩﺍﺕ ﺍﻟﺘﻲ ﺃﻨﺸﺄﻫﺎ ﺍﻟﻤﺒﺭﻤﺞ ) ﻋﻨﺩ ﺇﻀﺎﻓﺔ ﻋﻨﺎﺼﺭ ﺠﺩﻴﺩﺓ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺘﻘﻭﻡ ﺩﻟﻔﻲ ﺒﺈﻀﺎﻓﺔ ﺍﻟﻭﺤﺩﺓ‬
‫ﺍﻟﺘﺎﺒﻌﺔ ﻟﻬﺫﺍ ﺍﻟﻌﻨﺼﺭ ﺒﺸﻜل ﺘﻠﻘﺎﺌﻲ ( ‪.‬‬
‫ﺏ ـ ﺍﻟﻘﺴﻡ ‪ : Type‬ﺘﻌﺭﻑ ﺍﻟﻭﺤﺩﺓ ﻫﻨﺎ ﺼﻨﻔﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻤﻭﺭﻭﺜﹰﺎ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ ) TForm‬ﺼﻨﻑ ﺍﻟﻨﻤﻭﺫﺝ ( ‪ ،‬ﻴﻀﺎﻑ ﺇﻟﻰ‬
‫ﺍﻟﺼﻨﻑ ﺍﻟﺠﺩﻴﺩ ﺃﺴﻤﺎﺀ ﺠﻤﻴﻊ ﺍﻟﻌﻨﺎﺼﺭ ﻭﺍﻷﺤﺩﺍﺙ ﺍﻟﻤﻀﺎﻓﺔ ﺇﻟﻰ ﺍﻟﻭﺤﺩﺓ ) ﻗﺎﺭﻥ ﺒﻴﻥ ﺍﻟﻘﺴﻡ ‪ Type‬ﻟﻠﻭﺤﺩﺓ‬
‫‪ NewColors‬ﻭﺍﻟﻭﺤﺩﺓ ‪ ( AboutUnit‬ﻭﻴﺘﻀﻤﻥ ﺍﻟﻘﺴﻡ ‪ Type‬ﺍﻟﺠﺯﺃﻴﻥ ‪:‬‬
‫‪ : Private‬ﻭﺘﻭﻀﻊ ﻓﻴﻪ ﺍﻟﻤﺘﺤﻭﻻﺕ ﺍﻟﺨﺎﺼﺔ ﺒﺎﻟﻭﺤﺩﺓ ﻨﻔﺴﻬﺎ‪.‬‬
‫‪ : Public‬ﻭﺘﻭﻀﻊ ﻓﻴﻪ ﺍﻟﻤﺘﺤﻭﻻﺕ ﺍﻟﻌﺎﻤﺔ ) ﻤﻥ ﺃﺠل ﺃﻥ ﺘﺘﺒﺎﺩل ﺍﻟﻭﺤﺩﺓ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﻤﻊ ﺍﻟﻭﺤﺩﺍﺕ ﺍﻷﺨﺭﻯ (‬
‫ﻭﺴﻴﺸﺭﺡ ﻫﺫﻴﻥ ﺍﻟﺠﺯﺃﻴﻥ ﺒﺸﻜل ﻤﻔﺼل ﻓﻴﻤﺎ ﺒﻌﺩ ‪ ،‬ﻴﻨﺘﻬﻲ ﺍﻟﻘﺴﻡ ‪ Type‬ﺒﺎﻟﺘﻌﻠﻴﻤﺔ ;‪.end‬‬
‫ﺝ ـ ﺍﻟﻘﺴﻡ ‪ : Var‬ﻴﺘﻡ ﻓﻴﻪ ﺘﻌﺭﻴﻑ ﻋﻥ ﻫﺩﻑ ) ﻏﺭﺽ ( ﺍﺴﻤﻪ ‪ Form1‬ﻤﻥ ﺍﻟﻨﻭﻉ ‪ TForm1‬ﻭﻴﺸﻴﺭ ‪ Form1‬ﺇﻟﻰ‬
‫ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺫﻱ ﻨﻀﻴﻑ ﻟﻪ ﺍﻟﻌﻨﺎﺼﺭ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ‪.‬‬

‫‪15‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬

‫ﻗﺴﻡ ﺍﻟﺘﻨﻔﻴﺫ ‪: implementation‬‬

‫ﻴﻤﻜﻥ ﺃﻥ ﻴﺤﺘﻭﻱ ﻫﺫﺍ ﺍﻟﻘﺴﻡ ﻋﻠﻰ ﺘﺼﺭﻴﺤﺎﺕ ﻋﻥ ﺘﻭﺍﺒﻊ ﻭﺇﺠﺭﺍﺀﺍﺕ ﻭﻤﺘﺤﻭﻻﺕ ﺨﺎﺼﺔ ﺒﺎﻟﻭﺤﺩﺓ ﻨﻔﺴﻬﺎ ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ‬
‫ﺠﻤﻴﻊ ﺍﻟﺘﻭﺍﺒﻊ ﻭﺍﻹﺠﺭﺍﺀﺍﺕ ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﺩﺍﺨل ﺍﻟﻭﺤﺩﺓ ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻗﺩ ﻴﻜﻭﻥ ﺍﻟﺠﺯﺀ ﺍﻟﺴﺎﺒﻕ ﺼﻌﺒﹰﺎ ﺒﻌﺽ ﺍﻟﺸﻲﺀ ﻟﻜﻨﻪ ﻀﺭﻭﺭﻱ ﻟﻤﺘﺎﺒﻌﺔ ﺍﻟﻌﻤل ﻤﻊ ﺩﻟﻔﻲ ﻜﻤﺎ ﺃﻨﻨﺎ ﺴﻨﺘﻌﺭﻑ ﻋﻠﻴﻪ‬
‫ﺒﺸﻜل ﺃﻜﺒﺭ ﻜﻠﻤﺎ ﺩﻋﺕ ﺍﻟﺤﺎﺠﺔ ﺇﻟﻰ ﺫﻟﻙ ‪.‬‬
‫ﺴﻨﻌﻤل ﺍﻵﻥ ﻋﻠﻰ ﻜﺘﺎﺒﺔ ﺘﻁﺒﻴﻘﺎﺕ ﺒﺴﻴﻁﺔ ﺍﻟﻬﺩﻑ ﻤﻨﻬﺎ ﺍﻟﺘﻌﺭﻑ ﻋﻠﻰ ﻋﻨﺎﺼﺭ ﺠﺩﻴﺩﺓ ﻭﺨﺼﺎﺌﺼﻬﺎ ‪:‬‬
‫‪ 1‬ـ ﺍﻟﺘﻌﺭﻑ ﻋﻠﻰ ﺼﻨﺩﻭﻕ ﺍﻻﺨﺘﻴﺎﺭ ‪ checkbox‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪: Standard‬‬
‫ﻼ ﻭﺃﻀﻑ ﺃﻟﻴﻪ ﻋﻨﺼﺭ‬
‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩﹰﺍ ﻭﺼﻐﺭ ﺤﺠﻡ ﺍﻟﻨﻤﻭﺫﺝ ﻗﻠﻴ ﹰ‬
‫ﺍﻟﺯﺭ ‪ Button‬ﻭﻋﻨﺼﺭ ‪: checkbox‬‬
‫ﺍﺨﺘﺭ ﺍﻟﻌﻨﺼﺭ ‪ checkbox1‬ﻤﻥ ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ﻭﺍﻋﻁﻪ ﺍﻟﺨﺎﺼﺔ‬
‫‪" : Caption‬ﺃﻅﻬﺭ ﺍﻟﺯﺭ "‬
‫ﺜﻡ ﺍﻨﺘﻘل ﺇﻟﻰ ﺍﻟﺼﻔﺤﺔ ‪ Event‬ﻭﺍﺨﺘﺭ ﻤﻨﻬﺎ ﺍﻟﺤﺩﺙ ‪ OnClick‬ﻓﻴﻅﻬﺭ‬
‫ﻤﺤﺭﺭ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻜﺘﺏ ﻓﻴﻪ ﺍﻟﺴﻁﺭ ﺍﻟﺘﺎﻟﻲ ‪:‬‬

‫; ‪if checkbox1.Checked then button1.Visible := true else button1.Visible := false‬‬

‫ﺍﻟﺨﺎﺼﺔ ‪ Checked‬ﻟﻠﻌﻨﺼﺭ ‪ checkbox‬ﺘﻌﻴﺩ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻓﻲ ﺤﺎل ﺘﻡ ﺇﻅﻬﺎﺭ ﺇﺸﺎﺭﺓ ; ﻓﻲ ﺼﻨﺩﻭﻕ ﺍﻻﺨﺘﻴﺎﺭ‬
‫ﻭﺍﻟﻘﻴﻤﺔ ‪ False‬ﻓﻲ ﺤﺎل ﺍﺨﺘﻔﺎﺀ ﺍﻹﺸﺎﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ ‪.‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺸﺎﻫﺩ ﺍﻟﻨﺘﺎﺌﺞ ‪.‬‬
‫‪ 3‬ـ ﺍﻟﺘﻌﺭﻑ ﻋﻠﻰ ﻋﻨﺼﺭ ﺼﻨﺩﻭﻕ ﺍﻟﻼﺌﺤﺔ ‪ ListBox‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪: Standard‬‬
‫ﻴﻅﻬﺭ ﻫﺫﺍ ﺍﻟﺼﻨﺩﻭﻕ ﻗﺎﺌﻤﺔ ﺒﻨﺼﻭﺹ ﺘﻡ ﺇﺩﺨﺎﻟﻬﺎ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ‬
‫ﺃﻭ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ‪:‬‬
‫ﻗﻡ ﺒﺈﻨﺸﺎﺀ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﺼﻨﺩﻭﻕ ﻨﺹ ) ‪( Edit‬‬
‫ﻭﺼﻨﺩﻭﻕ ﻻﺌﺤﺔ ) ‪ ( ListBox‬ﻭﺜﻼﺜﺔ ﺃﺯﺭﺍﺭ‬
‫) ‪ ( Button‬ﻜﻤﺎ ﻓﻲ ﺍﻟﺸﻜل ﺍﻟﻤﺭﻓﻕ ‪:‬‬
‫ﺃ ـ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ‪ :‬ﺒﺎﺨﺘﻴﺎﺭ ﺍﻟﺨﺎﺼﺔ ‪ Items‬ﻤﻥ ﻤﺤﺭﺭ‬
‫ﺍﻟﺨﻭﺍﺹ ﺘﻅﻬﺭ ﻨﺎﻓﺫ ﻴﻤﻜﻥ ﺃﻥ ﻨﻜﺘﺏ ﻓﻴﻬﺎ ﺴﻁﻭﺭ ﺍﻟﻘﺎﺌﻤﺔ‬
‫ﻼ ﺃﺩﺨل " ﺍﻟﺠﻠﺴﺔ ﺍﻷﻭﻟﻰ " ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻷﻭل ﻭ "‬
‫ﻤﺜ ﹰ‬
‫ﺍﻟﺠﻠﺴﺔ ﺍﻟﺜﺎﻨﻴﺔ " ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺜﺎﻨﻲ ‪.‬‬
‫ﺏ ـ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ‪:‬‬
‫ﺃﻀﻐﻁ ﻤﺭﺘﻴﻥ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Button‬ﻭﺃﻀﻑ ﺍﻟﺴﻁﺭ ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫‪16‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫;)‪Listbox1.items.add (edit1.text‬‬
‫ﺘﻘﻭﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺴﺎﺒﻘﺔ ﺒﺈﻀﺎﻓﺔ ﺍﻟﻨﺹ ﺍﻟﻤﻜﺘﻭﺏ ﻓﻲ ﺼﻨﺩﻭﻕ ﺍﻟﻨﺹ ﺇﻟﻰ ﺼﻨﺩﻭﻕ ﺍﻟﻼﺌﺤﺔ ) ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺸﺎﻫﺩ ﺍﻟﻨﺘﺎﺌﺞ (‬
‫ﻟﺤﺫﻑ ﺴﻁﺭ ﻭﺍﺤﺩ ﻤﻥ ﻋﻨﺼﺭ ﺍﻟﻼﺌﺤﺔ ﻨﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺜﺎﻨﻲ ﻭﻨﻀﻴﻑ ﺍﻟﺴﻁﺭ ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫; ‪listbox1.DeleteSelected‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺤﺫﻑ ﺍﻟﺴﻁﺭ ﺍﻟﺫﻱ ﺘﻡ ﺍﺨﺘﻴﺎﺭﻩ ﻤﻥ ﺍﻟﻼﺌﺤﺔ ‪.‬‬
‫ﻜﺫﻟﻙ ﻟﺤﺫﻑ ﻋﻨﺎﺼﺭ ﺍﻟﻼﺌﺤﺔ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺜﺎﻟﺙ ﻤﺭﺘﻴﻥ ﻭﺍﻜﺘﺏ ﺍﻟﺴﻁﺭ ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫; ‪Listbox1.items.clear‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﻤﺴﺢ ﺼﻨﺩﻭﻕ ﺍﻟﻼﺌﺤﺔ ﺒﺎﻟﻜﺎﻤل‪.‬‬
‫‪ 4‬ـ ﺍﻟﺘﻌﺭﻑ ﻋﻠﻰ ﺃﺯﺭﺍﺭ ﺍﻟﺭﺍﺩﻴﻭ ) ‪: ( RadioButtons‬‬
‫ﺘﻌﺘﺒﺭ ﺃﺯﺭﺍﺭ ﺍﻟﺭﺍﺩﻴﻭ ﻤﺸﺎﺒﻬﺔ ﻟﻌﻨﺼﺭ ﺼﻨﺩﻭﻕ ﺍﻻﺨﺘﻴﺎﺭ ﻭﺘﺨﺘﻠﻑ ﻋﻨﻪ ﺃﻨﻪ‬
‫ﻻ ﻴﻤﻜﻥ ﺍﺨﺘﻴﺎﺭ ﺯﺭﻱ ﺭﺍﺩﻴﻭ ﺒﻨﻔﺱ ﺍﻟﻭﻗﺕ ﺃﻱ ﺃﻨﻪ ﺃﻤﺎﻡ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺍﺨﺘﻴﺎﺭ‬
‫ﺯﺭ ﻭﺍﺤﺩ ﻤﻥ ﺒﻴﻥ ﺍﻷﺯﺭﺍﺭ ﺍﻟﻅﺎﻫﺭﺓ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ‪.‬‬
‫ﻜﻤﺜﺎل ﻋﻠﻰ ﺫﻟﻙ ‪:‬‬
‫ﺃﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﺜﻼﺜﺔ ﺃﺯﺭﺍﺭ ﺭﺍﺩﻴﻭ ﻜﻤﺎ ﻓﻲ ﺍﻟﺸﻜل ‪:‬‬
‫ﺃﻋﻁ ﺍﻟﺯﺭ ﺍﻟﺜﺎﻟﺙ ﺍﻟﺨﺎﺼﺔ ‪ Checked‬ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻭﺃﻋﻁ ﺍﻟﻨﻤﻭﺫﺝ‬
‫ﺍﻟﻠﻭﻥ ‪. ClCream‬‬
‫ﺃﻀﻐﻁ ﻤﺭﺘﻴﻥ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻷﻭل ﻭﺃﻀﻑ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪form1.Color := clred‬‬
‫ﻭﺃﻀﻑ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻟﻠﺯﺭ ﺍﻟﺜﺎﻨﻲ ‪:‬‬
‫;‪form1.Color := clblue‬‬
‫ﻭﻟﻠﺯﺭ ﺍﻟﺜﺎﻟﺙ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪:‬‬
‫;‪form1.Color := clcream‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺸﺎﻫﺩ ﺍﻟﻨﺘﺎﺌﺞ ‪.‬‬
‫‪ 5‬ـ ﺍﻟﺘﻌﺭﻑ ﻋﻠﻰ ﺼﻨﺩﻭﻕ ﺍﻟﻤﺠﻤﻭﻋﺔ ‪: GroupBox‬‬
‫ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﻟﻨﻔﺭﺽ ﺃﻨﻨﺎ ﻨﺭﻴﺩ ﺇﻀﺎﻓﺔ ﻤﺠﻤﻭﻋﺔ ﺠﺩﻴﺩﺓ ﻤﻥ ﺃﺯﺭﺍﺭ ﺍﻟﺭﺍﺩﻴﻭ ﻟﺘﻐﻴﺭ ﻟﻭﻥ ﺍﻟﺨﻁ ﻓﻲ ﺍﻟﻨﻤﻭﺫﺝ ) ﻜﺎﻨﺕ‬
‫ﺍﻷﺯﺭﺍﺭ ﺍﻟﺴﺎﺒﻘﺔ ﺘﻐﻴﺭ ﻟﻭﻥ ﺍﻟﻨﻤﻭﺫﺝ ( ‪ ،‬ﻓﺈﺫﺍ ﺃﻀﻔﻨﺎ ﺯﺭﻴﻥ ﺁﺨﺭﻴﻥ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﻓﻼ ﻴﻤﻜﻨﻨﺎ ﺘﻐﻴﺭ ﺍﻟﺨﻁ ﻭﺍﻟﻠﻭﻥ ﻤﻌﹰﺎ‬
‫ﻷﻨﻪ ﻻ ﻴﻤﻜﻥ ﺍﺨﺘﻴﺎﺭ ﺯﺭﻱ ﺭﺍﺩﻴﻭ ﻓﻲ ﻨﻔﺱ ﺍﻟﻭﻗﺕ ‪ ،‬ﻭﻫﻨﺎ ﻴﺄﺘﻲ ﺩﻭﺭ ﺼﻨﺩﻭﻕ ﺍﻟﻤﺠﻤﻭﻋﺔ ﺤﻴﺙ ﻴﺅﻤﻥ ﻫﺫﺍ ﺍﻟﺼﻨﺩﻭﻕ‬
‫ﺭﺒﻁﹰﺎ ﺒﻴﻥ ﺃﺯﺭﺍﺭ ﺍﻟﺭﺍﺩﻴﻭ ﺒﺩﺍﺨﻠﻪ ﻓﻘﻁ ﺩﻭﻥ ﺍﻟﺘﺄﺜﻴﺭ ﻋﻠﻰ ﺃﺯﺭﺍﺭ ﺍﻟﺭﺍﺩﻴﻭ ﺨﺎﺭﺠﻪ ‪ ،‬ﻜﻤﺎ ﻴﻭﻀﺢ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫ﺃﻀﻑ ﺼﻨﺩﻭﻕ ﻤﺠﻤﻭﻋﺔ ﻟﻠﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﻭﻀﻊ ﻋﻠﻴﻪ ﺯﺭﻴﻥ ﺭﺍﺩﻴﻭ ﻜﻤﺎ ﻓﻲ ﺍﻟﺸﻜل‬
‫ﻭﺃﻀﻑ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻟﻠﺯﺭ ﺍﻷﻭل ﺩﺍﺨل ﺍﻟﺼﻨﺩﻭﻕ‬
‫;‪form1.Font.Color := clgreen‬‬

‫ﻭﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻟﻠﺯﺭ ﺍﻵﺨﺭ ‪:‬‬

‫‪form1.Font.Color := clyellow‬‬
‫‪17‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬

‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻷﺤﺩﺍﺙ ) ‪: ( Events‬‬

‫ﻼ ﻋﻠﻰ ﺍﻟﺤﺩﺙ ‪ OnClick‬ﻟﻠﺯﺭ‬
‫ﻴﻭﺠﺩ ﻟﻜل ﻋﻨﺼﺭ ﻓﻲ ﺩﻟﻔﻲ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻷﺤﺩﺍﺙ ﺍﻟﺘﻲ ﻴﻤﻜﻥ ﺃﻥ ﻴﻨﻔﺫﻫﺎ ‪ ،‬ﺘﻌﺭﻓﻨﺎ ﻤﺜ ﹰ‬
‫‪ ) Button‬ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻤﺭﺘﻴﻥ ﻋﻠﻰ ﺍﻟﺯﺭ ﻴﺘﻡ ﺘﻔﻌﻴل ﺍﻟﺤﺩﺙ ‪ Onclick‬ﻭﻴﻅﻬﺭ ﻤﻌﺎﻟﺞ ﺍﻟﺸﻴﻔﺭﺓ ﻟﻜﺘﺎﺒﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﻲ‬
‫ﺘﺒﻴﻥ ﻜﻴﻔﻴﺔ ﺘﻌﺎﻤل ﺍﻟﺒﺭﻨﺎﻤﺞ ﻤﻊ ﻫﺫﺍ ﺍﻟﺤﺩﺙ (‪،‬ﺴﻨﺘﻌﺭﻑ ﺍﻵﻥ ﻋﻠﻰ ﻤﺠﻤﻭﻋﺔ ﺠﺩﻴﺩﺓ ﻤﻥ ﺍﻷﺤﺩﺍﺙ‪.‬‬
‫‪ 1‬ـ ﺍﻟﺤﺩﺙ ‪ : OnMouseMove‬ﻴﻌﻤل ﻫﺫﺍ ﺍﻟﺤﺩﺙ ﻋﻥ ﻤﺭﻭﺭ ﺍﻟﻔﺄﺭﺓ ﻓﻭﻕ ﺍﻟﻌﻨﺼﺭ ﻭﻴﻌﻴﺩ ﺍﺤﺩﺍﺜﻴﺎﺕ ) ‪ ( x,y‬ﺍﻟﺫﻴﻥ‬
‫ﻴﺸﺭﻴﻥ ﻋﻠﻰ ﻤﻜﺎﻥ ﻭﺠﻭﺩ ﺍﻟﻔﺄﺭﺓ ﺤﻴﺙ ‪ X = left‬ﺃﻱ ﺒﻌﺩ ﺍﻟﻔﺄﺭﺓ ﻋﻥ ﺍﻟﻴﺴﺎﺭ‪ ،‬ﻭ ‪ y = top‬ﺃﻱ ﺒﻌﺩ ﺍﻟﻔﺄﺭﺓ ﻋﻥ ﺸﺭﻴﻁ‬
‫ﻋﻨﻭﺍﻥ ﺍﻟﻨﺎﻓﺫﺓ ﻭﻜﻤﺜﺎل ﻋﻠﻰ ﺫﻟﻙ ‪:‬‬
‫ﺃﻨﺸﺎﺀ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ ﻭﻀﻊ ﻋﻠﻰ ﻋﻨﺼﺭ ‪ Label‬ﺍﻷﻭل ﻓﻲ ﺍﻷﻋﻠﻰ ﻭﻓﻲ ﺃﻗﺼﻰ ﺍﻟﻴﻤﻴﻥ ﻭﺍﻟﺜﺎﻨﻲ ﻓﻲ ﺍﻷﺴﻔل ﻭﻓﻲ ﺃﻗﺼﻰ‬
‫ﺍﻟﻴﺴﺎﺭ ‪،‬ﻭﺍﻵﻥ ﺤﺩﺩ ﺍﻟﻨﻤﻭﺫﺝ ) ‪ ( Form1‬ﺍﺨﺘﺭ ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ﻭﺍﻨﺘﻘل ﺇﻟﻰ ﺍﻟﺼﻔﺤﺔ ‪ Event‬ﻭﺍﻀﻐﻁ ﻤﺭﺘﻴﻥ ﻋﻠﻰ‬
‫ﺍﻟﺨﺎﺼﺔ ‪ OnMouseMove‬ﻓﹸﻴﻅﻬﺭ ﻤﺤﺭﺭ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﺘﺎﺒﻊ ‪:‬‬
‫‪procedure TForm1.FormMouseMove(Sender: TObject; Shift: TShiftState; X,‬‬
‫;)‪Y: Integer‬‬
‫ﻟﻨﻜﺘﺏ ﺒﻴﻥ ﺍﻟﺴﻁﺭﻴﻥ ‪ Begin‬ﻭ‪ End‬ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;)‪label1.Caption := inttostr(x‬‬
‫;)‪label2.Caption := inttostr(y‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪.‬‬
‫‪ 2‬ـ ﺍﻟﺤﺩﺙ ‪ : OnMouseDown‬ﻴﻌﻤل ﻫﺫﺍ ﺍﻟﺤﺩﺙ ﻋﻥ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺍﻟﻔﺄﺭﺓ ﻭﻴﻌﻴﺩ ﺍﻹﺤﺩﺍﺜﻴﺎﺕ ﻜﻤﺎ ﻓﻲ ﺍﻟﺤﺩﺙ‬
‫ﺍﻟﺴﺎﺒﻕ ‪ ،‬ﻜﻤﺜﺎل ﻋﻠﻴﻪ ‪ :‬ﺤﺩﺩ ﺍﻟﻨﻤﻭﺫﺝ ) ‪ ( Form1‬ﻤﻥ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﺍﺨﺘﺭ ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ﻭﺍﻨﺘﻘل ﺇﻟﻰ ﺍﻟﺼﻔﺤﺔ‬
‫‪ Event‬ﻭﺍﻀﻐﻁ ﻤﺭﺘﻴﻥ ﻋﻠﻰ ﺍﻟﺨﺎﺼﺔ ‪ OnMouseDown‬ﻓﻴﻅﻬﺭ ﻤﺤﺭﺭ ﺍﻟﺸﻴﻔﺭﺓ ﺃﻜﺘﺏ ﻓﻴﻪ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪label1.Left := x‬‬
‫;‪label1.Top := y -10‬‬
‫;‪label2.Left := x+20‬‬
‫;‪label2.Top := y-10‬‬

‫‪18‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺘﻌﻤل ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻋﻠﻰ ﻭﻀﻊ ﻋﻨﺼﺭﻱ ﺍﻟﻌﻨﻭﺍﻥ ‪ Label‬ﻓﻲ ﻤﻜﺎﻥ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﻔﺄﺭﺓ ‪ ) ،‬ﺘﻡ ﺇﻀﺎﻓﺔ ﻭﻁﺭﺡ ﺍﻷﺭﻗﺎﻡ‬
‫ﻤﻥ ‪ X‬ﻭ ‪ y‬ﻓﻘﻁ ﻹﻅﻬﺎﺭ ﺍﻟﻨﺘﺎﺌﺞ ﺒﺸﻜل ﺃﻓﻀل ( ‪.‬‬
‫‪ 5‬ـ ﺍﻟﺤﺩﺙ ‪ : OnMouseLeave‬ﻴﻌﻤل ﻫﺫﺍ ﺍﻟﺤﺩﺙ ﻋﻨﺩ ﺍﺒﺘﻌﺎﺩ ﺍﻟﻔﺄﺭﺓ ﻋﻥ ﺍﻟﻌﻨﺼﺭ ‪:‬‬
‫ﺃﻀﻑ ﻋﻨﺼﺭ ‪ Label‬ﺠﺩﻴﺩ ﺇﻟﻰ ﺍﻟﺸﻜل ﺍﻟﺴﺎﺒﻕ ﻭﺤﺩﺩ ﺍﻟﺤﺩﺙ ‪ OnMouseMove‬ﻟﻬﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻭﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ‬
‫;‪label3.font.color := clblue‬‬ ‫ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬
‫ﺜﻡ ﺤﺩﺩ ﺍﻟﺤﺩﺙ ‪ OnMouseLeave‬ﻭﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪Label3.font.color := clblack‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻻﺤﻅ ﺃﻨﻪ ﻋﻨﺩ ﻤﺭﻭﺭ ﺍﻟﻔﺄﺭﺓ ﻤﻥ ﻓﻭﻕ ﺍﻟﻌﻨﺼﺭ ‪ Label3‬ﻴﺘﺤﻭل ﺇﻟﻰ ﺍﻟﻠﻭﻥ ﺍﻷﺯﺭﻕ ﺜﻡ ﻴﻌﻭﺩ ﺇﻟﻰ ﻟﻭﻨﻪ‬
‫ﺍﻷﺴﻭﺩ ﻋﻥ ﻤﻐﺎﺩﺭﺓ ﺍﻟﻔﺄﺭﺓ ﻟﻪ‪.‬‬
‫‪ 4‬ـ ﺍﻟﺤﺩﺙ ‪ : On DblClick‬ﻴﻌﻤل ﻫﺫﺍ ﺍﻟﺤﺩﺙ ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻤﺭﺘﻴﻥ ﻋﻠﻰ ﺍﻟﻌﻨﺼﺭ ‪:‬‬
‫;‪Close‬‬ ‫ﺤﺩﺩ ﺍﻟﻌﻨﺼﺭ ‪ Label3‬ﺜﻡ ﺃﺨﺘﺭ ﺍﻟﺤﺩﺙ ‪ On DblClick‬ﻭﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪:‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﻀﻐﻁ ﻤﺭﺘﻴﻥ ﻋﻠﻰ ﺍﻟﻌﻨﺼﺭ ‪ Label3‬ﻟﻠﺨﺭﻭﺝ ﻤﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪.‬‬

‫‪19‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ﺍﻟﺭﺍﺒﻌﺔ‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻭﺍﺠﻬﺔ ﺍﻟﺩﻟﻔﻲ ‪:‬‬
‫‪ 1‬ـ ﺇﻀﺎﻓﺔ ﻋﺩﺓ ﻨﺴﺦ ﻤﻥ ﺍﻟﻌﻨﺼﺭ ﻨﻔﺴﻪ ‪:‬‬
‫ﻴﻤﻜﻥ ﺇﻀﺎﻓﺔ ﻋﺩﺓ ﻨﺴﺦ ﻤﻥ ﺍﻟﻌﻨﺼﺭ ﻨﻔﺴﻪ ﻭﺫﻟﻙ ﺒﺎﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﻤﻔﺘﺎﺡ ‪ Shift‬ﻤﻥ ﻟﻭﺤﺔ ﺍﻟﻤﻔﺎﺘﻴﺢ ﻭﺇﺒﻘﺎﺅﻩ ﻤﻀﻐﻭﻁﹰﺎ‬
‫ﺤﺘﻰ ﻨﺨﺘﺎﺭ ﺍﻟﻌﻨﺼﺭ ﺍﻟﻤﺭﺍﺩ ﺇﻀﺎﻓﺘﻪ ﻤﻥ ﻟﻭﺤﺔ ﺍﻟﻌﻨﺎﺼﺭ‪ ،‬ﻋﻨﺩﺌ ٍﺫ ﻴﻅﻬﺭ ﻤﺭﺒﻊ ﺃﺯﺭﻕ ﻴﺤﻴﻁ ﺒﺄﻴﻘﻭﻨﺔ ﺍﻟﻌﻨﺼﺭ ﻀﻤﻥ ﻟﻭﺤﺔ‬
‫ﺍﻟﻌﻨﺎﺼﺭ ‪ ،‬ﻨﻨﻘﺭ ﺍﻵﻥ ﻓﻭﻕ ﺍﻟﻨﻤﻭﺫﺝ ﻟﻴﻅﻬﺭ ﺍﻟﻌﻨﺼﺭ ﻭﻓﻲ ﻜل ﻤﺭﺓ ﻨﻨﻘﺭ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺘﻅﻬﺭ ﻨﺴﺨﺔ ﺃﺨﺭﻯ ﻤﻥ ﺍﻟﻌﻨﺼﺭ‬
‫ﻨﻔﺴﻪ ‪ ،‬ﻹﻴﻘﺎﻑ ﺍﻟﻌﻤﻠﻴﺔ ﻨﻀﻐﻁ ﺃﻴﻘﻭﻨﺔ ﺍﻟﻤﺅﺸﺭ ﻀﻤﻥ ﻟﻭﺤﺔ ﺍﻟﻌﻨﺎﺼﺭ ﻟﻴﺨﺘﻔﻲ ﺍﻟﺼﻨﺩﻭﻕ ﺍﻷﺯﺭﻕ ﺤﻭل ﺍﻟﻌﻨﺼﺭ ‪ ،‬ﻜﻤﺜﺎل‬
‫ﻋﻠﻰ ﺫﻟﻙ ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﻌﻨﺼﺭ ‪ Label‬ﺒﻤﺅﺸﺭ ﺍﻟﻔﺄﺭﺓ ﻤﻊ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﻤﻔﺘﺎﺡ ‪ shift‬ﺍﻨﻘل ﺍﻟﻔﺄﺭﺓ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ‬
‫ﻭﺍﻀﻐﻁ ﻋﺩﺓ ﻤﺭﺍﺕ ‪.‬‬
‫‪ 2‬ـ ﺍﻟﺘﺤﻜﻡ ﺒﻤﻜﺎﻥ ﺍﻟﻌﻨﺼﺭ ﻭﺤﺠﻤﻪ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﻤﻥ ﻟﻭﺤﺔ ﺍﻟﻤﻔﺎﺘﻴﺢ ‪:‬‬
‫ﻜﻤﺎ ﺭﺃﻴﻨﺎ ﻴﻤﻜﻥ ﺍﻟﺘﺤﻜﻡ ﺒﻬﺫﻩ ﺍﻟﺨﻭﺍﺹ ﺒﺩﻗﺔ ﻋﻥ ﻁﺭﻴﻕ ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ﻭﻟﻜﻥ ﻫﻨﺎﻙ ﻁﺭﻴﻘﺔ ﺃﺨﺭﻯ ﻭﻤﻔﻴﺩﺓ ﻟﻠﺘﺤﻜﻡ ﺒﻬﺫﻩ‬
‫ﺍﻟﺨﻭﺍﺹ ‪.‬‬
‫ﺃ ـ ﺘﺤﺭﻴﻙ ﺍﻟﻌﻨﺼﺭ ‪:‬‬
‫ﺃﺨﺘﺭ ﺍﻟﻌﻨﺼﺭ ﺍﻟﻤﺭﺍﺩ ﺘﺤﺭﻴﻜﻪ ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﻤﻔﺎﺘﺢ ‪ + Ctrl‬ﺃﺯﺭﺍﺭ ﺍﻷﺴﻬﻡ ﻓﺴﻴﺘﻡ ﻨﻘل ﺍﻟﻌﻨﺼﺭ ﺒﺎﺘﺠﺎﻩ ﺍﻟﺴﻬﻡ ﺍﻟﻤﻀﻐﻭﻁ‬
‫‪ ،‬ﻭﻟﺘﺤﺭﻴﻙ ﺍﻟﻌﻨﺼﺭ ﺒﺴﺭﻋﺔ ﺃﻜﺒﺭ ﺃﺴﺘﺨﺩﻡ ﺍﻷﺯﺭﺍﺭ ‪ + Ctrl + Shift‬ﺃﺯﺭﺍﺭ ﺍﻷﺴﻬﻡ ‪.‬‬
‫ﺏ ـ ﺘﻐﻴﺭ ﺤﺠﻡ ﺍﻟﻌﻨﺼﺭ ‪:‬‬
‫ﺍﺨﺘﺭ ﺍﻟﻌﻨﺼﺭ ﺍﻟﻤﺭﺍﺩ ﺘﻐﻴﺭ ﺤﺠﻤﻪ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﻤﻔﺘﺎﺡ ‪ + Shift‬ﺃﺯﺭﺍﺭ ﺍﻷﺴﻬﻡ ﻭﺴﻴﺘﻡ ﺍﻟﺘﻜﺒﻴﺭ ﺃﻭ ﺍﻟﺘﺼﻐﻴﺭ ﺤﺴﺏ‬
‫ﺍﻟﺴﻬﻡ ﺍﻟﻤﻀﻐﻭﻁ ‪.‬‬
‫‪ 3‬ـ ﺍﺨﺘﻴﺎﺭ ﺃﻜﺜﺭ ﻤﻥ ﻋﻨﺼﺭ ﻓﻲ ﻨﻔﺱ ﺍﻟﻭﻗﺕ ‪:‬‬
‫ﻴﻤﻜﻥ ﺃﻥ ﻨﺨﺘﺎﺭ ﺃﻜﺜﺭ ﻤﻥ ﻋﻨﺼﺭ ﻋﻠﻰ ﻨﻤﻭﺫﺝ ﻓﻲ ﻨﻔﺱ ﺍﻟﻭﻗﺕ ﻋﻠﻰ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﻌﻨﺼﺭ ﺍﻷﻭل ﻭﻤﻥ ﺜﻡ‬
‫ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺜﺎﻨﻲ ﻤﻊ ﻤﻔﺘﺎﺡ ‪ Shift‬ﻭﻫﻜﺫﺍ ‪ ، ...‬ﻭﻋﻨﺩ ﺘﻨﻔﻴﺫ ﻫﺫﻩ ﺍﻟﻌﻤﻠﻴﺔ ﺘﻅﻬﺭ ﻓﻲ ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ‬
‫ﺍﻟﺨﻭﺍﺹ ﺍﻟﻤﺸﺘﺭﻜﺔ ﻟﻠﻌﻨﺎﺼﺭ ﺍﻟﻤﺨﺘﺎﺭﺓ ) ﻋﻨﺩ ﺃﺨﺘﻴﺎﺭ ﻋﻨﺼﺭﻴﻥ ﺍﻷﻭل ‪ Label‬ﻭﺍﻟﺜﺎﻨﻲ ‪ Edit‬ﺴﺘﻅﻬﺭ ﺍﻟﺨﻭﺍﺹ‬
‫ﺍﻟﻤﺸﺘﺭﻜﺔ ﻤﺜل ‪ ، ... Width, Height, left, top,‬ﻭﺴﺘﺨﺘﻔﻲ ﺒﻌﺽ ﺍﻟﺨﻭﺍﺹ ﻤﺜل ‪( Caption, Text‬‬
‫ـ ﺭﺼﻑ ﺍﻟﻌﻨﺎﺼﺭ ‪:‬‬
‫ﻴﻤﻜﻨﻨﺎ ﺭﺼﻑ ﺍﻟﻌﻨﺎﺼﺭ ﻨﺴﺒﻴﹰﺎ ﻭﻓﻕ ﺒﻌﻀﻬﺎ ﺍﻟﺒﻌﺽ ‪ ،‬ﺃﻭ ﻨﺴﺒﻴﹰﺎ ﻭﻓﻕ ﺍﻟﺸﻜل ﻭﺫﻟﻙ ﻤﻥ ﺨﻼل ﺍﺨﺘﻴﺎﺭ ﺍﻟﻌﻨﺼﺭ ﺍﻟﻤﺭﺍﺩ‬
‫ﺭﺼﻔﻪ ﻭﻤﻥ ﺜﻡ ﺍﺴﺘﺨﺩﺍﻡ ﻟﻭﺤﺔ ﺍﻟﺭﺼﻑ ‪ Alignment palette‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪ View‬ﺃﻭ ‪ Alignment‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ‬
‫‪: Edit‬‬
‫ﺃ ـ ﻟﻭﺤﺔ ﺍﻟﺭﺼﻑ ‪: Alignment palette‬‬
‫ﻜل ﺯﺭ ﻓﻲ ﻫﺫﻩ ﺍﻟﻠﻭﺤﺔ ﻟﻪ ﻤﻬﻤﺔ ﻤﺎ ﻭﺴﻴﺘﻡ ﺸﺭﺡ ﻜل ﻤﻨﻬﺎ ﻋﻠﻰ ﺤﺩﺓ ‪:‬‬
‫ﺘﺭﺼﻑ ﺠﻤﻴﻊ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﻤﺨﺘﺎﺭﺓ ﺇﻟﻰ ﺍﻟﺠﻬﺔ ﺍﻟﻴﺴﺎﺭﻴﺔ ﻷﻭل ﻋﻨﺼﺭ ﺘﻡ ﺍﺨﺘﻴﺎﺭﻩ‬
‫‪.‬‬
‫ﻨﻔﺱ ﺍﻟﻌﻤل ﺍﻟﺴﺎﺒﻕ ﻭﻟﻜﻥ ﺍﻟﺭﺼﻑ ﻴﺘﻡ ﻟﻠﺠﻬﺔ ﺍﻟﻴﻤﻴﻨﻴﺔ‬
‫‪20‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺘﺭﺼﻑ ﺍﻟﻌﻨﺎﺼﺭ ﺠﻤﻴﻊ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﻤﺨﺘﺎﺭﺓ ﺇﻟﻰ ﻤﻨﺘﺼﻑ ﺍﻟﻌﻨﺼﺭ ﺍﻷﻭل ﺍﻟﺫﻱ ﺘﻡ ﺍﺨﺘﻴﺎﺭﻩ ﺒﺸﻜل ﺃﻓﻘﻲ ) ﺘﺠﻌل‬
‫ﺠﻤﻴﻊ ﺍﻟﻌﻨﺎﺼﺭ ﻋﻠﻰ ﻋﻤﻭﺩ ﻭﺍﺤﺩ (‬
‫ﻨﻔﺱ ﻋﻤل ﺍﻟﺯﺭ ﺍﻟﺴﺎﺒﻕ ﻭﻟﻜﻥ ﺍﻟﺭﺼﻑ ﻴﺘﻡ ﺒﺸﻜل ﻋﻤﻭﺩﻱ‪)،‬ﺘﺠﻌل ﺠﻤﻴﻊ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﻤﺨﺘﺎﺭﺓ ﻋﻠﻰ ﺼﻑ ﻭﺍﺤﺩ(‪.‬‬
‫ﺘﻨﻘل ﺠﻤﻴﻊ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﻤﺨﺘﺎﺭﺓ ﺇﻟﻰ ﻭﺴﻁ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻷﺏ ﺒﺸﻜل ﺃﻓﻘﻲ ‪.‬‬
‫ﺘﻨﻘل ﺠﻤﻴﻊ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﻤﺨﺘﺎﺭﺓ ﺇﻟﻰ ﻭﺴﻁ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻷﺏ ﺒﺸﻜل ﻋﺎﻤﻭﺩﻱ ‪.‬‬
‫ﺘﺠﻌل ﺍﻟﻤﺴﺎﻓﺔ ﺒﻴﻥ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻷﻓﻘﻴﺔ ﻤﺘﺴﺎﻭﻴﺔ ) ﺘﺜﺒﺕ ﺍﻟﻌﻨﺼﺭ ﺍﻷﻭل ﻭﺍﻷﺨﻴﺭ ﻭﺘﺤﺭﻙ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﺘﻲ ﺒﻴﻨﻬﻤﺎ‬
‫ﻟﺘﺄﺨﺫ ﻤﺴﺎﻓﺎﺕ ﻤﺘﺴﺎﻭﻴﺔ ‪.‬‬
‫ﻨﻔﺱ ﺍﻟﺨﺎﺼﺔ ﺍﻟﺴﺎﺒﻘﺔ ﻟﻠﻌﻨﺎﺼﺭ ﺍﻟﻌﺎﻤﻭﺩﻴﺔ ‪.‬‬
‫ﺘﺤﺭﻴﻙ ﺍﻟﻌﻨﺎﺼﺭ ﺇﻟﻰ ﻨﻔﺱ ﺍﻟﻨﺎﺤﻴﺔ ﺍﻟﺴﻔﻠﻴﺔ ﻷﻭل ﻋﻨﺼﺭ ﺘﻡ ﺍﺨﺘﻴﺎﺭﻩ ‪.‬‬
‫ﺘﺤﺭﻴﻙ ﺍﻟﻌﻨﺎﺼﺭ ﺇﻟﻰ ﻨﻔﺱ ﺍﻟﻨﺎﺤﻴﺔ ﺍﻟﻌﻠﻭﻴﺔ ﻷﻭل ﻋﻨﺼﺭ ﺘﻡ ﺍﺨﺘﻴﺎﺭﻩ ‪.‬‬

‫ﺏ ـ ‪ : Alignment‬ﺃﺨﺘﺭ ‪ Align‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪ Edit‬ﺴﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫ﻋﻤل ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﻴﺸﺒﻪ ﻋﻤل ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺴﺎﺒﻘﺔ ﻭﻟﻜﻥ ﺘﻡ‬
‫ﺍﻻﺴﺘﻌﺎﻀﺔ ﻋﻥ ﺍﻷﻴﻘﻭﻨﺎﺕ ﺒﺄﺯﺭﺍﺭ ﺭﺍﺩﻴﻭ ﻟﻴﺘﻡ ﺍﻻﺨﺘﻴﺎﺭ‬
‫ﻤﻨﻬﺎ‪.‬‬

‫ﺘﺜﺒﻴﺕ ﻤﻭﻗﻊ ﺍﻟﻌﻨﺎﺼﺭ ‪:‬‬

‫ﺒﻌﺩ ﺃﻥ ﻨﻌﻁﻲ ﺍﻟﻌﻨﺎﺼﺭ ﻤﻭﺍﻗﻌﻬﺎ ﻴﻤﻜﻨﻨﺎ ﺘﺜﺒﻴﺕ ﻫﺫﻩ ﺍﻟﻤﻭﺍﻗﻊ ﻟﻜﻲ ﻻ ﺘﺘﺤﺭﻙ ﺍﻟﻌﻨﺎﺼﺭ ﺒﻁﺭﻴﻕ ﺍﻟﺨﻁﺄ ﻭﺫﻟﻙ ﻋﻥ ﻁﺭﻴـﻕ‬
‫ﺍﺨﺘﻴﺎﺭ ﺍﻟﻌﻨﺼﺭ ﻭﻤﻥ ﺜﻡ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻷﻤﺭ ‪ Lock Controls‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪ ، Edit‬ﻋﻨﺩﻫﺎ ﻟـﻥ ﻨـﺴﺘﻁﻴﻊ ﺘﺤﺭﻴـﻙ ﻫـﺫﻩ‬
‫ﺍﻟﻌﻨﺎﺼﺭ ﺤﺘﻰ ﻨﺨﺘﺎﺭ ﻨﻔﺱ ﺍﻷﻤﺭ ﻤﺭﺓ ﺃﺨﺭﻯ ‪.‬‬
‫ﻗﺹ ﻭﻨﺴﺦ ﻭﻟﺼﻕ ﺍﻟﻌﻨﺎﺼﺭ ‪:‬‬
‫ﻴﻤﻜﻥ ﻗﺹ ﺃﻭ ﻨﺴﺦ ﺍﻟﻌﻨﺎﺼﺭ ﻭﻟﺼﻘﻬﺎ ﻋﻠﻰ ﻨﻔﺱ ﺍﻟﻨﻤﻭﺫﺝ ﺃﻭ ﻋﻠﻰ ﻨﻤﻭﺫﺝ ﺁﺨﺭ ﻋﻥ ﻁﺭﻴﻕ ﺍﺨﺘﻴﺎﺭ ﺍﻟﻌﻨﺎﺼﺭ ﻭﻗﺼﻬﺎ ﺍﻭ‬
‫ﻨﺴﺨﻬﺎ ﻋﻥ ﻁﺭﻴﻕ ﺍﻷﻭﺍﻤﺭ ‪ Cut‬ﺃﻭ ‪ Copy‬ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ‪ Edit‬ﻭﻟﺼﻘﻬﺎ ﻋﻥ ﻁﺭﻴﻕ ﺍﻷﻤﺭ ‪ Paste‬ﻤﻥ ﻨﻔﺱ ﺍﻟﻘﺎﺌﻤﺔ ‪:‬‬
‫ﻤﻼﺤﻅﺔ ﺍﻟﻌﻨﺼﺭ ﺍﻟﻤﻠﺼﻕ ﻴﺄﺨﺫ ﺠﻤﻴﻊ ﺨﺼﺎﺌﺹ ﺍﻟﻌﻨﺼﺭ ﺍﻷﺼل ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺠﻤﻴﻊ ﺃﺤﺩﺍﺜﻪ ‪.‬‬
‫ﻋﻨﻭﺍﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪:‬‬
‫ﻴﻤﻜﻥ ﻭﻀﻊ ﻋﻨﻭﺍﻥ ﻟﻠﺒﺭﻨﺎﻤﺞ ) ﻋﻨﻭﺍﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻴﻅﻬﺭ ﻋﻠﻰ ﺸﺭﻴﻁ ﺍﻟﻤﻬﺎﻡ ﺒﻘﺭﺏ ﺃﻴﻘﻭﻨﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ( ﺃﺨﺘﺭ ﺍﻷﻤﺭ‬
‫‪ File Æ Options‬ﻭﺍﻨﺘﻘل ﺇﻟﻰ ﺍﻟﺼﻔﺤﺔ ﻭﺍﻨﺘﻘل ﺇﻟﻰ ﺍﻟﺼﻔﺤﺔ ‪، Application‬ﻭﺍﻜﺘﺏ ﻓـﻲ ﺍﻟﻘـﺴﻡ ‪Application‬‬
‫‪ setting‬ﻗﺭﺏ ‪ Title‬ﺍﻟﻨﺹ ﺍﻟﺫﻱ ﺘﺭﻴﺩ‪ ،‬ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻻﺤﻅ ﺍﻟﻌﻨﻭﺍﻥ ﻋﻠﻰ ﺸﺭﻴﻁ ﻤﻬﺎﻡ ﻭﻴﻨﺩﻭﺯ ‪.‬‬

‫‪21‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺃﻴﻘﻭﻨﺔ ﺒﺭﻨﺎﻤﺞ ‪:‬‬
‫ﺘﻌﻠﻤﻨﺎ ﺴﺎﺒﻘﹰﺎ ﺘﻐﻴﺭ ﺃﻴﻘﻭﻨﺔ ﻨﺎﻓﺫﺓ ) ﻨﻤﻭﺫﺝ ( ﻭﺴﻨﺘﻌﻠﻡ ﺍﻵﻥ ﺘﻐﻴﺭ ﺃﻴﻘﻭﻨﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ) ﺃﻴﻘﻭﻨﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻫﻲ ﻨﻔﺱ ﺃﻴﻘﻭﻨﺔ ﺍﻟﻤﻠﻑ‬
‫‪ EXE‬ﺍﻟﺫﻱ ﻴﻨﺘﺞ ﻋﻨﺩ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺘﻅﻬﺭ ﺃﻴﻘﻭﻨﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻋﻠﻰ ﺸﺭﻴﻁ ﺍﻟﻤﻬﺎﻡ ﻭﻓﻲ ﺃﻱ ﺍﺨﺘﺼﺎﺭ ﻴﻭﻀﻊ ﻟﻠﺒﺭﻨﺎﻤﺞ (‪،‬‬
‫ﻤﻥ ﻨﻔﺱ ﺍﻟﺼﻔﺤﺔ ﺍﻟﺴﺎﺒﻘﺔ ‪ Project Æ Options‬ﺍﻨﺘﻘل ﺇﻟﻰ ﺍﻟﺼﻔﺤﺔ ‪، Application‬ﺍﻀﻐﻁ ﻋﻠـﻰ ﺍﻟـﺯﺭ ‪Load‬‬
‫‪ Icon‬ﻭﺍﺨﺘﺭ ﺃﻴﻘﻭﻨﺔ ﺠﺩﻴﺩﺓ ﻟﻠﺒﺭﻨﺎﻤﺞ ) ﻴﻤﻜﻥ ﺍﺨﺘﻴﺎﺭ ﺃﻴﻘﻭﻨﺎﺕ ﻤﻥ ﺍﻟﻔﻬﺭﺱ‬
‫‪C:\Program Files\Common Files\Borland Shared\Images\Icons‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻻﺤﻅ ﺍﻟﻨﺘﺎﺌﺞ ‪.‬‬
‫ﺼﻨﺎﺩﻴﻕ ﺍﻟﺭﺴﺎﺌل ‪:‬‬
‫ﺃ ـ ﺍﻟﺼﻨﺩﻭﻕ ‪: ShowMessage‬‬
‫ﻴﺴﺘﺨﺩﻡ ﺍﻹﺠﺭﺍﺀ )‪ showmessage (S : string‬ﻹﻅﻬﺎﺭ ﺭﺴﺎﻟﺔ ﻟﻠﻤﺴﺘﺨﺩﻡ ﺤﻴﺙ ﺘﻅﻬﺭ ﻨﺎﻓﺫﺓ ﺼﻐﻴﺭﺓ ﺘﺤـﻭﻱ ﻨـﺹ‬
‫ﺍﻟﺭﺴﺎﻟﺔ ﻭﻋﻠﻰ ﺍﻟﺯﺭ ‪ Ok‬ﻓﻘﻁ ﻭﻴﻜﻭﻥ ﻋﻨﻭﺍﻥ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﻫﻭ ﺃﺴﻡ ﺍﻟﻤﻠـﻑ ﺍﻟﺘﻨﻔﻴـﺫﻱ ﻟﻠﺒﺭﻨـﺎﻤﺞ‬
‫ﻜﻤﺜﺎل ﻋﻠﻰ ﺫﻟﻙ ﺃﻨﺸﺄ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻴﻪ ‪ Button‬ﻭﺃﻀﻑ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻋﻨﺩ ﺤـﺩﺙ‬
‫ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪:‬‬
‫ﻼ ﺒﻜﻡ ﻤﻊ ﺩﻟﻔﻲ'(‪showmessage‬‬
‫;)'ﺃﻫ ﹰ‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﻟﺘﺸﺎﻫﺩ ﺼﻨﺩﻭﻕ ﺍﻟﺭﺴﺎﻟﺔ‬
‫ﺏ ـ ﺍﻟﺼﻨﺩﻭﻕ ‪: MessageDlg‬‬
‫ﻫﺫﺍ ﺍﻟﺼﻨﺩﻭﻕ ﻴﺸﺒﻪ ﺍﻟﺼﻨﺩﻭﻕ ﺍﻟﺴﺎﺒﻕ ﻭﻟﻜﻨﻪ ﻴﺘﻭﻗﻊ ﻤﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺃﻥ ﻴﻌﻴﺩ ﻗﻴﻤﻪ ﻟﻠﺒﺭﻨﺎﻤﺞ ﻤﻥ ﺨﻼل ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺃﺯﺭﺍﺭ‬
‫ﻫﺫﺍ ﺍﻟﺼﻨﺩﻭﻕ ﻓﺭﻀﹰﺎ ﺴﻴﻘﻭﻡ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒﺘﻨﻔﻴﺫ ﺘﻌﻠﻴﻤﺎﺕ ﻤﻌﻴﻨﺔ ﺇﺫﺍ ﻀﻐﻁ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Yes‬ﻭﺘﻌﻠﻴﻤﺎﺕ ﺃﺨﺭﻯ ﻓﻲ‬
‫ﺤﺎل ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ ، NO‬ﻴﺘﻡ ﺍﺴﺘﺩﻋﺎﺀ ﻫﺫﺍ ﺍﻟﺼﻨﺩﻭﻕ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﺘﺎﺒﻊ ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫‪Function MessageDlg(const Msg: string ; DlgType: TMsgDlgType; Buttons:‬‬
‫‪TMsgDlgButtons ; HelpCtx: Longint): Word‬‬
‫ﺤﻴﺙ ‪ : Msg‬ﻨﺹ ﺍﻟﺭﺴﺎﻟﺔ ﺍﻟﻤﻁﻠﻭﺏ ﺇﻅﻬﺎﺭﻫﺎ ‪.‬‬
‫‪ : Dlgtype‬ﺘﺤﺩﻴﺩ ﻨﻭﻉ ﻟﺼﻨﺩﻭﻕ ﺍﻟﺭﺴﺎﻟﺔ ﻭﻴﺄﺨﺫ ﺃﺤﺩﻯ ﺍﻟﻘﻴﻡ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ : mtWarning‬ﻴﻅﻬﺭ ﻓﻲ ﺼﻨﺩﻭﻕ ﺍﻟﺭﺴﺎﻟﺔ ﺃﻴﻘﻭﻨﺔ ﻋﻠﻰ ﺸﻜل ﻤﺜﻠﺙ ﺃﺼﻔﺭ ﻟﻪ ﺇﺸﺎﺭﺓ ﺘﻌﺠﺏ ‪.‬‬
‫‪ : mtError‬ﻴﻅﻬﺭ ﻓﻲ ﺼﻨﺩﻭﻕ ﺍﻟﺭﺴﺎﻟﺔ ﺃﻴﻘﻭﻨﺔ ﻋﻠﻰ ﺸﻜل ﺩﺍﺌﺭﺓ ﺤﻤﺭﺍﺀ ﺩﺍﺨﻠﻬﺎ ﺇﺸﺎﺭﺓ × ‪.‬‬
‫ﺩﺍﺨﻠﻬﺎ ﺇﺸﺎﺭﺓ ﺘﻌﺠﺏ ‪.‬‬ ‫ﺸﻜل !‬ ‫‪ : mtInformation‬ﻴﻅﻬﺭ ﻓﻲ ﺼﻨﺩﻭﻕ ﺍﻟﺭﺴﺎﻟﺔ ﺃﻴﻘﻭﻨﺔ ﻋﻠﻰ‬
‫ﺩﺍﺨﻠﻬﺎ ﺇﺸﺎﺭﺓ ? ‪.‬‬ ‫ﺸﻜل‬
‫!‬ ‫‪ : mtConfirmation‬ﻴﻅﻬﺭ ﻓﻲ ﺼﻨﺩﻭﻕ ﺍﻟﺭﺴﺎﻟﺔ ﺃﻴﻘﻭﻨﺔ ﻋﻠﻰ‬
‫‪ : mtCustom‬ﻻ ﻴﻅﻬﺭ ﻓﻲ ﺼﻨﺩﻭﻕ ﺍﻟﺭﺴﺎﻟﺔ ﺃﻴﻘﻭﻨﺔ ‪.‬‬
‫ﻴﻌﺘﻤﺩ ﻨﻭﻉ ﺼﻨﺩﻭﻕ ﺍﻟﺭﺴﺎﻟﺔ ﻋﻠﻰ ﻨﻭﻉ ﺍﻟﺭﺴﺎﻟﺔ ﺍﻟﻤﺭﺍﺩ ﺇﻅﻬﺎﺭﻫﺎ ﻟﻠﻤﺴﺘﺨﺩﻡ ﻫل ﻫـﻲ ﻟﻠﺘﻨﺒﻴـﻪ ﺃﻭ ﻹﻋـﻼﻡ ﺍﻟﻤـﺴﺘﺨﺩﻡ‬
‫ﺒﺤﺼﻭل ﺨﻁﺄ ﻤﺎ ﺃﻭ ﺇﻋﻁﺎﺀﻩ ﻤﻌﻠﻭﻤﺔ ﺠﺩﻴﺩﺓ ‪. ....‬‬
‫‪: Buttons‬‬
‫ﺘﺤﺩﺩ ﺍﻷﺯﺭﺍﺭ ﺍﻟﺘﻲ ﺴﺘﻅﻬﺭ ﻓﻲ ﺼﻨﺩﻭﻕ ﺍﻟﺭﺴﺎﻟﺔ ﻭﺘﺄﺨﺫ ﺍﻟﻘﻴﻡ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫‪22‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪mbYes,mbNo,mbOK,mbCancel,mbAbort,mbRetry,mbIgnore,mbAll,mbNoToAll,mbYesT‬‬
‫‪oAll, mbHelp‬‬
‫ﺘﻭﻀﻊ ﺍﻷﺯﺭﺍﺭ ﺒﻴﻥ ﻗﻭﺴﻴﻥ ] [ ﻭﺘﻭﻀﻊ ﺒﻴﻨﻬﻤﺎ ﻓﺎﺼﻠﺔ ‪.‬‬
‫‪ :HelpCtx‬ﺘﻭﻀﻊ ﻓﻴﻪ ﺭﻗﻡ ﺍﻟﺴﻁﺭ ﻓﻲ ﻤﻠﻑ ﺍﻟﻤﺴﺎﻋﺩﺓ ﺍﻟﻤﺭﺘﺒﻁ ﻤﻊ ﺍﻟﺯﺭ ) ﺴﻴﺸﺭﺡ ﻤﻠﻑ ﺍﻟﻤﺴﺎﻋﺩﺓ ‪ *.HLP‬ﻻﺤﻘﹰﺎ (‪.‬‬
‫ﻴﻌﻴﺩ ﺍﻟﺘﺎﺒﻊ ﻗﻴﻤﺔ ﺘﺘﺒﻊ ﻟﻠﺯﺭ ﺍﻟﺫﻱ ﻀﻐﻁ ﻋﻠﻴﻪ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺤﺴﺏ ﺍﻟﺠـﺩﻭل‬
‫‪mbOK‬‬ ‫‪mrOk‬‬
‫‪mbCancel‬‬ ‫‪mrCancel‬‬ ‫ﺍﻟﺘﺎﻟﻲ ‪ :‬ﺃﻱ ﺃﻨﻪ ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ OK‬ﺴﻴﻌﻴﺩ ﺍﻟﺘﺎﺒﻊ ﺍﻟﻘﻴﻤﺔ ‪mrok‬‬
‫‪mbYes‬‬ ‫‪mrYes‬‬ ‫‪.‬‬
‫‪mbNo‬‬ ‫‪mrNo‬‬
‫ﻭﻫﻜﺫﺍ ‪.‬‬
‫‪mbAbort‬‬ ‫‪mrAbort‬‬
‫‪mbRetry‬‬ ‫‪mrRetry‬‬ ‫ﻤﺜﺎل ) ‪: ( 1‬‬
‫‪mbIgnore‬‬ ‫‪mrIgnore‬‬ ‫ﺃﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﻀﻊ ﻋﻠﻴﻪ ﺍﻟﺯﺭ ‪ Button‬ﻭﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴـﺔ‬
‫‪mbAll‬‬ ‫‪mrAll‬‬
‫‪mrNoToAll‬‬ ‫ﻋﻨﺩ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻴﻪ ‪:‬‬

‫‪mbNoToAll‬‬ ‫‪',mtConfirmation‬ﻫل ﺘﺭﻴﺩ ﺇﻏـﻼﻕ ﺍﻟﺒﺭﻨـﺎﻤﺞ'(‪if MessageDlg‬‬

‫‪mbYesToAll mrYesToAll‬‬ ‫;‪,[mbyes,mbno],0)= mryes then close‬‬
‫ﺘﻅﻬﺭ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺼﻨﺩﻭﻕ ﺍﻟﺘﺎﻟﻲ ﻤـﻊ‬
‫ﺤﺎل ﺘﻡ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ‪. Yes‬‬ ‫ﺍﻟﺯﺭﻴﻥ ‪ Yes‬ﻭ‪ No‬ﻭﺘﻐﻠﻕ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻓﻲ‬
‫ﻤﺜﺎل ‪: 2‬‬
‫ﻭﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻋﻨﺩ ﺤﺩﺙ ﺍﻟـﻀﻐﻁ‬ ‫ﺃﻀﻑ ﺯﺭ ﺠﺩﻴﺩ ﺇﻟﻰ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟـﺴﺎﺒﻕ‬
‫ﻋﻠﻴﻪ‪:‬‬
‫; )‪',mterror,[mball,mbyestoall,mbNoToAll,mbIgnore],0‬ﺘﺠﺭﺒﺔ ' (‪messagedlg‬‬
‫‪ 3‬ﺍﻟﺼﻨﺩﻭﻕ ‪: InputBox‬‬
‫ﻴﻅﻬﺭ ﻫﺫﺍ ﺍﻟﺼﻨﺩﻭﻕ ﻋﻠﻰ ﺸﻜل ﻨﺎﻓﺫﺓ ﻓﻴﻬﺎ ﻋﻨﺼﺭ ‪ Edit‬ﻤﻊ ﺍﻟﺯﺭﻴﻥ ‪ Ok‬ﻭ ‪ Cancel‬ﻭﻟﻪ ﺍﻟﺸﻜل ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫; ‪InputBox( const ACaption, APrompt, ADefault: string ): string‬‬
‫ﺤﻴﺙ ‪ : ACaption‬ﻫﻭ ﻋﻨﻭﺍﻥ ﺍﻟﺼﻨﺩﻭﻕ ‪.‬‬
‫‪ : Aprompt‬ﻨﺹ ﺍﻟﺭﺴﺎﻟﺔ ‪.‬‬
‫‪ : ADefault‬ﻗﻴﻤﺔ ﺍﻓﺘﺭﺍﻀﻴﺔ ﺘﻅﻬﺭ ﻓﻲ ﺍﻟﺼﻨﺩﻭﻕ ‪.‬‬
‫ﻴﻌﻴﺩ ﺍﻟﺘﺎﺒﻊ ﺍﻟﻨﺹ ﺍﻟﻤﺩﺨل ﻓﻲ ﺍﻟﻌﻨﺼﺭ ‪. Edit‬‬
‫ﻤﺜﺎل ‪ :‬ﺃﻀﻑ ﺯﺭ ﺠﺩﻴﺩ ﺇﻟﻰ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟﺴﺎﺒﻕ ﻭﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;)'ﺠﺩﻴﺩ '‪',‬ﺃﺩﺨل ﺃﺴﻤﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻟﻠﻨﻤﻭﺫﺝ'‪',‬ﺘﻐﻴﺭ ﻋﻨﻭﺍﻥ ﺍﻟﻨﻤﻭﺫﺝ'(‪form1.Caption := inputbox‬‬

‫‪23‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ﺍﻟﺨﺎﻤﺴﺔ‬

‫ﺍﻟﺘﻌﺭﻑ ﻋﻠﻰ ﻋﻨﺼﺭ ﺍﻟﻤﺫﻜﺭﺓ ‪: Memo‬‬

‫ﻴﺴﺘﺨﺩﻡ ﻋﻨﺼﺭ ﺍﻟﻤﺫﻜﺭﺓ ﻟﻜﺘﺎﺒﺔ ﻨﺹ ﻁﻭﻴل ) ﺃﻜﺜﺭ ﻤﻥ ‪ 256‬ﺤﺭﻑ ( ﻜﻤﺎ ﻴﻤﻜﻥ ﻓﻴﻪ ﻜﺘﺎﺒﺔ ﻨﺹ ﻤﻥ ﻋﺩﺓ ﺴﻁﻭﺭ ‪.‬‬
‫ﺘﺘﻡ ﺍﻟﻜﺘﺎﺒﺔ ﻓﻲ ﺍﻟﻤﺫﻜﺭﺓ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﺨﺎﺼﺔ ‪ Lines‬ﻓﻲ ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ‪،‬ﻜﻤﺎ ﻟﻬﺎ ﺒﻌـﺽ ﺍﻟﺨـﺼﺎﺌﺹ‬
‫ﺍﻟﻤﻬﻤﺔ ﻤﺜل ‪:‬‬
‫‪ : WordWrap‬ﻓﻲ ﺤﺎل ﻜﺎﻨﺕ ﻗﻴﻤﺔ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ‪ True‬ﻴﻘﻭﻡ ﺍﻟﻤﺅﺸﺭ ﺒﺎﻹﻨﺘﻘﺎل ﺇﻟﻰ ﺍﻟﺴﻁﺭ ﺍﻟﺘﺎﻟﻲ ﻋﻨـﺩ ﺍﻟﻭﺼـﻭل‬
‫ﺇﻟﻰ ﺁﺨﺭ ﺍﻟﺴﻁﺭ ﺍﻟﺤﺎﻟﻲ ‪.‬‬
‫‪Tab‬‬ ‫‪ : WantTabs‬ﻓﻲ ﺤﺎل ﻜﺎﻨﺕ ﻗﻴﻤﺔ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ‪ True‬ﻓﺈﻨﻪ ﺴﺘﺘﻡ ﺇﻀﺎﻓﺔ ‪ 6‬ﻓﺭﺍﻏﺎﺕ ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ‬
‫ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ‪.‬‬
‫‪ : Wantreturns‬ﻓﻲ ﺤﺎل ﻜﺎﻨﺕ ﻗﻴﻤﺔ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ‪ True‬ﺴﻴﺘﻡ ﺇﻀﺎﻓﺔ ﺴﻁﺭ ﺠﺩﻴﺩ ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪Enter‬‬
‫ﻭﺴﺘﺘﻡ ﺍﻟﻜﺘﺎﺒﺔ ﻋﻠﻰ ﺴﻁﺭ ﻭﺍﺤﺩ ﻓﻲ ﺤﺎل ﻗﻴﻤﺘﻬﺎ ‪. False‬‬
‫‪ : ReadOnly‬ﻓﻲ ﺤﺎل ﻜﺎﻨﺕ ﻗﻴﻤﺔ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ‪ True‬ﻻ ﻴﻤﻜﻥ ﺍﻟﻜﺘﺎﺒﺔ ﻓﻲ ﺍﻟﻌﻨﺼﺭ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ‪.‬‬
‫‪ : Alignment‬ﺘﻅﻬﺭ ﻁﺭﻴﻘﺔ ﻋﺭﺽ ﺍﻟﻨﺹ ﻓﻲ ﺍﻟﻤﺫﻜﺭﺓ ﻭﺘﺄﺨﺫ ﺇﺤﺩﻯ ﺍﻟﻘﻴﻡ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ : taRightJustify‬ﻴﻅﻬﺭ ﺍﻟﻨﺹ ﻓﻲ ﺍﻟﺠﻬﺔ ﺍﻟﻴﻤﻴﻨﻴﺔ) ﻓﻲ ﺤﺎل ﻜﺎﻨﺕ ﺍﻟﺨﺎﺼﺔ‬
‫(‬ ‫‪ BiDiMode‬ﺘﺴﺎﻭﻱ ‪bdRightToLeft‬‬
‫‪ : taLeftJustify‬ﻴﻅﻬﺭ ﺍﻟﻨﺹ ﻓﻲ ﺍﻟﺠﻬﺔ ﺍﻟﻴﺴﺎﺭﻴﺔ ) ﻓﻲ ﺤﺎل ﻜﺎﻨﺕ ﺍﻟﺨﺎﺼﺔ‬
‫(‬ ‫‪ BiDiMode‬ﺘﺴﺎﻭﻱ ‪bdRightToLeft‬‬
‫‪ : taCenter‬ﻴﻅﻬﺭ ﺍﻟﻨﺹ ﻓﻲ ﻭﺴﻁ ﺍﻟﻌﻨﺼﺭ ‪.‬‬
‫ﻤﺜﺎل ‪ :‬ﺃﻨﺸﺊ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﻋﻨﺼﺭ ﻤﺫﻜﺭﺓ ‪ Memo‬ﻭﺯﺭﻴﻥ ‪، Button‬ﺃﻋـﻁ ﺍﻟـﺯﺭ ﺍﻷﻭل ﺍﻟﺨﺎﺼـﺔ‬
‫‪" Caption‬ﺤﻔﻅ " ﻭﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﺒﻌﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻴﻪ ‪:‬‬
‫; )'‪Memo1.Lines.SaveToFile( 'c:\a.txt‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺤﻔﻅ ﺍﻟﻨﺹ ﺍﻟﻤﻜﺘﻭﺏ ﺩﺍﺨل ﻋﻨﺼﺭ ﺍﻟﻤﺫﻜﺭﺓ )ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ( ﺇﻟﻰ ﺍﻟﻤﻠﻑ ﺍﻟﻤﺤﺩﺩ ﺒﻴﻥ ﺍﻟﻘﻭﺴﻴﻥ ) ﻫﻨـﺎ‬
‫‪. ( a.txt‬‬
‫ﺃﻋﻁ ﺍﻟﺯﺭ ﺍﻟﺜﺎﻨﻲ ﺍﻟﺨﺎﺼﺔ ‪ " Caption‬ﻓﺘﺢ " ﻭﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﺒﻌﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻴﻪ ‪:‬‬
‫; )'‪Memo1.lines.LoadFromFile ('c:\a.txt‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺘﺤﻤﻴل ﺍﻟﻨﺹ ﻤﻥ ﺍﻟﻤﻠﻑ ) ﺍﻟﻤﺫﻜﻭﺭ ﺍﺴﻤﻪ ﺒﻴﻥ ﺍﻟﻘﻭﺴﻴﻥ ( ﺇﻟﻰ ﺍﻟﻤﺫﻜﺭﺓ ‪.‬‬
‫ﺍﻟﺘﻌﺭﻑ ﻋﻠﻰ ﻋﻨﺼﺭ ﺍﻟﺯﺭ ‪: Bitbtn‬‬
‫ﻴﺸﺒﻪ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻋﻨﺼﺭ ﺍﻟﺯﺭ ﺇﻟﻰ ﺤﺩ ﺒﻌﻴﺩ ﻭﻴﺨﺘﻠﻑ ﻋﻨﻪ ﻓﻲ ‪:‬‬
‫‪ 1‬ـ ﺇﻤﻜﺎﻨﻴﺔ ﺘﻐﻴﺭ ﻟﻭﻥ ﺨﻁ ﺍﻟﻌﻨﻭﺍﻥ ) ‪. ( Caption‬‬
‫‪ 2‬ـ ﺇﻤﻜﺎﻨﻴﺔ ﺇﻀﺎﻓﺔ ﺼﻭﺭﺓ ﻟﻬﺫﺍ ﺍﻟﺯﺭ ﻭﺫﻟﻙ ﻋﻥ ﻁﺭﻴﻕ ‪:‬‬
‫ﺃ ـ ﺍﻟﺼﻭﺭ ﺍﻻﻓﺘﺭﺍﻀﻴﺔ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪. Kind‬‬

‫‪24‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺏ ـ ﺍﻟﺨﺎﺼﺔ ‪ Glyph‬ﺍﻟﺘﻲ ﻴﻤﻜﻥ ﺃﻥ ﻨﺨﺘﺎﺭ ﻤﻨﻬﺎ ﺼﻭﺭﺓ ﻤﺎ ﻟﻠﺯﺭ ) ﻴﻭﺠﺩ ﺒﻌﺽ ﺼﻭﺭ ﻟﻸﺯﺭﺍﺭ ﻓﻲ ﺍﻟﻤﺠﻠﺩ‬
‫‪C:\Program Files\Common Files\Borland Shared\Images\Buttons‬‬
‫ﻴﻤﻜﻥ ﺘﻐﻴﺭ ﺼﻭﺭﺓ ﺍﻟﺯﺭ ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻴﻪ ﺒﺎﺨﺘﻴﺎﺭ ﺍﻟﺼﻭﺭﺓ ‪ Glyph‬ﻋﺒﺎﺭﺓ ﻋﻥ ﺜﻼﺙ ﺼﻭﺭ ﻤﺘﺠﺎﻭﺭﺓ ﺒﻨﻔﺱ ﺍﻟﺤﺠﻡ‬
‫ﻭﺘﻐﻴﺭ ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﺔ ‪ NumGlyph‬ﺇﻟﻰ ‪ ، 3‬ﺤﻴﺙ ﺘﻜﻭﻥ ﺍﻟﺼﻭﺭﺓ ﺍﻷﻭﻟﻰ ﻟﻠﺯﺭ‬ ‫ﻜﻤﺎ ﻓﻲ ﺍﻟﺼﻭﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻓﻲ ﺍﻟﻭﻀﻊ ﺍﻻﻓﺘﺭﺍﻀﻲ ﻭﺍﻟﺼﻭﺭﺓ ﺍﻟﺜﺎﻨﻴﺔ ﻓﻲ ﺤﺎﻟﺔ ﻜﺎﻨﺕ ﺍﻟﺨﺎﺼﺔ ‪ Enabeled‬ﺘﺴﺎﻭﻱ ‪ False‬ﻭﺍﻟﺼﻭﺭﺓ ﺍﻟﺜﺎﻟﺜﺔ ﺘﻅﻬﺭ‬
‫ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪.‬‬
‫ﺍﻟﺘﻌﺭﻑ ﻋﻠﻰ ﺍﻷﺯﺭﺍﺭ ﺍﻟﺴﺭﻴﻌﺔ ‪: SpeedButton‬‬
‫ﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻥ ﺃﺯﺭﺍﺭ ﺘﺴﺘﺨﺩﻡ ﻓﻲ ﺃﺸﺭﻁﺔ ﺍﻷﺩﻭﺍﺕ ﻭﻟﻬﺎ ﺨﺼﺎﺌﺹ ﺍﻟﺯﺭ ‪ BitBtn‬ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ 1‬ـ ‪ : Flat‬ﺘﻌﻁﻲ ﻤﻅﻬﺭ ﻤﺴﺘﻭﻱ ﻟﻠﺯﺭ ﻭﻴﺼﺒﺢ ﺍﻟﻤﻅﻬﺭ ﺜﻼﺜﻲ ﺍﻟﺒﻌﺩ ﻋﻨﺩ ﻤﺭﻭﺭ ﺍﻟﻔﺄﺭﺓ ﻓﻭﻗﻪ ‪.‬‬
‫‪ 2‬ـ ‪: GroupIndex‬ﻋﻨﺩ ﺇﻋﻁﺎﺀ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺃﺯﺭﺍﺭ ﺍﻟﺴﺭﻋﺔ ﻗﻴﻤﺔ ﻭﺍﺤﺩﺓ ﻟﻬﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺃﻜﺒﺭ ﻤﻥ ﺍﻟﺼﻔﺭ ﺘﻌﻤـل‬
‫ﻫﺫﻩ ﺍﻷﺯﺭﺍﺭ ﻜﺄﺯﺭﺍﺭ ﺍﻟﺭﺍﺩﻴﻭ ‪.‬‬
‫ﻤﺜﺎل ‪:‬‬
‫ﺃﻨﺸﺄ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺃﻟﻴﻪ ﺃﺭﺒﻊ ﺃﺯﺭﺍﺭ ‪ Speedbutton‬ﺃﻀﻑ ﻟﻜل ﺯﺭ ﺼﻭﺭﺓ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﺨﺎﺼﺔ ‪Glyph‬‬
‫ﻭﺃﻋﻁ ﺠﻤﻴﻊ ﺍﻷﺯﺭﺍﺭ ﺍﻟﺨﺎﺼﺔ ‪ GroupIndex‬ﺍﻟﻘﻴﻤﺔ ‪ ،1‬ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻻﺤﻅ ﺃﻨﻪ ﻻ ﻴﻤﻜﻥ ﻷﻜﺜﺭ ﻤﻥ ﺯﺭ ﻤﻥ ﻫـﺫﻩ‬
‫ﺍﻟﻤﺠﻤﻭﻋﺔ ﺃﻥ ﻴﻜﻭﻥ ﻤﻀﻐﻭﻁﹰﺎ ﻓﻲ ﻨﻔﺱ ﺍﻟﻭﻗﺕ ‪.‬‬
‫ﺃﻨﻭﺍﻉ ﺍﻟﻨﻤﺎﺫﺝ ) ‪ SDI‬ﻭ ‪: ( MDI‬‬
‫ﺘﻘﺴﻡ ﻜل ﻭﺍﺠﻬﺎﺕ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﺍﻟﺘﻲ ﻨﺼﻤﻤﻬﺎ ﺇﻟﻰ ﻨﻭﻋﻴﻥ ﻫﻤﺎ ‪ :‬ﻭﺍﺠﻬﺔ ﺍﻟﻭﺜﻴﻘﺔ ﺍﻟﻭﺍﺤﺩﺓ ‪ SDI‬ﺃﻱ ﺇﻅﻬﺎﺭ ﻨﺎﻓـﺫﺓ ﻭﺍﺤـﺩﺓ‬
‫ﻟﻠﺒﺭﻨﺎﻤﺞ ‪،‬ﻭﻭﺍﺠﻬﺔ ﺍﻟﻭﺜﺎﺌﻕ ﺍﻟﻤﺘﻌﺩﺩﺓ ‪ : MDI‬ﻭﺘﻌﺘﻤﺩ ﻋﻠﻰ ﻋﺩﺩ ﻤﻥ ﺍﻟﻨﻭﺍﻓﺫ ﺍﻷﺒﻨﺎﺀ ﺘﻅﻬﺭ ﻀﻤﻥ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻷﺏ ‪.‬‬
‫ﻴﻤﻜﻥ ﺘﺤﺩﻴﺩ ﻨﻭﻉ ﺍﻟﺘﻁﺒﻴﻕ ﺍﻟﺫﻱ ﻨﺼﻤﻤﻪ ﻤﻥ ﺨﻼل ﺍﻟﺨﺎﺼﺔ ‪ FormStyle‬ﻭﺍﻟﺘﻲ ﺘﺄﺨﺫ ﺇﺤﺩﻯ ﺍﻟﻘﻴﻡ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻤﻼﺤﻅﺎﺕ‬ ‫ﻋﻤﻠﻬﺎ‬ ‫‪FormStyle‬‬
‫ﻼ ﻭﺤﻴﺩﹰﺍ ﻤﻥ ﺍﻟﻨﻭﻉ ‪SDI‬‬
‫ﺘﻨﺸﺊ ﺸﻜ ﹰ‬ ‫‪fsNormal‬‬
‫ﻴﻤﻜﻥ ﻟﻬﺫﺍ ﺍﻟﺸﻜل ﺃﻥ ﻴﺤﺘﻭﻱ ﻋﻠﻰ‬ ‫ﻼ ﺃﺒﹰﺎ )ﺸﻜل ﺭﺌﻴﺴﻲ ﻟﻠﺘﻁﺒﻴﻕ(‬
‫ﺘﻨﺸﺊ ﺸﻜ ﹰ‬ ‫‪fsMDIForm‬‬
‫ﺃﺸﻜﺎل ﺃﺨﺭﻯ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ‪.‬‬
‫ﻼ ﻭﻟﺩﹰﺍ ‪ ،‬ﺃﻱ ﺸـﻜل ﺜـﺎﻨﻭﻱ ﻫﺫﺍ ﺍﻟﺸﻜل ﺴﻭﻑ ﻴﺤﺘﻭﻱ ﻤﻥ ﻗﺒل‬
‫ﺘﻨﺸﺊ ﺸﻜ ﹰ‬ ‫‪fsMDIChild‬‬
‫ﺍﻟﺸﻜل ﺍﻷﺏ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ‪.‬‬ ‫ﻤﺘﻌﻠﻕ ﺒﺸﻜل ﺁﺨﺭ‬
‫ﻼ ﻭﺤﻴﺩﹰﺍ ﻴﺒﻘﻰ ﻅـﺎﻫﺭﹰﺍ ﻓـﻲ‬
‫‪ fsStayOnTop‬ﺘﻨﺸﺊ ﺸﻜ ﹰ‬
‫ﺍﻷﻤﺎﻡ ﻤﻬﻤﺎ ﻜﺎﻨﺕ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﺍﻟﻤﻔﺘﻭﺤﺔ‬
‫ﻼ ﻭﻟﺩﹰﺍ ﺴﻨﻘﻭﻡ ﺒﻤﺎ ﻴﻠﻲ ‪:‬‬
‫ﻭﺤﺘﻰ ﻨﺸﺭﺡ ﻜﻴﻑ ﻴﺴﺘﻁﻴﻊ ﺍﻟﺸﻜل ﺍﻷﺏ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ MDI‬ﺃﻥ ﻴﺤﺘﻭﻱ ﺸﻜ ﹰ‬
‫‪ 1‬ـ ﻨﻨﺸﺊ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﻨﻌﻁﻲ ﺍﻟﺨﺎﺼﺔ ‪ Formstyle‬ﻟﻠﻨﻤﻭﺫﺝ ‪ Form1‬ﺍﻟﻘﻴﻤﺔ ‪. fsMDIForm‬‬
‫‪ 2‬ـ ﻨﻀﻴﻑ ﻨﻤﻭﺫﺝ ﺠﺩﻴﺩ ﻟﻠﻤﺸﺭﻭﻉ ﻭﻨﻌﻁﻲ ﺍﻟﺨﺎﺼﺔ ‪ Formstyle‬ﻟﻪ ﺍﻟﻘﻴﻤﺔ ‪. fsMDIChild‬‬
‫‪ 3‬ـ ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻻﺤﻅ ﺃﻥ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺜﺎﻨﻲ ﻴﻅﻬﺭ ﻀﻤﻥ ﺤﺩﻭﺩ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻷﻭل ﻭﻻ ﻴﻤﻜﻥ ﺘﺤﺭﻴﻜﻪ ﺨﺎﺭﺠﻪ ‪.‬‬

‫‪25‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻴﺸﺭﺡ ﺍﻟﺨﺎﺼﺔ ‪: fsStayOnTop‬‬
‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ Formstyle‬ﻟﻠﻨﻤﻭﺫﺝ ‪ Form1‬ﺍﻟﻘﻴﻤـﺔ ‪ ، fsStayOnTop‬ﻨﻔـﺫ ﺍﻟﺒﺭﻨـﺎﻤﺞ‬
‫ﻼ ﻓـﺘﺢ ﻨﺎﻓـﺫﺓ ﺠﻬـﺎﺯ‬
‫ﻭﻻﺤﻅ ﺃﻥ ﺍﻟﻨﺎﻓﺫﺓ ﺴﺘﻅﻬﺭ ﻋﻠﻰ ﺍﻟﺸﺎﺸﺔ ﻭﻻ ﻴﻤﻜﻥ ﻷﻱ ﻨﺎﻓﺫﺓ ﺃﺨﺭﻯ ﺍﻟﻅﻬﻭﺭ ﻓﻭﻗﻬﺎ ) ﺤﺎﻭل ﻤﺜ ﹰ‬
‫ﺍﻟﻜﻤﺒﻴﻭﺘﺭ ﺃﻭ ﻨﺎﻓﺫﺓ ﺴﻠﺔ ﺍﻟﻤﺤﺫﻭﻓﺎﺕ ﻭﻻﺤﻅ ﺃﻥ ﻫﺫﻩ ﺍﻟﻨﻭﺍﻓﺫ ﺴﺘﻅﻬﺭ ﺨﻠﻑ ﻨﺎﻓﺫﺓ ﺍﻟﺒﺭﻨﺎﻤﺞ ( ‪.‬‬

‫‪26‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺇﻨﺸﺎﺀ ﻗﻭﺍﺌﻡ ﻟﻠﻨﻤﺎﺫﺝ ‪:‬‬
‫ﺘﻌﻁﻲ ﺍﻟﻘﻭﺍﺌﻡ ﻁﺭﻴﻘﺔ ﺴﻬﻠﺔ ﻟﻠﻤﺴﺘﺨﺩﻡ ﻟﻠﻭﺼﻭل ﺇﻟﻰ ﻋﺩﺩ ﻤﻥ ﺍﻷﻭﺍﻤﺭ ﻭﻫﻨﺎﻙ ﻨﻭﻋﻴﻥ ﻤﻥ ﺍﻟﻘﻭﺍﺌﻡ‬
‫ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﺭﺌﻴﺴﻴﺔ ) ‪ ( Main Menu‬ﻭﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﻤﻨﺒﺜﻘﺔ ) ‪. ( Popup Menu‬‬
‫ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﺭﺌﻴﺴﻴﺔ )‪ : ( Main Menu‬ﻟﻠﻘﺎﺌﻤﺔ ﺍﻟﺭﺌﻴﺴﻴﺔ ﺍﻟﺸﻜل ﺍﻟﺘﺎﻟﻲ ‪:‬‬

‫ﻋﻨﺎﺻﺮ اﻟﻘﻮاﺋﻢ ﺿﻤﻦ ﺷﺮﻳﻂ اﻟﻘﻮاﺋﻢ‬

‫أواﻣﺮ اﻟﻘﺎﺋﻤﺔ‬

‫أﻣﺮ ﻳﻔﺘﺢ ﻗﺎﺋﻤﺔ ﻓﺮﻋﻴﺔ‬

‫ﻣﻔﺘﺎح ﺗﺴﺮﻳﻊ‬

‫اﺧﺘﺼﺎرات ﻟﻮﺣﺔ اﻟﻤﻔﺎﺗﻴﺢ‬

‫ﺷﺮﻳﻂ ﻓﺎﺻﻞ‬

‫ﻤﺜﺎل ‪:‬‬
‫‪ 1‬ـ ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﻋﻨﺼﺭ ‪ MainMenu‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪Standered‬‬
‫‪ 2‬ـ ﺍﻓﺘﺢ ﻤﺼﻤﻡ ﺍﻟﻘﻭﺍﺌﻡ ) ‪ ( Menu Desigenr‬ﻋﻥ ﻁﺭﻴﻕ ‪:‬‬
‫ﺍﻟﺨﺎﺼﺔ ‪ Items‬ﻤﻥ ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ﺃﻭ ﺍﻟﻀﻐﻁ ﻤﺭﺘﻴﻥ ﻋﻠﻰ ﻋﻨﺼﺭ ﺍﻟﻘﺎﺌﻤﺔ ﺃﻭ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﻌﻨﺼﺭ ﺒﺎﻟﺯﺭ‬
‫ﺍﻟﻴﻤﻴﻨﻲ‬
‫ﻭﺍﺨﺘﺭ ‪ Menu Desigenr‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ﻋﻨﺩ ﺫﻟﻙ ﺴﻴﻅﻬﺭ ﻤﺼﻤﻡ ﺍﻟﻘﻭﺍﺌﻡ ﻭﻓﻴﻪ ﻋﻨﺼﺭ ﻗﺎﺌﻤﺔ ) ‪Menu Item‬‬
‫( ﻓﺎﺭﻍ ﻤﻀﺎﺀ ﻭﺴﺘﻀﺎﺀ ﺃﻴﻀﹰﺎ ﺍﻟﺨﺎﺼﺔ ‪ Caption‬ﻀﻤﻥ ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ‪.‬‬
‫‪ 3‬ـ ﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ Caption‬ﺍﻟﻘﻴﻤﺔ ) &ﻤﻠﻑ ( ‪ :‬ﺴﺘﻼﺤﻅ ﻅﻬﻭﺭ ﻋﻨﺼﺭ ﺍﻟﻘﺎﺌﻤﺔ ﻤﻠﻑ ﻭﻅﻬﻭﺭ ﺨﻁ ﺼﻐﻴﺭ ﺘﺤـﺕ‬
‫ﺍﻟﺤﺭﻑ ﻡ ﻓﻲ ﻜﻠﻤﺔ ﻤﻠﻑ ﻭﺫﻟﻙ ﻷﻨﻨﺎ ﻭﻀﻌﻨﺎ ﺍﻟﺭﻤﺯ & ﻗﺒل ﻫﺫﺍ ﺍﻟﺤﺭﻑ ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪. Caption‬‬
‫‪ 4‬ـ ﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ Caption‬ﻟﻠﺯﺭ ﺍﻟﻅﺎﻫﺭ ﺘﺤﺕ ﻋﻨﺼﺭ ﺍﻟﻘﺎﺌﻤﺔ ﻤﻠﻑ ﺍﻟﻘﻴﻤﺔ ) &ﺠﺩﻴﺩ ( ‪.‬‬
‫‪ 5‬ـ ﻭﺴﻴﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺯﺭ ﺠﺩﻴﺩ ﺘﺤﺕ ﺍﻟﺯﺭ ﺍﻟﺴﺎﺒﻕ ﺃﻋﻁﻪ ‪& ) Caption‬ﻓﺘﺢ ( ‪.‬‬
‫‪ 6‬ـ ﺃﻋﻁ ﺍﻟـ ‪ Caption‬ﻟﻠﺯﺭ ﺍﻷﺨﻴﺭ ﺍﻟﻘﻴﻤﺔ – ﻭﺫﻟﻙ ﻹﻅﻬﺎﺭ ﺨﻁ ﻓﺎﺼل ﺒﻴﻥ ﺃﻭﺍﻤﺭ ﺍﻟﻘﺎﺌﻤﺔ ‪.‬‬

‫‪27‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ 7‬ـ ﺃﻋﻁ ﺍل ‪ Caption‬ﻵﺨﺭ ﺯﺭ ﻨﺎﺘﺞ ﺍﻟﻘﻴﻤﺔ & ﺇﻏﻼﻕ ‪.‬‬
‫‪ 8‬ـ ﺃﺨﺘﺭ ﻋﻨﺼﺭ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﻤﻭﺠﻭﺩ ﺒﺠﺎﻨﺏ ﺍﻟﻌﻨﺼﺭ ﻤﻠﻑ ﻭﺃﻋﻁﻪ ﺍﻟـ ‪& Caption‬ﺘﺤﺭﻴﺭ ‪.‬‬
‫‪ 9‬ـ ﺃﻋﻁ ﺍﻟﺯﺭ ﺍﻟﺫﻱ ﺘﺤﺘﻪ ﺍﻟـ ‪ Caption‬ﺍﻟﻘﻴﻤﺔ ﻨﺴﺦ‪ ،‬ﻭﺍﻟﺨﺎﺼﺔ ‪ Shortcut‬ﺍﻟﻘﻴﻤﺔ ‪ Ctrl + c‬ﻭﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ‬
‫ﺒﺘﻨﻔﻴﺫ ﻋﻤﻠﻴﺔ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﻋﻨﺼﺭ ﺍﻟﻘﺎﺌﻤﺔ ﻋﻨﺩ ﻁﺭﻴﻕ ﺍﺴﺘﺨﺩﺍﻡ ﻟﻭﺤﺔ ﺍﻟﻤﻔﺎﺘﻴﺢ ‪.‬‬
‫‪ 10‬ـ ﺃﻋﻁ ﺍﻟﺯﺭ ﺍﻟﺘﺎﻟﻲ ﺍﻟـ ‪ Caption‬ﻗﺹ ‪ ،‬ﻭﺍﻟﺨﺎﺼﺔ ‪ Shortcut‬ﺍﻟﻘﻴﻤﺔ ‪. Ctrl + X‬‬
‫‪ 11‬ـ ﺃﻋﻁ ﺍﻟﺯﺭ ﺍﻟﺘﺎﻟﻲ ﺍﻟـ ‪ Caption‬ﻟﺼﻕ ‪ ،‬ﻭﺍﻟﺨﺎﺼﺔ ‪ Shortcut‬ﺍﻟﻘﻴﻤﺔ ‪. Ctrl + V‬‬
‫ﺇﻨﺸﺎﺀ ﻗﺎﺌﻤﺔ ﻓﺭﻋﻴﺔ ﻟﻘﺎﺌﻤﺔ ﺭﺌﻴﺴﻴﺔ ‪:‬‬
‫‪ 12‬ـ ﺃﻋﻁ ﺍﻟﺯﺭ ﺍﻟﺫﻱ ﻴﻠﻲ ﺍﻟﺯﺭ ﻟﺼﻕ ﺍﻟــ ‪ Caption‬ﻨﻤـﻁ ﺍﻟﺨـﻁ ‪ ،‬ﺍﻀـﻐﻁ ﻋﻠﻴـﻪ ﺒـﺯﺭ ﺍﻟﻔـﺄﺭﺓ ﺍﻟﻴﻤﻴﻨـﻲ‬
‫ﻭﺍﺨﺘﺭ ‪ Create SubMenu‬ﺴﺘﻅﻬﺭ ﻋﻨﺩﺌﺫ ﻗﺎﺌﻤﺔ ﻓﺭﻋﻴﺔ ﺃﻋﻁ ﻓﻴﻬﺎ ﺍﻷﻭﺍﻤﺭ ﺍﻟﺜﻼﺙ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻏﺎﻤﻕ ‪ ،‬ﻤﺎﺌل ‪ ،‬ﺘﺤﺘﻪ ﺨﻁ ‪.‬‬
‫ﺍﻟﻌﻤل ﻤﻊ ﻋﻨﺎﺼﺭ ﺍﻟﻘﺎﺌﻤﺔ ‪:‬‬
‫‪ 1‬ـ ﻟﺤﺫﻑ ﻋﻨﺼﺭ ﻗﺎﺌﻤﺔ ﻨﺨﺘﺎﺭ ﺃﻱ ﻋﻨﺼﺭ ﻭﻨﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Delete‬ﺃﻭ ﻨﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻔـﺄﺭﺓ ﺍﻷﻴﻤـﻥ ﻭﻨﺨﺘـﺎﺭ‬
‫‪ Delete‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪.‬‬
‫‪ 2‬ـ ﻹﻀﺎﻓﺔ ﻋﻨﺼﺭ ﺠﺩﻴﺩ ﺒﻴﻥ ﻋﻨﺼﺭﻴﻥ ﻨﺨﺘﺎﺭ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺴﻔﻠﻲ ﻭﻨﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻷﻴﻤﻥ ﻭﻨﺨﺘـﺎﺭ ‪ Insert‬ﻤـﻥ‬
‫ﺍﻟﻘﺎﺌﻤﺔ ‪.‬‬
‫‪ 3‬ـ ﻟﺘﻐﻴﻴﺭ ﻤﻭﻗﻊ ﻋﻨﺼﺭ ﻗﺎﺌﻤﺔ ﺃﻭ ﻹﻋﺎﺩﺓ ﺘﺭﺘﻴﺏ ﻗﺎﺌﻤﺔ ﻨﺴﺤﺏ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺫﻱ ﻨﺭﻴﺩ ﻨﻘﻠﻪ ) ﻨﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻔـﺄﺭﺓ ﻋﻠـﻰ‬
‫ﺍﻟﻌﻨﺼﺭ ﻭﻨﺒﻘﻴﻪ ﻤﻀﻐﻭﻁﹰﺎ ( ﺜﻡ ﻨﺤﺭﺭ ﺯﺭ ﺍﻟﻔﺄﺭﺓ ﻟﻴﺘﻭﻀﻊ ﻓﻲ ﺍﻟﻤﻜﺎﻥ ﺍﻟﺠﺩﻴﺩ ‪.‬‬
‫‪ 4‬ـ ﻹﻅﻬﺎﺭ ﻋﻨﺎﺼﺭ ﻗﺎﺌﻤﺔ ﻤﺘﺠﺎﻭﺭﻴﻥ ﺃﻓﻘﻴﹰﺎ ﻨﻐﻴﺭ ﺍﻟﺨﺎﺼﺔ ‪ Break‬ﻷﻤﺭ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﻤﻁﻠﻭﺏ ﺇﻟﻰ ‪ mbBreak‬ﺃﻭ ﺇﻟـﻰ‬
‫‪mbBarBreak‬ﻭﺤﻴﺙ ﺘﻅﻬﺭ ﺍﻟﺜﺎﻨﻴﺔ ﺨﻁ ﻋﻤﻭﺩﻱ ﺒﻴﻥ ﺍﻷﻭﺍﻤﺭ ‪ ،‬ﻭﻹﻋﺎﺩﺓ ﺍﻟﻘﺎﺌﻤﺔ ﺇﻟﻰ ﺍﻟﺤﺎﻟـﺔ ﺍﻻﻓﺘﺭﺍﻀـﻴﺔ ﻨﺨﺘـﺎﺭ‬
‫‪. mbNone‬‬
‫ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﻋﻨﺼﺭ ﻗﺎﺌﻤﺔ ‪:‬‬
‫‪ 5‬ـ ﺘﺴﺘﺨﺩﻡ ﺍﻟﻘﻭﺍﺌﻡ ﻟﺘﻨﻔﻴﺫ ﺘﻌﻠﻴﻤﺎﺕ ﻤﻌﻴﻨﺔ ﻭﻟﻜﺘﺎﺒﺔ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻨﻀﻐﻁ ﻋﻠﻰ ﺍﻷﻤﺭ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﺃﻭ ﻨﺨﺘﺎﺭﻩ ﻭﻨـﻀﻐﻁ‬
‫ﻋﻠﻰ ﺍﻟﺤﺩﺙ ‪ OnClick‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪ Event‬ﻓﻲ ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ‪.‬‬
‫‪ 6‬ـ ﻏﺎﻟﺒﹰﺎ ﻤﺎ ﺘﺴﺘﺨﺩﻡ ﺍﻟﻘﻭﺍﺌﻡ ﻤﻊ ﺍﻟﺒﺭﺍﻤﺞ ﻤﺘﻌﺩﺩﺓ ﺍﻟﻭﺜﻴﻘﺔ ‪ MDI‬ﻭﻴﻤﻜﻥ ﺩﻤﺞ ﻗﻭﺍﺌﻡ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻷﺒﻥ ﻤﻊ ﻨﻭﺍﻓﺫ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻷﺏ‬
‫ﻭﺴﻨﺩﺭﺱ ﺫﻟﻙ ﻻﺤﻘﹰﺎ‪.‬‬
‫ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﻤﻨﺒﺜﻘﺔ ) ‪: ( Popup Menu‬‬
‫ﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻥ ﻗﺎﺌﻤﺔ ﺘﻅﻬﺭ ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﻤﻴﻨﻲ ﻭﻴﻤﻜﻥ ﺭﺒﻁﻬﺎ ﻤﻊ ﺍﻟﻨﻤـﻭﺫﺝ ﺃﻭ ﺃﻱ ﻋﻨـﺼﺭ ﺁﺨـﺭ‬
‫ﻭﺘﺼﻤﻴﻬﻤﺎ ﻤﺸﺎﺒﻪ ﻟﺘﺼﻤﻴﻡ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﺭﺌﻴﺴﻴﺔ ‪. Main Menu‬‬
‫ﻤﺜﺎل ‪:‬‬
‫ﺃﻀﻑ ﻋﻨﺼﺭﻱ ﻗﺎﺌﻤﺔ ﻤﻨﺒﺜﻘﺔ ‪ PopUpMenu‬ﺇﻟﻰ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ ﻭﺃﻀﻑ ﻋﻨﺼﺭ ‪ Panel‬ﻜﺫﻟﻙ ‪.‬‬
‫ﺃﻀﻑ ﺇﻟﻰ ﻋﻨﺼﺭ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻷﻭﻟﻰ ﺍﻷﻭﺍﻤﺭ ﺍﻟﺘﺎﻟﻴﺔ ‪ :‬ﺍﻷﻤﺭ ﺍﻷﻭل ‪ ،‬ﺍﻷﻤﺭ ﺍﻟﺜﺎﻨﻲ ‪ ،‬ﺍﻷﻤﺭ ﺍﻟﺜﺎﻟﺙ ‪.‬‬
‫ﺃﻀﻑ ﺇﻟﻰ ﻋﻨﺼﺭ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﺜﺎﻨﻴﺔ ﺍﻷﻭﺍﻤﺭ ﺍﻟﺘﺎﻟﻴﺔ ‪ :‬ﺍﻟﺭﺍﺒﻊ ‪ ،‬ﺍﻟﺨﺎﻤﺱ ‪.‬‬
‫ﻋﻠﻰ اﻷﻣﺮ اﻷول ﻣﻦ اﻟﻘﺎﺋﻤﺔ' 'اﻷوﻟﻰ‬
‫'ﻟﻘﺪ ﺿﻐﻄﺖ ‪28‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻷﻤﺭ ﺍﻷﻭل ﻭﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬
‫;) "‪Showmessage ( "you click the first button‬‬
‫ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻷﻤﺭ ﺍﻟﺜﺎﻨﻲ ﻭﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;) " ‪Showmessage ( "you click over the second button‬‬
‫ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺭﺍﺒﻊ ﻭﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫)"‪Showmessage ("you click over the third button‬‬
‫ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺨﺎﻤﺱ ﻭﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫) "‪Showmessage ("you click over the fifth button‬‬
‫ﺍﺨﺘﺭ ﺍﻟﺨﺎﺼﺔ ‪ PopUpMenu‬ﺍﻟﺘﺎﺒﻌﺔ ﻟﻠﻨﻤﻭﺫﺝ ﻭﺃﻋﻁﻬﺎ ﺍﻟﻘﻴﻤﺔ ‪. PopUpMenu1‬‬
‫ﺍﺨﺘﺭ ﺍﻟﺨﺎﺼﺔ ‪ PopUpMenu‬ﺍﻟﺘﺎﺒﻌﺔ ﻟﻠـ ‪ Panel‬ﻭﺃﻋﻁﻬﺎ ﺍﻟﻘﻴﻤﺔ ‪.PopUpMenu2‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻔﺎﺭﺓ ﺍﻷﻴﻤﻥ ﻋﻠﻰ ﻜل ﻤﻥ ﺍﻟﻨﻤﻭﺫﺝ ﻭﺍﻟـ ‪. Panel‬‬

‫ﺇﻀﺎﻓﺔ ﻤﻼﺤﻅﺎﺕ ﺇﻟﻰ ﺍﻟﺒﺭﻨﺎﻤﺞ )‪: ( Comments‬‬

‫ﻼ ﻓـﻲ‬
‫ﻴﺴﺘﺨﺩﻡ ﺍﻟﻤﺒﺭﻤﺞ ﺍﻟﻤﻼﺤﻅﺎﺕ ﻟﻴﺘﺫﻜﺭ ﻋﻤل ﻤﻘﻁﻊ ﺒﺭﻤﺠﻲ ﻤﺤﺩﺩ ‪ ،‬ﻭﻟﻴﺘﺭﻙ ﻓﻜﺭﺓ ﻋﻤﺎ ﻴﺭﻴﺩ ﺃﻥ ﻴﻁـﻭﺭﻩ ﻤـﺴﺘﻘﺒ ﹰ‬
‫ﺴﻁﻭﺭ ﺒﺭﻤﺠﻴﺔ ﻤﻌﻴﻨﻪ ‪.‬‬
‫ﻴﻤﻜﻥ ﺇﻀﺎﻓﺔ ﻤﻼﺤﻅﺎﺕ ﺇﻟﻰ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪:‬‬
‫‪ 1‬ـ } ﺃﻜﺘﺏ ﺃﻱ ﻨﺹ ﺘﺭﻴﺩﻩ ﺒﻴﻥ ﻫﺫﻴﻥ ﺍﻟﻘﻭﺴﻴﻥ ‪ ،‬ﻭﻴﻤﻜﻥ ﺃﻥ ﻴﻜﻭﻥ ﻋﻠﻰ ﻋﺩﺓ ﺃﺴﻁﺭ { ‪.‬‬
‫‪ 2‬ـ )* ﺃﻜﺘﺏ ﺃﻱ ﻨﺹ ﺘﺭﻴﺩﻩ ﺒﻴﻥ ﺇﺸﺎﺭﺘﻲ ﺍﻟﻘﻭﺱ ﻭﺍﻟﻨﺠﻤﺔ ‪ ،‬ﻭﻴﻤﻜﻥ ﺃﻥ ﻴﻜﻭﻥ ﻋﻠﻰ ﻋﺩﺓ ﺍﺴﻁﺭ *( ‪.‬‬
‫‪ 3‬ـ ‪ //‬ﺃﻜﺘﺏ ﺃﻱ ﻨﺹ ﺘﺭﻴﺩﻩ ﺒﻌﺩ ﻫﺫﻴﻥ ﺍﻹﺸﺎﺭﺘﻴﻥ ‪ ،‬ﺍﻟﻨﺹ ﻋﻠﻰ ﺴﻁﺭ ﻭﺍﺤﺩ ﻓﻘﻁ ‪.‬‬
‫ﻟﻜﺘﺎﺒﺔ ﺍﻟﻤﻼﺤﻅﺎﺕ ﻓﻲ ﺍﻟﻠﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ ‪ :‬ﺍﻀﻐﻁ ﺒﻤﺅﺸﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻷﻴﻤﻥ ﻓﻲ ﻭﺴﻁ ﻤﺤﺭﺭ ﺍﻟـﺸﻴﻔﺭﺓ ﻭﺍﺨﺘـﺭ ﻤـﻥ ﺍﻟﻘﺎﺌﻤـﺔ‬
‫‪ properties‬ﻓﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ‪ Property Editors‬ﺃﺨﺘﺭ ﻤﻨﻬﺎ ﺍﻟﺼﻔﺤﺔ ‪ Display‬ﻭﻏﻴﺭ ﺍﻟﺨﺎﺼﺔ ‪ Editor Font‬ﺇﻟﻰ‬
‫ﺍﻟﻘﻴﻤﺔ )‪ ، Courier New ( Arabic‬ﺍﻀﻐﻁ ﻋﻠﻰ ‪... Ok‬‬
‫ﺃﻨﻭﺍﻉ ﺍﻟﻤﻌﻁﻴﺎﺕ ‪:Data Types‬‬
‫ﺘﻤﻠﻙ ﻟﻐﺔ ﺒﺎﺴﻜﺎل ﺍﻟﻬﺩﻓﻴﺔ )‪ (Object Pascal‬ﻋﺩﺩﹰﺍ ﻤﻥ ﺃﻨﻭﺍﻉ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻤﺴﺒﻘﺔ ﺍﻟﺘﻌﺭﻴﻑ ﺒﺤﻴﺙ ﺘﻤﻜﻨﻨﺎ ﻤﻥ ﺍﻟﺘﺼﺭﻴﺢ‬
‫ﻤﺒﺎﺸﺭﺓ ﻋﻥ ﻤﺘﺤﻭﻻﺕ ﺘﻨﺘﻤﻲ ﻟﻬﺫﻩ ﺍﻷﻨﻭﺍﻉ‪ .‬ﻭﺍﻟﺠﺩﻭل ﺍﻟﺘﺎﻟﻲ ﻴﻌﺭﺽ ﺃﻨﻭﺍﻉ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻤﺴﺒﻘﺔ ﺍﻟﺘﻌﺭﻴﻑ ﻓﻲ ﻫﺫﻩ ﺍﻟﻠﻐﺔ‪:‬‬
‫ﺍﻷﻨﻭﺍﻉ ﺍﻟﺼﺤﻴﺤﺔ ‪:‬‬
‫ﻭﺼﻔﻬﺎ‬ ‫ﻨﻭﻉ ﺍﻟﻤﻌﻁﻴﺎﺕ‬
‫ﻫﻲ ﺃﻋﺩﺍﺩ ﺒﺩﻭﻥ ﻓﺎﺼﻠﺔ ﻋﺸﺭﻴﺔ‪ .‬ﺘﻘﻊ ﻫﺫﻩ ﺍﻷﻋﺩﺍﺩ ﻀﻤﻥ ﺍﻟﻤﺠﺎل ﻤﻥ ) ‪(2147483648-‬ﻭﺤﺘﻰ‬ ‫‪Integer‬‬
‫)‪ ، (2147483647‬ﻭﺘﺘﻁﻠﺏ ﺃﺭﺒﻊ ﺒﺎﻴﺘﺎﺕ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ ﻟﺘﺨﺯﻴﻨﻬﺎ ) ﻜﺎﻥ ﺤﺠﻤﻪ ﻓﻲ ﺘﺭﺒﻭ ﺒﺎﺴﻜﺎل‬
‫‪ 2‬ﺒﺎﻴﺕ ( ﻟﺫﻟﻙ ﻟﻴﺱ ﻤﻥ ﺍﻟﻀﺭﻭﺭﻱ ﺍﻥ ﺘﺘﻁﺎﺒﻕ ﺃﻨﻭﺍﻉ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺒﻴﻥ ﺩﻟﻔﻲ ﻭ ﺘﺭﺒﻭ ﺒﺎﺴﻜﺎل( ‪.‬‬
‫ﻫﻲ ﺃﻋﺩﺍﺩ ﺒﺩﻭﻥ ﻓﺎﺼﻠﺔ ﻋﺸﺭﻴﺔ‪ .‬ﺘﻘﻊ ﻓﻲ ﺍﻟﻤﺠﺎل ﺒﻴﻥ )‪ (128-‬ﻭﺤﺘﻰ)‪ (127‬ﻭﺘﺘﻁﻠﺏ ﺒﺎﻴﺘ ﹰﺎ ﻭﺍﺤﺩﹰﺍ‬ ‫‪Shortint‬‬
‫ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ ‪.‬‬
‫ﻭﻫﻲ ﺃﻋﺩﺍﺩ ﺒﺩﻭﻥ ﻓﺎﺼﻠﺔ ﻋﺸﺭﻴﺔ ﻭﺘﻘﻊ ﻓﻲ ﺍﻟﻤﺠﺎل ﺒﻴﻥ )‪(32768-‬ﻭﺤﺘﻰ )‪ (32767‬ﻭﺘﺘﻁﻠﺏ‬ ‫‪Smallint‬‬
‫‪29‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺒﺎﻴﺘﻴﻥ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ ﻟﺘﺨﺯﻴﻨﻬﺎ‬
‫ﻫﻲ ﺃﻋﺩﺍﺩ ﺒﺩﻭﻥ ﻓﺎﺼﻠﺔ ﻋﺸﺭﻴﺔ‪ ،‬ﻭﺘﻘﻊ ﻓﻲ ﺍﻟﻤﺠﺎل ﺒﻴﻥ)‪(-2147483648‬ﻭﺤﺘﻰ‬ ‫‪Longint‬‬
‫)‪(2147483647‬ﻭﺘﺘﻁﻠﺏ ﺃﺭﺒﻊ ﺒﺎﻴﺘﺎﺕ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ ﻟﺘﺨﺯﻴﻨﻬﺎ‬
‫ﻫﻲ ﺃﻋﺩﺍﺩ ﺒﺩﻭﻥ ﻓﺎﺼﻠﺔ ﻋﺸﺭﻴﺔ ﻭﺒﺩﻭﻥ ﺇﺸﺎﺭﺓ ﺘﻘﻊ ﻓﻲ ﺍﻟﻤﺠﺎل ﺒﻴﻥ )‪ (0‬ﻭﺤﺘﻰ )‪(225‬ﻭﺘﺘﻁﻠﺏ‬ ‫‪Byte‬‬
‫ﺒﺎﻴﺘﹰﺎ ﻭﺍﺤﺩﹰﺍ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ ‪.‬‬
‫ﻫﻲ ﺃﻋﺩﺍﺩ ﺒﺩﻭﻥ ﻓﺎﺼﻠﺔ ﻋﺸﺭﻴﺔ ﻭﺒﺩﻭﻥ ﺇﺸﺎﺭﺓ ﻭﺘﻘﻊ ﻓﻲ ﺍﻟﻤﺠﺎل ﺒﻴﻥ )‪(0‬ﻭﺤﺘﻰ)‪(65535‬ﻭﺘﺤﺘﺎﺝ‬ ‫‪Word‬‬
‫ﺒﺎﻴﺘﻴﻥ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ‪.‬‬
‫ﻭﻫﻲ ﺃﻋﺩﺍﺩ ﺒﺩﻭﻥ ﻓﺎﺼﻠﺔ ﻋﺸﺭﻴﺔ ﻭﺒﺩﻭﻥ ﺇﺸﺎﺭﺓ ﻭﺘﻘﻊ ﻓﻲ ﺍﻟﻤﺠﺎل ﺒﻴﻥ)‪ (0‬ﻭﺤﺘﻰ‬ ‫‪Cardinal‬‬
‫)‪ (2147483647‬ﻭﺘﺤﺘﺎﺝ ﺃﺭﺒﻊ ﺒﺎﻴﺘﺎﺕ ﻟﺘﺨﺯﻴﻨﻬﺎ‪.‬‬
‫ﻭﻫﻲ ﺃﻋﺩﺍﺩ ﺒﺩﻭﻥ ﻓﺎﺼﻠﺔ ﻋﺸﺭﻴﺔ ﻭﺘﻘﻊ ﻀﻤﻥ ﺍﻟﻤﺠﺎل ) ‪ ( -2*1063‬ﻭﺤﺘﻰ ﺍﻟﻤﺠﺎل ) ‪2*1063-1‬‬ ‫‪Int64‬‬
‫( ﻭﺘﺤﺘﺎﺝ ﺇﻟﻰ ﺜﻤﺎﻥ ﺒﺎﻴﺘﺎﺕ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ‬

‫ﺍﻷﻨﻭﺍﻉ ﺍﻟﺤﻘﻴﻘﻴﺔ‬
‫ﻫﻲ ﺃﻋﺩﺍﺩ ﺘﺤﺘﻭﻱ ﻓﺎﺼﻠﺔ ﻋﺸﺭﻴﺔ ﻭﺠﺯﺀﹰﺍ ﻋﺸﺭﻴﹰﺎ ﻓﻴﻪ ) ‪ ( 7‬ﺃﻭ ) ‪ ( 8‬ﺃﺭﻗﺎﻡ ﻭﺘﻘﻊ ﻓـﻲ ﺍﻟﻤﺠـﺎل‬ ‫‪Single‬‬
‫ﻤﻥ ‪ 1.5* 10-45‬ﻭﺤﺘﻰ ‪ 3.4*1038‬ﻭﺘﺤﺘﺎﺝ ﺇﻟﻰ ﺃﺭﺒﻊ ﺒﺎﻴﺘﺎﺕ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ‬
‫ﻫﻲ ﺃﻋﺩﺍﺩ ﺘﺤﺘﻭﻱ ﻓﺎﺼﻠﺔ ﻋﺸﺭﻴﺔ ﻭﺠﺯﺀﹰﺍ ﻋﺸﺭﻴﹰﺎ ﻓﻴﻪ ) ‪ ( 11‬ﺃﻭ ) ‪ ( 12‬ﻭﺘﻘﻊ ﻀـﻤﻥ ﺍﻟﻤﺠـﺎل‬ ‫‪Real‬‬
‫‪ 2.9*10-39‬ﺇﻟﻰ ‪ 1.7*1038‬ﻭﻫﻲ ﺘﺤﺘﺎﺝ ﺇﻟﻰ ﺴﺕ ﺒﺎﻴﺘﺎﺕ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ ﻭﺘﺴﺘﺨﺩﻡ ﻟﻠﺘﻭﺍﻓﻕ ﻤﻊ ﻨﺴﺦ‬
‫ﺒﺎﺴﻜﺎل ﺍﻟﻘﺩﻴﻤﺔ ﻭﺇﻻ ﻓﺈﻥ ﺍﺴﺘﺨﺩﺍﻡ ‪ Extended‬ﺃﻭ ‪ Double‬ﺃﻭﻟﻰ‬
‫ﻫﻲ ﺃﻋﺩﺍﺩ ﺘﺤﺘﻭﻱ ﻓﺎﺼﻠﺔ ﻋﺸﺭﻴﺔ ﻭﺠﺯﺀﹰﺍ ﻋﺸﺭﻴﹰﺎ ﻓﻴﻪ ) ‪ ( 15‬ﺃﻭ ) ‪ ( 16‬ﻭﺘﻘﻊ ﻀـﻤﻥ ﺍﻟﻤﺠـﺎل‬ ‫‪Double‬‬
‫‪ 5.0*10-324‬ﺇﻟﻰ ‪ 1.7*10308‬ﻭﺘﺤﺘﺎﺝ ﺇﻟﻰ ﺜﻤﺎﻨﻲ ﺒﺎﻴﺘﺎﺕ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ ‪.‬‬
‫ﻫﻲ ﺃﻋﺩﺍﺩ ﺘﺤﺘﻭﻱ ﻓﺎﺼﻠﺔ ﻋﺸﺭﻴﺔ ﻭﺠﺯﺀﹰﺍ ﻋﺸﺭﻴﹰﺎ ﻓﻴﻪ ) ‪ (19‬ﺃﻭ ) ‪ ( 20‬ﺭﻗﻡ ﻭﺘﻘﻊ ﻓـﻲ ﺍﻟﻤﺠـﺎل‬ ‫‪Extended‬‬
‫‪ 3.4*10-4932‬ﻭﺤﺘﻰ ‪ 1.1*104932‬ﻭﺘﺤﺘﺎﺝ ﺇﻟﻰ ﻋﺸﺭﺓ ﺒﺎﻴﺘﺎﺕ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ‬
‫ﻭﻫﻲ ﺃﻋﺩﺍﺩ ﺤﻘﻴﻘﻴﺔ ﺫﺍﺕ ﻓﺎﺼﻠﺔ ﺜﺎﺒﺘﺔ ﺒﺨﻼﻑ ﺒﺎﻗﻲ ﺍﻷﻨﻭﺍﻉ ﺫﺍﺕ ﺍﻟﻔﺎﺼﻠﺔ ﺍﻟﻌﺎﺌﻤﺔ ‪ ،‬ﻭﻫﻲ ﻤﻼﺌﻤـﺔ‬ ‫‪Currency‬‬
‫ﻟﻠﺤﺴﺎﺒﺎﺕ ﺍﻟﻤﺎﻟﻴﺔ ﻭﺘﻤﻠﻙ ﺠﺯﺀﹰﺍ ﻋﺸﺭﻴﹰﺎ ﻤـﻥ ) ‪ ( 19‬ﺃﻭ ) ‪ 20‬ﺭﻗـﻡ ( ﻭﺘﻘـﻊ ﻀـﻤﻥ ﺍﻟﻤﺠـﺎل‬
‫‪ -922337203685477.5808‬ﻭﺤﺘﻰ ‪ 922337203685477‬ﻭﻴﺘﻁﻠﺏ ﺘﺨﺯﻴﻨﻬﺎ ﺜﻤﺎﻥ ﺒﺎﻴﺘﺎﺕ‬
‫‪.‬‬
‫ﻫﻲ ﺃﻋﺩﺍﺩ ﺘﺤﺘﻭﻱ ﻓﺎﺼﻠﺔ ﻋﺸﺭﻴﺔ ﻭﺠﺯﺀﹰﺍ ﻋﺸﺭﻴﹰﺎ ﻓﻴﻪ ) ‪ (19‬ﺃﻭ ) ‪ ( 20‬ﺭﻗﻡ ﻭﺘﻘﻊ ﻓـﻲ ﺍﻟﻤﺠـﺎل‬ ‫‪Comp‬‬
‫‪ -9.2*1018‬ﻭﺤﺘﻰ ‪ 9.2*1018‬ﻭﺘﺤﺘﺎﺝ ﺇﻟﻰ ﺜﻤﺎﻥ ﺒﺎﻴﺘﺎﺕ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ ‪.‬‬

‫‪30‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻷﻨﻭﺍﻉ ﺍﻟﺒﻭﻟﻴﺎﻨﻴﺔ ‪:‬‬
‫ﻫﻭ ﻨﻭﻉ ﻤﻨﻁﻘﻲ ﻴﻤﻜﻥ ﺃﻥ ﺘﺄﺨﺫ ﺍﻟﻤﺘﺤﻭﻻﺕ ﺍﻟﻤﻨﺘﻤﻴﺔ ﺇﻟﻴﻪ ﺇﺤﺩﻯ ﻗﻴﻤﺘﻴﻥ ‪ True‬ﺃﻭ ‪ False‬ﻭﻴﺤﺘﺎﺝ‬ ‫‪Boolean‬‬
‫ﺇﻟﻰ ﺒﺎﻴﺕ ﻭﺍﺤﺩ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ ‪.‬‬
‫ﻤﺜل ﻨﻭﻉ ‪ Boolean‬ﻴﺴﺘﺨﺩﻡ ﻟﻠﺘﻭﺍﻓﻕ ﻤﻊ ﻟﻐﺎﺕ ﺃﺨﺭﻯ ﻤﺜل ‪ C‬ﻭﻴﺤﺘﺎﺝ ﺇﻟﻰ ﺒﺎﻴﺕ ﻭﺍﺤﺩ ﻤﻥ‬ ‫‪ByteBool‬‬
‫ﺍﻟﺫﺍﻜﺭﺓ‬
‫ﻤﺜل ﻨﻭﻉ ‪ Boolean‬ﻴﺴﺘﺨﺩﻡ ﻟﻠﺘﻭﺍﻓﻕ ﻤﻊ ﻟﻐﺎﺕ ﺃﺨﺭﻯ ﻤﺜل ‪ C‬ﻭﻴﺤﺘﺎﺝ ﺇﻟﻰ ﺒﺎﻴﺘﻴﻥ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ‬ ‫‪Wordbool‬‬
‫ﻤﺜل ﻨﻭﻉ ‪ Boolean‬ﻴﺴﺘﺨﺩﻡ ﻟﻠﺘﻭﺍﻓﻕ ﻤﻊ ﻟﻐﺎﺕ ﺃﺨﺭﻯ ﻤﺜل ‪ C‬ﻭﻴﺤﺘﺎﺝ ﺇﻟﻰ ﺃﺭﺒﻊ ﺒﺎﻴﺘﺎﺕ ﻤﻥ‬ ‫‪Longbool‬‬
‫ﺍﻟﺫﺍﻜﺭﺓ‬
‫ﺍﻷﻨﻭﺍﻉ ﺍﻟﺭﻤﺯﻴﺔ ‪:‬‬
‫‪ AnsiChar‬ﻫﻭ ﻨﻭﻉ ﺭﻤﺯﻱ ﻴﺤﺘﺎﺝ ﺇﻟﻰ ﺒﺎﻴﺕ ﻭﺍﺤﺩ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ ﻟﺘﺨﺯﻴﻥ ﺸﻴﻔﺭﺓ ﺃﺴﻜﻲ ﺍﻟﻤﻘﺎﺒﻠﺔ ﻟﺭﻤﺯ ﻤﻌﻴﻥ‬
‫‪. Character‬‬
‫ﻫﻭ ﻨﻭﻉ ﺭﻤﺯﻱ ﻴﺤﺘﺎﺝ ﺇﻟﻰ ﺒﺎﻴﺘﻴﻥ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ ﻟﺘﺨﺯﻴﻥ ﺭﻤﺯ ﺒﺎﻟﺸﻴﻔﺭﺓ ﺍﻟﻤﻭﺤﺩﺓ ‪) Unicode‬‬ ‫‪WideChar‬‬
‫ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﻤﻭﺤﺩﺓ ﺘﻡ ﺍﻋﺘﻤﺎﺩﻫﺎ ﻤﻨﺫ ﻓﺘﺭﺓ ﻓﻲ ﺃﻨﻅﻤﺔ ﺍﻟﺘﺸﻐﻴل ‪ Windows 2000,Xp‬ﻭﻫﻲ ﻋﺒﺎﺭﺓ‬
‫ﺘﻤﺜﻴل ﻴﻀﻡ ﺠﻤﻴﻊ ﻟﻐﺎﺕ ﺍﻟﻌﺎﻟﻡ ) ﻋﺩﻯ ﻟﻐﺎﺕ ﺸﺭﻕ ﺁﺴﻴﺎ ( ﻭﻴﺤﺘﺎﺝ ﻜل ﺭﻤﺯ ﻓﻴﻬﺎ ﺇﻟﻰ ‪ 16‬ﺒﺕ ‪.‬‬
‫ﻫﻭ ﻨﻔﺱ ﺍﻟﻨﻭﻉ ‪ AnsiChar‬ﺘﺤﺕ ﺒﻴﺌﺔ ‪ Windows 98,Me‬ﻭﻟﻜﻨﻪ ﻗﺩ ﻴﺸﻴﺭ ﺇﻟﻰ ‪WideChar‬‬ ‫‪Char‬‬
‫ﻓﻲ ﺒﻴﺌﺔ ‪. Windows 2000,Xp‬‬
‫ﺃﻨﻭﺍﻉ ﺍﻟﺴﻼﺴل ﺍﻟﺭﻤﺯﻴﺔ ‪:‬‬
‫‪ AnsiString‬ﻫﻭ ﻋﺒﺎﺭﺓ ﻋﻥ ﻤﺼﻔﻭﻓﺔ ﻤﻥ ﺍﻟﺭﻤﻭﺯ ﻏﻴﺭ ﻤﺤﺩﻭﺩﺓ ﺍﻟﻁﻭل ﻴﺒﺩﺃ ﺤﺠﻤﻬﺎ ‪4‬ﺒﺎﻴﺕ ﻭﻴﻨﺘﻬﻲ ﺒـ ‪ 2‬ﺠﻴﻐﺎ‬
‫ﺒﺎﻴﺕ‬
‫ﻭﺘﺒﺩﺃ ﺭﻤﻭﺯﻫﺎ ﻤﻥ ﺍﻟﺤﺠﺭﺓ ﺍﻷﻭﻟﻰ ‪ ) 1‬ﻻ ﻭﺠﻭﺩ ﻟﻠﺤﺠﺭﺓ ‪. ( 0‬‬
‫‪ Sortstring‬ﻫﻭ ﻋﺒﺎﺭﺓ ﻋﻥ ﻤﺼﻔﻭﻓﺔ ﻤﻥ ﺍﻟﺭﻤﻭﺯ ﺤﺩﻫﺎ ﺍﻷﻗﺼﻰ ‪ 256‬ﺭﻤﺯ ﻭﻴﺄﺨﺫ ﺤﺠﻤﻬﺎ ﺒﻴﻥ ‪ 2‬ﺒﺎﻴﺕ ﻭ‬
‫‪ 256‬ﺒﺎﻴﺕ ﻭﻴﺨﺯﻥ ﻓﻲ ﺍﻟﺤﺠﺭﺓ ﺍﻷﻭﻟﻰ ﻤﻨﻬﺎ ) ﺍﻟﺤﺠﺭﺓ ﺭﻗﻡ ‪ ( 0‬ﻁﻭل ﺍﻟﻤﺼﻔﻭﻓﺔ‬

‫‪ WideString‬ﻫﻭ ﻋﺒﺎﺭﺓ ﻋﻥ ﻤﺼﻔﻭﻓﺔ ﻤﻥ ﺍﻟﺭﻤﻭﺯ ﺒﺎﻟﺸﻴﻔﺭﺓ ﺍﻟﻤﻭﺤﺩﺓ ‪ Unicode‬ﻴﺒﺩﺃ ﺤﺠﻤﻬﺎ ‪4‬ﺒﺎﻴﺕ ﻭﻴﻨﺘﻬﻲ‬
‫ﺒـ ‪ 2‬ﺠﻴﻐﺎ ﺒﺎﻴﺕ ﻭﺘﺒﺩﺃ ﺭﻤﻭﺯﻫﺎ ﻤﻥ ﺍﻟﺤﺠﺭﺓ ﺍﻷﻭﻟﻰ ‪ ) 1‬ﻻ ﻭﺠﻭﺩ ﻟﻠﺤﺠﺭﺓ ‪. ( 0‬‬
‫ﺒﺸﻜل ﺍﻓﺘﺭﺍﻀﻲ ﺘﻌﺭﻴﻑ ﻤﺘﺤﻭل ﻤﻥ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻴﻜﺎﻓﺊ ﺘﻌﺭﻴﻑ ﻤﺘﺤﻭل ‪ AnsiString‬ﺃﻭ‬ ‫‪String‬‬
‫‪ WideString‬ﺤﺴﺏ ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ‪ ،‬ﻭﻴﻤﻜﻥ ﺃﻥ ﻴﺸﻴﺭ ﺇﻟﻰ ‪ Shortstring‬ﻓﻲ ﺤﺎل ﺃﻀﻔﻨﺎ‬
‫}‪{$H-‬‬ ‫ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺒﺩﺍﻴﺔ ﺍﻟﻘﺴﻡ ‪implementation‬‬

‫‪31‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺴﻼﺴل ﺍﻟﺭﻤﺯﻴﺔ ﺍﻟﻤﻨﺘﻬﻴﺔ ﺒﻼ ﺸﻲﺀ ) ‪. ( Null‬‬
‫‪ PAnsiChar‬ﻫﻭ ﻋﺒﺎﺭﺓ ﻋﻥ ﻨﻭﻉ ﻤﻌﻁﻴﺎﺕ ﻤﺅﺸﺭ ﻴﺅﺸﺭ ﺇﻟﻰ ﻋﻠﻰ ﺴﻼﺴل ﺭﻤﺯﻴـﺔ ﻤﻨﺘﻬﻴـﺔ ﺒﺭﻤـﺯ ‪Null‬‬
‫ﻭﺭﻤﻭﺯ ﻫﺫﻩ ﺍﻟﺴﻠﺴﺔ ﻤﻥ ﺍﻟﻨﻭﻉ ‪AnsiChar‬‬
‫‪ PWideChar‬ﻫﻭ ﻋﺒﺎﺭﺓ ﻋﻥ ﻨﻭﻉ ﻤﻌﻁﻴﺎﺕ ﻤﺅﺸﺭ ﻴﺅﺸﺭ ﺇﻟﻰ ﻋﻠﻰ ﺴﻼﺴل ﺭﻤﺯﻴـﺔ ﻤﻨﺘﻬﻴـﺔ ﺒﺭﻤـﺯ ‪Null‬‬
‫ﻭﺭﻤﻭﺯ ﻫﺫﻩ ﺍﻟﺴﻠﺴﺔ ﻤﻥ ﺍﻟﻨﻭﻉ ‪WideChar‬‬
‫ﻨﻔﺱ ﺍﻟﻨﻭﻋﻴﻥ ﺍﻟﺴﺎﺒﻘﻴﻥ ﻭﻴﺅﺸﺭ ﻋﻠﻰ ﺍﻟﻨﻭﻉ ‪Char‬‬ ‫‪Pchar‬‬
‫ﺍﻟﻤﺅﺸﺭ‬
‫ﻭﻫﻭ ﻤﺅﺸﺭ ﻏﻴﺭ ﻤﺤﺩﺩ ﺍﻟﻨﻭﻉ ﺃﻱ ﻴﺅﺸﺭ ﺇﻟﻰ ﺃﻱ ﻨﻭﻉ ﻤﻥ ﺍﻟﻤﻌﻁﻴﺎﺕ ‪،‬ﻭﻴﺤﺘﺎﺝ ﺇﻟﻰ ﺃﺭﺒﻊ ﺤﺠﺭﺍﺕ‬ ‫‪Pointer‬‬
‫ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ ‪.‬‬
‫ﺍﻟﻨﻭﻉ ﺍﻟﻤﺘﻨﻭﻉ ) ﺍﻟﻤﺘﻐﻴﺭ (‬
‫ﻨﻭﻉ ﻤﺘﻐﻴﺭ ﻤﺘﻭﺍﻓﻕ ﻤﻊ ﺠﻤﻴﻊ ﺍﻨﻭﺍﻉ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻭﻴﻤﻜﻥ ﺃﻥ ﻴﺨﺯﻥ ﻗﻴﻤﹰﺎ ﻭﻓﻕ ﺃﻱ ﻨﻭﻉ ‪.‬‬ ‫‪Variant‬‬
‫ﺃﻤﺜﻠﺔ ‪:‬‬
‫‪ 1‬ـ ﺍﻟﻨﻭﻉ ‪: Boolean‬‬
‫ﺃﻨﺸﺄ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﺯﺭ ‪ Button‬ﻭﻋﻨﺼﺭﻱ ‪ Edit‬ﻭﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ‬
‫;‪var a:Boolean‬‬
‫;‪i,j:integer‬‬
‫‪begin‬‬
‫;)‪i:=strtoint(edit1.text‬‬
‫;)‪j:= strtoint(edit2.text‬‬
‫;‪a:= i>j‬‬
‫)'ﺍﻟﻌﺩﺩ ﺍﻟﺜـﺎﻨﻲ ﺃﻜﺒـﺭ ﻤـﻥ ‪' ) else showmessage‬ﺍﻟﻌﺩﺩ ﺍﻟﻸﻭل ﺃﻜﺒﺭ ﻤﻥ ﺍﻟﺜﺎﻨﻲ'( ‪if a then showmessage‬‬
‫ﺍﻷﻭل'(؛‬
‫‪ 2‬ـ ﺍﻟﻨﻭﻉ ‪: Shortstring‬‬
‫ﺃﻀﻑ ﺯﺭ ﻭﻋﻨﺼﺭﻱ ‪ Label‬ﻭ ﻋﻨﺼﺭ ‪ Edit‬ﺇﻟﻰ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ ‪ :‬ﻭﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪:‬‬
‫;‪var a:shortstring‬‬
‫‪begin‬‬
‫;‪a:=edit1.text‬‬
‫;)]‪form1.Caption := inttostr(word(a[0‬‬
‫‪if word(a[0]) >= 4 then‬‬
‫;]‪label1.Caption := a[3]+a[4‬‬
‫ﻼ )'‪ Word('A‬ﻴﺴﺎﻭﻱ ‪ 65‬ﻭﺍﺴﺘﺨﺩﻡ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﻷﻥ ﻁـﻭل‬ ‫ﻴﻘﻭﻡ ﺍﻟﺘﺎﺒﻊ ‪ Word‬ﺒﺈﻋﺎﺩﺓ ﺸﻴﻔﺭﺓ ﺍﻷﺴﻜﻲ ﻟﺭﻤﺯ ﻤﻌﻴﻥ ﻤﺜ ﹰ‬
‫ﺍﻟﺴﻠﺴﺔ ﻤﺨﺯﻥ ﻜﺭﻤﺯ ﻭﻟﻴﺱ ﻜﺭﻗﻡ ‪.‬‬

‫‪32‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ﺍﻟﺴﺎﺩﺴﺔ‬
‫‪ 2‬ـ ﺍﻟﻨﻭﻉ ‪: String‬‬
‫ﻟﻠﺤﺼﻭل ﻋﻠﻰ ﻁﻭل ﺴﻠﺴﻠﺔ ﺭﻤﺯﻴﺔ ﻨﺴﺘﺨﺩﻡ ﺍﻟﺘﺎﺒﻊ )'‪ Length('s‬ﺤﻴﺙ ‪ S‬ﻫﻭ ﺍﻟﺴﻠﺴﺔ ﺍﻟﻤﻁﻠﻭﺏ ﺤﺴﺎﺏ ﻁﻭﻟﻬﺎ‬
‫ﻤﺜﺎل ‪:‬‬
‫ﺃﻀﻑ ﺯﺭ ﻭﻋﻨﺼﺭ ‪ label‬ﻭ ‪ Edit‬ﺇﻟﻰ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ ﻭﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻋﻨﺩ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪:‬‬
‫;‪var a:string‬‬
‫‪begin‬‬
‫;‪a:=edit1.text‬‬
‫;)‪label1.Caption := inttostr(length(A‬‬
‫;)'‪label2.Caption :=inttostr(length('asdfgh‬‬
‫‪ 3‬ـ ﺍﻟﻨﻭﻉ ‪: Pchar‬‬
‫;‪Var P:pchar‬‬ ‫ﻟﻨﻔﺭﺽ ﺃﻨﻪ ﻋﺭﻓﻨﺎ ﻤﺘﺤﻭل ‪ P‬ﻤﻥ ﺍﻟﻨﻭﻉ ‪: Pchar‬‬
‫‪'Hello‬‬ ‫‪;Form1.Caption := p‬‬ ‫ﺜﻡ ﻜﺘﺒﻨﺎ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Begin‬ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴـﺔ ‪:‬‬
‫'‪p:= All…….‬‬
‫ﻫﺫﺍ ﻴﻜﺎﻓﺊ ﻜﺘﺎﺒﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪s: string‬‬
‫‪begin‬‬
‫‪s:= 'HELLO ALL......'#0‬‬ ‫;‬
‫;]‪p:= @s[1‬‬
‫;‪form1.Caption := p‬‬
‫ﺤﻴﺙ ‪ #0‬ﻫﻭ ﺭﻤﺯ ﺍﻷﺴﻜﻲ ﻟـ ‪ Null‬ﻭﻭﻀﻌﻪ ﻫﻨﺎ ﻴﻨﻬﻲ ﺍﻟﺴﻠﺴﻠﺔ ‪ s‬ﺒـ ‪. Null‬‬
‫@ ﻴﻌﻴﺩ ﻋﻨﻭﺍﻥ ﻤﻭﻗﻊ ﺍﻟﺫﺍﻜﺭﺓ ﺍﻟﻤﺨﺯﻥ ﻓﻴﻪ ﺍﻟﺤﺭﻑ ﺍﻷﻭل ﻤﻥ ﺍﻟﺴﻠﺴﻠﺔ ‪. s‬‬
‫‪ 4‬ـ ﺍﻟﻨﻭﻉ ﺍﻟﻤﺘﻐﻴﺭ ) ﺍﻟﻤﺘﻨﻭﻉ ( ‪: Variant‬‬
‫ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ‪:‬‬
‫;‪var v1,v2,v3 :variant‬‬
‫‪begin‬‬
‫;‪v1:= 5‬‬
‫;‪v2:= 20‬‬
‫; ‪v3 := v1+v2‬‬
‫;‪form1.Caption := v3‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﺘﻌﻁﻲ ﺭﺴﺎﻟﺔ ﺨﻁﺄ ﻤﻥ ﺍﻟﻨﻭﻉ ‪: EvariantError‬‬
‫;‪v1:= 5‬‬
‫;'‪v2:= 'asd‬‬
‫‪v3 := v1+v2‬‬ ‫;‬
‫ﻭﻟﻜﻥ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻻ ﺘﻌﻁﻲ ﻫﺫﺍ ﺍﻟﺨﻁﺄ ‪:‬‬

‫;‪v1:= 5‬‬
‫;'‪v2:= '123‬‬
‫‪v3 := v1+v2‬‬ ‫;‬
‫‪33‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬

‫ﻟﻤﺎﺫﺍ ﻻ ﻨﺴﺘﺨﺩﻡ ﺍﻟﻨﻭﻉ ‪ Variant‬ﺩﺍﺌﻤﹰﺎ ‪ :‬ﻻﺤﻅ ﺃﻥ ﻫﺫﺍ ﺍﻟﻤﺘﺤﻭل ﻀﺩ ﺍﻟﺘﻭﺠ‪‬ﻪ ﺍﻟﻌﺎﻡ ﻟﻠﻐﺔ ﺒﺎﺴﻜﺎل ﻭ ﻀـ ‪‬ﺩ ﺃﻋـﺭﺍﻑ‬
‫ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﺠﻴﺩﺓ‪ ،‬ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻴﺘﻡ ﻓﺤﺹ ﻨﻭﻋﻪ ﻭ ﻴﺘﻡ ﺤﺴﺎﺒﻪ ﻓﻲ ﻭﻗﺕ ﺍﻟﺘﺸﻐﻴل‪ ،‬ﻭﺍﻟﻤﺠﻤ‪‬ﻊ ‪ compiler‬ﻟﻥ ﻴﺤﺫﺭﻙ ﻤﻥ‬
‫ل ﻋﻠﻴﻬﺎ ﺇﻻ ﺒﻌﺩ ﺍﺠﺭﺍﺀ ﺍﺨﺘﺒﺎﺭﺍﺕ ﻤﻜﺜﻔﺔ‪ ،‬ﺒﺼﻭﺭﺓ ﻋﺎﻤﺔ‪ ،‬ﻴﻤﻜﻨﻙ ﺍﻋﺘﺒـﺎﺭ ﺃﺠـﺯﺍﺀ‬
‫ﺍﺤﺘﻤﺎﻻﺕ ﺍﻷﺨﻁﺎﺀ‪ ،‬ﻭ ﺍﻟﺘﻲ ﻟﻥ ﻴﺴﺘﺩ ّ‬
‫ﺍﻟﺘﺭﺠﻤﺔ ﺍﻟﺘﻲ ﺘﺴﺘﺨﺩﻡ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻫﻲ ﺘﺭﺠﻤﺔ ﻓﻭﺭﻴﺔ ‪ ،interpreted‬ﻷﻨﻪ‪ ،‬ﻤﺜل ﺃﻱ ﻟﻐﺔ ﺘﻔﺴﻴﺭﻴﺔ‪ ،‬ﺍﻟﻌﺩﻴـﺩ ﻤـﻥ‬
‫ﺍﻟﻌﻤﻠﻴﺎﺕ ﻻ ﻴﻤﻜﻥ ﺍﻟﺘﻘﺭﻴﺭ ﺒﺸﺄﻨﻬﺎ ﻭﺤﻠﹼﻬﺎ ﺇﻻ ﻓﻲ ﻭﻗﺕ ﺍﻟﺘﺸﻐﻴل‪ ،‬ﻫﺫﺍ ﻴﺅﺜﺭ ﺒﺼﻔﺔ ﺨﺎﺼﺔ ﻓﻲ ﺴﺭﻋﺔ ﺍﻟﺘﻨﻔﻴﺫ‪.‬‬
‫ﺍﻟﻤﺘﺤﻭﻻﺕ ﺍﻟﻌﺎﻤﺔ ﻭﺍﻟﺨﺎﺼﺔ ‪:‬‬
‫ﻴﻭﺠﺩ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Interface‬ﻟﻜل ﻭﺤﺩﺓ ﻗﺴﻡ ﺨﺎﺹ ﺒﺎﻟﻤﺘﺤﻭﻻﺕ ﺍﻟﻤـﺴﺘﺨﺩﻤﺔ ﺩﺍﺨـل ﺍﻟﻭﺤـﺩﺓ ﻨﻔـﺴﻬﺎ ﻭﻴـﺩﻋﻰ‬
‫‪ private‬ﻭﺍﻟﻤﺘﺤﻭل ﺍﻟﻤﻌﺭﻑ ﻓﻲ ﻫﺫﺍ ﺍﻟﻘﺴﻡ ﻴﻤﻜﻥ ﺍﺴﺘﺨﺩﺍﻤﻪ ﻓﻲ ﺠﻤﻴﻊ ﺇﺠﺭﺍﺀﺍﺕ ﻭﺘﻭﺍﺒﻊ ﻫﺫﻩ ﺍﻟﻭﺤـﺩﺓ ﻟﻜـﻥ ﻻ‬
‫ﻴﻤﻜﻥ ﺍﻟﻭﺼﻭل ﺇﻟﻴﻪ ﻤﻥ ﺨﺎﺭﺠﻬﺎ ‪.‬‬
‫ﻭﻫﻨﺎﻙ ﻗﺴﻡ ﺁﺨﺭ ﻴﺸﺒﻪ ﺍﻟﻘﺴﻡ ﺍﻟﺴﺎﺒﻕ ﻭﻴﺨﺘﻠﻑ ﻋﻨﻪ ﺒﺈﻤﻜﺎﻨﻴﺔ ﺍﻟﻭﺼﻭل ﺇﻟﻴﻪ ﻤﻥ ﻭﺤﺩﺍﺕ ﺨﺎﺭﺠﻴﺔ ﻤﺭﺘﺒﻁﺔ ﻤـﻊ ﺍﻟﻭﺤـﺩﺓ‬
‫ﺍﻟﻤﻌﺭﻑ ﻓﻴﻬﺎ ﻫﺫﺍ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻭﻴﺩﻋﻰ ‪. Public‬‬
‫ﻤﺜﺎل ‪:‬‬
‫ﺃﻨﺸﺊ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﺯﺭﹰﺍ ﻭﻋﺭﻑ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Private‬ﺍﻟﻤﺘﺤﻭل ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫‪private‬‬
‫;‪I :integer‬‬
‫ﻭﻋﺭﻑ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Public‬ﺍﻟﻤﺘﺤﻭل ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫‪public‬‬
‫;‪x:integer‬‬
‫ﺃﺫﻫﺏ ﺇﻟﻰ ﺍﻟﺤﺩﺙ ‪ OnCreate‬ﺍﻟﺨﺎﺹ ﺒﺎﻟﻨﻤﻭﺫﺝ ﻭﺍﻜﺘﺏ ﻓﻴﻪ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪I := 4 ; X := 24‬‬
‫‪ OnCreate‬ﻴﺘﻡ ﺘﻨﻔﻴﺫﻩ ﻋﻨﺩ ﻴﻘﻭﻡ ﻭﻴﻨﺩﻭﺯ ﺒﺈﻨﺸﺎﺀ ﺍﻟﻨﺎﻓﺫﺓ ﻭﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺴﺎﺒﻘﺔ ﺘﻌﻁﻲ ﻗﻴﻡ ﺍﺒﺘﺩﺍﺌﻴﺔ ﻟﻠﻤﺘﺤـﻭﻟﻴﻥ‬ ‫ﺍﻟﺤﺩﺙ‬
‫‪ procedure‬ﺃﻱ‬ ‫‪ ) X,I‬ﻻﺤﻅ ﺍﺴﺘﺨﺩﺍﻡ ﻫﺫﻴﻥ ﺍﻟﻤﺘﺤﻭﻟﻴﻥ ﻀـﻤﻥ ﺍﻹﺠـﺭﺍﺀ ‪TForm1.FormCreate‬‬
‫ﻴﻤﻜﻥ ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﻀﻤﻥ ﺃﻱ ﺠﺯﺀ ﻤﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ( ‪.‬‬
‫ﺃﻀﻑ ﻨﻤﻭﺫﺠﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﺯﺭﹰﺍ ﺍﻵﻥ ﺍﺫﻫﺏ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻷﻭل ﻭﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠـﻰ‬
‫ﺍﻟﺯﺭ ‪:‬‬
‫; ‪form2.Show‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺤﺘﻰ ﻴﺘﻡ ﺭﺒﻁ ﺍﻟﻭﺤﺩﺓ ﺍﻟﺜﺎﻨﻴﺔ ﻤﻊ ﺍﻷﻭﻟﻰ ﺒﺸﻜل ﺁﻟﻲ ) ﺃﻭ ﺍﻜﺘﺏ ﺃﺴﻡ ﺍﻟﻭﺤﺩﺓ ﺍﻷﻭﻟﻰ ﻓﻲ ﺍﻟﻘﺴﻡ ‪. ( Uses‬‬
‫ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﻤﻭﺠﻭﺩ ﻓﻲ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺜﺎﻨﻲ ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; )‪Form2.Caption := inttostr ( Form1.X‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻟﺭﺒﻁ ﺍﻟﻭﺤﺩﺍﺕ ﻤﻊ ﺒﻌﻀﻬﺎ ﺁﻟﻴﹰﺎ ﺜﻡ ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ‪ ،‬ﺍﻟﺯﺭ ﻓﻲ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻷﻭﻟﻰ ﺴﻴﻘﻭﻡ ﺒﺈﻅﻬﺎﺭ ﺍﻟﻨﺎﻓـﺫﺓ ﺍﻟﺜﺎﻨﻴـﺔ‪،‬‬
‫ﻭﺍﻟﺯﺭ ﻓﻲ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺜﺎﻨﻴﺔ ﺴﻴﺄﺨﺫ ﺍﻟﻘﻴﻤﺔ ‪ X‬ﻤﻥ ﺍﻟﻭﺤﺩﺓ ﺍﻷﻭﻟﻰ ﻭﻴﻀﻌﻬﺎ ﻓﻲ ﻋﻨﻭﺍﻥ ﺍﻟﻨﺎﻓﺫﺓ ‪.‬‬
‫ﻫﻨﺎﻙ ﻁﺭﻴﻘﺔ ﺃﺨﺭﻯ ﻟﺘﻌﺭﻴﻑ ﻤﺘﺤﻭل ﺨﺎﺹ ﺒﺎﻟﻭﺤﺩﺓ ﻋﻥ ﻁﺭﻴﻕ ﺘﻌﺭﻴﻔﻪ ﺒﺎﻟﻘﺴﻡ ‪ Var‬ﻗﺒل ‪Implementation‬‬
‫ﻭﻴﺘﻤﻴﺯ ﺘﻌﺭﻴﻑ ﺍﻟﻤﺘﺤﻭل ﻫﻨﺎ ﺒﺈﻤﻜﺎﻨﻴﺔ ﺇﻋﻁﺎﺀ ﻗﻴﻤﺔ ﻤﺒﺩﺌﻴﺔ ﻟﻪ ﻤﺒﺎﺸﺭﺓ ‪.‬‬

‫‪34‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻤﺜﺎل ‪ :‬ﻋﺭﻑ ﺍﻟﻤﺘﺤﻭﻻﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Var‬ﻗﺒل ‪Implementation‬‬
‫;‪Y: string = 'abcd'; F : double = 55‬‬
‫ﺍﻟﺜﻭﺍﺒﺕ ‪: Const‬‬
‫ﺍﻟﺜﺎﺒﺕ ﻫﻭ ﺤﺠﺭﺓ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ ﺘﺤﻤل ﻗﻴﻤﺔ ﻤﻌﻴﻨﺔ ﻁﻭﺍل ﻓﺘﺭﺓ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪:‬‬
‫ﻴﻤﻜﻥ ﺘﻌﺭﻴﻑ ﺍﻟﺜﻭﺍﺒﺕ ﺨﺎﺭﺝ ﺍﻟﻘﺴﻡ ‪ Type‬ﻗﺒل ‪ Implementation‬ﻓﺘﻜﻭﻥ ﺜﻭﺍﺒﺕ ﻋﺎﻤﺔ ‪ ،‬ﻭﻴﻤﻜﻥ ﺘﻌﺭﻴﻔﻬـﺎ‬
‫ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Implementation‬ﻭﺘﻜﻭﻥ ﺜﻭﺍﺒﺕ ﺨﺎﺼﺔ ﺒﺎﻟﻭﺤﺩﺓ ‪.‬ﻭﻴﻜﻭﻥ ﺘﻌﺭﻴﻔﻬﺎ ﺒﺎﻟﻁﺭﻴﻘﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪Const‬‬
‫;‪pi=3.14‬‬
‫;‪pi2=22/7‬‬
‫;'‪programmer = 'Khaled‬‬
‫ﻭﻴﻤﻜﻥ ﺘﻌﺭﻴﻔﻬﺎ ﺒﻁﺭﻴﻘﺔ ﺃﺨﺭﻯ ‪:‬‬
‫‪Const‬‬
‫;‪Pi :Real = 3.14‬‬
‫;‪pi2:single =22/7‬‬
‫;'‪programmer :string= 'Khaled‬‬
‫ﺍﻹﺠﺭﺍﺀﺍﺕ ﻭﺍﻟﺘﻭﺍﺒﻊ ‪:‬‬
‫ﻤﺒﺩﺌﻴﺎ ﻫﻲ ﺴﻠﺴﻠﺔ ﻤﻥ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺘﺤﺕ ﺍﺴﻡ ﺨﺎﺹ‪ ،‬ﻭ ﺍﻟﺘﻲ ﻴﻤﻜﻥ ﺘﻨﻔﻴﺫﻫﺎ ﻓﻲ ﻜل ﻤﺭ‪‬ﺓ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﺴﻤﻬﺎ‪ ،‬ﺒﻬﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ‬
‫ﺘﺘﺠﻨﺏ ﻤﻌﺎﻭﺩﺓ ﻜﺘﺎﺒﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻤﺭﺓ ﺒﻌﺩ ﺃﺨﺭﻯ‪ ،‬ﻓﺘﺘﺤﺼ‪‬ل ﻋﻠﻰ ﻤﺠﻤﻭﻋﺔ ﻭﺍﺤﺩﺓ ﻤﻥ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻴﻤﻜﻨﻙ ﺍﺴﺘﺩﻋﺎﺌﻬﺎ ﻓﻲ‬
‫ﻜﺎﻤل ﺍﻟﺒﺭﻨﺎﻤﺞ‪.‬‬
‫ﻓﻲ ﺩﻟﻔﻲ ﺍﻹﺠﺭﺍﺌﻴﺔ ‪ routine‬ﻴﻤﻜﻥ ﺍﻓﺘﺭﺍﻀﻬﺎ ﺒﺸﻜﻠﻴﻥ‪ :‬ﺇﺠﺭﺍﺀ ‪ procedure‬ﻭ ﺘﺎﺒﻊ ‪function‬‬
‫ﻨﻅﺭﻴﺎ‪ ،‬ﻴﺴﺘﺨﺩﻡ ﺍﻹﺠﺭﺍﺀ ﻋﻨﺩﻤﺎ ﻨﺭﻴﺩ ﻤﻥ ﺍﻟﺤﺎﺴﺏ ﺍﻟﻘﻴﺎﻡ ﺒﻌﻤل ﻤﺎ ﺩﻭﻥ ﺃﻥ ﻴﻌﻴﺩ ﻗﻴﻤﺔ ﻤﻌﻴﻨﺔ ‪،‬ﻭﺍﻟﺘﺎﺒﻊ ﻫﻭ ﻋﺒﺎﺭﺓ ﻋﻥ‬
‫ﺇﺠﺭﺍﺀ ﻴﻨﻔﺫ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻟﻴﻌﻴﺩ ﻗﻴﻤﺔ ﻤﻌﻴﻨﺔ ﻴﻁﻠﺒﻬﺎ ﺍﻟﻤﺒﺭﻤﺞ ‪ .‬ﻫﺫﺍ ﺍﻟﻔﺭﻕ ﻴﺅﻜﹼﺩﻩ ﺤﻘﻴﻘﺔ ﺃﻥ ﺍﻟﺘﺎﺒﻊ ﻟﻪ ﻨﺘﻴﺠﺔ‬
‫‪ ،result‬ﻗﻴﻤﺔ ﻤﺴﺘﺭﺠﻌﺔ‪ ،‬ﺒﻴﻨﻤﺎ ﺍﻹﺠﺭﺍﺀ ﻟﻴﺱ ﻜﺫﻟﻙ‪ ،‬ﻜﻼ ﺍﻟﻨﻭﻋﻴﻥ ﻤﻥ ﺍﻻﺠﺭﺍﺌﻴﺎﺕ ﻴﻜﻤﻥ ﺃﻥ ﻴﻜﻭﻥ ﻟﻬﻤﺎ ﻋﺩﺓ‬
‫ﻤﺘﺤﻭﻻﺕ‪ ، parameters‬ﻤﻥ ﺃﻨﻭﺍﻉ ﺒﻴﺎﻨﺎﺕ ﺘﻌﻁﻰ ﻟﻬﺎ ‪.‬‬
‫ﻋﻤﻠﻴﹰﺎ‪ ،‬ﺍﻟﻔﺭﻕ ﻋﻤﻭﻤﺎ ﺒﻴﻥ ﺍﻟﺘﻭﺍﺒﻊ ﻭ ﺍﻹﺠﺭﺍﺀﺍﺕ ﻤﺤﺩﻭﺩ ﺠﺩﺍ‪ :‬ﻴﻤﻜﻨﻙ ﺍﺴﺘﺩﻋﺎﺀ ﺘﺎﺒﻊ ﻹﻨﺠﺎﺯ ﻋﻤل ﻤﺎ ﺜﻡ ﺘﺘﺨﻁﹼﻰ ﺍﻟﻨﺘﻴﺠﺔ‬
‫)ﺍﻟﺘﻲ ﻗﺩ ﺘﻜﻭﻥ ﺭﻤﺯ ﺨﻁﺄ ﺍﺨﺘﻴﺎﺭﻱ ﺃﻭ ﻤﺎ ﺸﺎﺒﻪ( ﻜﻤﺎ ﺒﺎﻤﻜﺎﻨﻙ ﺍﺴﺘﺩﻋﺎﺀ ﺇﺠﺭﺍﺀ ﻴﻤﺭ‪‬ﺭ ﻨﺘﻴﺠﺘﻪ ﻀﻤﻥ ﻤﺘﺤﻭﻻﺘﻪ‪.‬‬

‫ﻭﻫﺫﺍ ﻤﺜﺎل ﻟﺘﻌﺭﻴﻑ ﺇﺠﺭﺍﺀ ‪:‬‬

‫;‪procedure Hello‬‬
‫‪begin‬‬
‫;)'ﻤﺭﺤﺒﹰﺎ ﺒﻜﻡ ﻓﻲ ﺩﻟﻔﻲ'( ‪ShowMessage‬‬
‫;‪end‬‬
‫ﻭﻫﺫﺍ ﻤﺜﺎل ﻟﺘﻌﺭﻴﻑ ﺘﺎﺒﻊ ‪:‬‬
‫;‪function Double (Value: Integer) : Integer‬‬
‫‪begin‬‬
‫;‪Double := Value * 2‬‬
‫;‪end‬‬
‫‪35‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺘﻜﺘﺏ ﻫﺫﻩ ﺍﻹﺠﺭﺍﺀﺍﺕ ﺃﻭ ﺍﻟﺘﻭﺍﺒﻊ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Implementation‬ﻭﻻﺴﺘﺩﻋﺎﺌﻬﺎ‪ ،‬ﺃﻀﻑ ﺯﺭﻴﻥ ﻭﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤـﺔ‬
‫ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻷﻭل ‪:‬‬
‫‪Hello‬‬
‫ﻭﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻨﻘﺭ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺜﺎﻨﻲ ‪:‬‬
‫;))‪Form1.caption := inttostr( Double(6‬‬
‫ﺍﻟﻤﺘﺤﻭﻻﺕ ﺩﺍﺨل ﺇﺠﺭﺍﺀ ﺃﻭ ﺘﺎﺒﻊ ‪:‬‬
‫‪ 1‬ـ ﺍﻟﺤﺎﻟﺔ ﺍﻟﻌﺎﻤﺔ‬
‫‪Procedure‬‬ ‫‪ProcedureName‬‬ ‫(‬ ‫‪var1,var2,var3:‬‬ ‫‪anytype‬‬ ‫;‬
‫; )‪var4,var5:any type‬‬
‫‪Begin‬‬
‫‪….‬‬
‫…‬
‫;‪end‬‬
‫ﻤﺜﺎل ‪:‬‬
‫; )‪Procedure Add( x,y : integer‬‬
‫‪Begin‬‬
‫; ‪Y:= x+y‬‬
‫;‪End‬‬
‫ﺃﻀﻑ ﺯﺭ ﻭﻋﻨﺼﺭﻱ ‪ Label‬ﻭﺍﻜﺘﺏ ﻓﻴﻪ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪var i,j:integer‬‬
‫‪begin‬‬
‫;‪i:=1;j:=2‬‬
‫;)‪add(i,j‬‬
‫;)‪label1.Caption := inttostr(i‬‬
‫;)‪label2.Caption := inttostr(j‬‬
‫ﻴﻘﻭﻡ ﻫﺫﺍ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒﺎﺴﺘﺩﻋﺎﺀ ﺍﻟﺘﺎﺒﻊ ‪ Add‬ﺍﻟﺫﻱ ﻴﻘﻭﻡ ﺒﺈﻀﺎﻓﺔ ‪ x‬ﺇﻟﻰ ‪ y‬ﻭﻟﻜﻨﻪ ﻻ ﻴﻌﻴﺩ ﺃﻱ ﻨﺘﻴﺠﺔ ‪.‬‬
‫‪ 2‬ـ ﺍﻟﻤﺘﺤﻭﻻﺕ ) ﺍﻟﻭﺴﻁﺎﺀ ( ﺍﻟﻤﺘﻐﻴﺭﺓ ‪:‬‬
‫‪Procedure ProcedureName‬‬ ‫(‬ ‫‪var1,var2,var3: anytype ;var‬‬
‫; )‪var4,var5:any type‬‬
‫‪Begin‬‬
‫‪….‬‬
‫…‬
‫;‪end‬‬
‫ﻤﺜﺎل ‪:‬‬
‫ﻋﺩل ﺍﻹﺠﺭﺍﺀ ‪ Add‬ﻟﻴﺼﺒﺢ ﻜﺘﺎﻟﻲ ﻭﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ‬
‫;)‪procedure add(x:integer;var y:integer‬‬
‫‪begin‬‬
‫;‪y:= x+y‬‬
‫;‪end‬‬
‫ﻴﻘﻭﻡ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒﺎﺴﺘﺩﻋﺎﺀ ﺍﻹﺠﺭﺍﺀ ‪ Add‬ﺍﻟﺫﻱ ﻴﻘﻭﻡ ﺒﺈﻀﺎﻓﺔ ‪ x‬ﺇﻟﻰ ‪ y‬ﻭﻟﻜﻨﻪ ﻴﻌﻴﺩ ﻗﻴﻤﺔ ‪ y‬ﻭﺒﺎﻟﺘﺎﻟﻲ ﺘﺘﻐﻴﺭ ﻗﻴﻤﺔ ‪. j‬‬

‫‪36‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻤﻼﺤﻅﺎﺕ ‪:‬‬
‫( ‪Add‬‬ ‫ﺃ ـ ﻴﻤﻜﻥ ﺍﺴﺘﺩﻋﺎﺀ ﺍﻹﺠﺭﺍﺀ ‪ Add‬ﺍﻟﻤﻌﺩل ﺒﺎﻟﺸﻜل )‪ Add( 1,j‬ﻭﻟﻜﻥ ﻻ ﻴﻤﻜﻥ ﺍﺴﺘﺩﻋﺎﺌﻪ ﺒﺎﻟـﺸﻜل‬
‫(‪ Add‬ﻭﺫﻟﻙ ﻷﻥ ﺍﻟﻭﺴﻴﻁ ﺍﻟﺜﺎﻨﻲ ﻟﻬﺫﺍ ﺍﻹﺠﺭﺍﺀ ﻴﺠﺏ ﺃﻥ ﻴﻜﻭﻥ ﻤﺘﺤﻭل ﺤﺘﻰ ﺘﺘﻡ ﺇﻋـﺎﺩﺓ‬ ‫)‪ I,2‬ﺃﻭ ﺒﺎﻟﺸﻜل )‪1,2‬‬
‫ﺍﻟﻨﺘﻴﺠﺔ ﻓﻴﻪ ‪.‬‬
‫ﺏ ـ ﻗﺩ ﻴﺘﺒﺎﺩﺭ ﺇﻟﻰ ﺍﻟﺫﻫﻥ ﻫﻨﺎ ﺍﻟﺴﺅﺍل ﺍﻟﺘﺎﻟﻲ ﺒﻤﺎ ﺃﻨﻨﻲ ﺃﺭﻴﺩ ﻤﻥ ﺍﻹﺠﺭﺍﺀ ﺃﻥ ﻴﻌﻴﺩ ﻗﻴﻤﺔ ﻤﺎ ﻓﻠﻤـﺎﺫﺍ ﻻ ﺃﺴـﺘﺨﺩﻡ ﺘـﺎﺒﻊ؟‬
‫ﻭﺍﻟﺠﻭﺍﺏ ﻫﻨﺎ ﺃﻨﻪ ﺒﻬﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﻴﻤﻜﻥ ﺃﻥ ﻴﻌﻴﺩ ﺍﻹﺠﺭﺍﺀ ﺃﻜﺜﺭ ﻤﻥ ﻗﻴﻤﺔ ﺒﻴﻨﻤﺎ ﻴﻌﻴﺩ ﺍﻟﺘﺎﺒﻊ ﻗﻴﻤﺔ ﻭﺤﻴﺩﺓ‪ ،‬ﻋﻠﻰ ﻜل ﺤﺎل ﻫﺫﻩ‬
‫ﺍﻟﻁﺭﻴﻘﺔ ﻴﻤﻜﻥ ﺃﻥ ﺘﺴﺘﺨﺩﻡ ﻤﻊ ﺍﻹﺠﺭﺍﺀﺍﺕ ﻭﺍﻟﺘﻭﺍﺒﻊ ﻋﻠﻰ ﺤﺩ ﺴﻭﺍﺀ ﺃﻱ ﺍﻨﻪ ﻴﻤﻜﻥ ﺃﻥ ﻨﻌﺭﻑ ﺘﺎﺒﻊ ﻴﻌﻴﺩ ﻗﻴﻤـﺔ ﻤـﺎ ﻋـﻥ‬
‫ﻁﺭﻴﻕ ﺇﺴﻤﻪ ﻭﻗﻴﻡ ﺃﺨﺭﻯ ﻋﻥ ﻁﺭﻴﻕ ﻤﺘﺤﻭﻻﺘﻪ ) ﻭﺴﻁﺎﺀﻩ ( ‪.‬‬
‫‪ 3‬ـ ﺍﻟﻭﺴﻁﺎﺀ ﺍﻟﺜﺎﺒﺘﺔ ‪:‬‬
‫; ‪Procedure ProcedureName ( const var1,var2,var3: anytype‬‬
‫; )‪var4,var5:any type‬‬
‫‪Begin‬‬
‫‪….‬‬
‫…‬
‫;‪end‬‬
‫ﻋﻨﺩﻤﺎ ﻻ ﻨﻜﻭﻥ ﺒﺤﺎﺠﺔ ﻟﺘﻐﻴﺭ ﻗﻴﻤﺔ ﺍﻟﻭﺴﻴﻁ ﻀﻤﻥ ﺍﻟﺘﺎﺒﻊ ﻴﻤﻜﻥ ﺃﻥ ﻨﻌﺭﻓﻪ ﻤﻥ ﺍﻟﻨﻭﻉ ﺍﻟﺜﺎﺒﺕ ‪ Const‬ﻭﻻ ﻴﻔﻴﺩ ﺫﻟـﻙ ﺇﻻ‬
‫ﻓﻲ ﺯﻴﺎﺩﺓ ﺴﺭﻋﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪.‬‬
‫ﻋﺩل ﺍﻟﺘﺎﺒﻊ ‪ Add‬ﻟﻴﺼﺒﺢ ﺒﺎﻟﺸﻜل ‪:‬‬
‫;)‪procedure add(const x:integer;var y:integer‬‬
‫‪begin‬‬
‫;‪y:= x+y‬‬
‫;‪end‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻟﻥ ﺘﻼﺤﻅ ﺃﻱ ﻓﺭﻕ ﻓﻲ ﺍﻟﻨﺘﺎﺌﺞ ‪.‬‬
‫ﺃﻤﺎ ﺇﺫﺍ ﻋﺩل ﺍﻟﺒﺭﻨﺎﻤﺞ ﻟﻴﺼﺒﺢ ﺒﺎﻟﺸﻜل‬
‫;)‪procedure add(const x:integer;const y:integer‬‬
‫‪begin‬‬
‫;‪y:= x+y‬‬
‫;‪end‬‬
‫ﻓﺴﻴﻌﻁﻲ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺭﺴﺎﻟﺔ ﺍﻟﺨﻁﺄ ﺍﻟﺘﺎﻟﻴﺔ ‪ Left side cannot be assigned to :‬ﻭﺘﻌﻨـﻲ‬
‫ﺃﻨﻪ ﻻ ﻴﻤﻜﻥ ﺇﻋﻁﺎﺀ ﻗﻴﻤﺔ ﻟـ ‪ Y‬ﻷﻨﻬﺎ ﻤﻥ ﺍﻟﻨﻭﻉ ﺍﻟﺜﺎﺒﺕ ‪.‬‬
‫‪ 5‬ـ ﺇﺠﺭﺍﺀﺍﺕ ﺍﻟﻘﻴﻤﺔ ﺍﻻﻓﺘﺭﺍﻀﻴﺔ ‪:‬‬
‫ﻴﻤﻜﻥ ﺇﻋﻁﺎﺀ ﻭﺴﻴﻁ ﻤﺎ ﻗﻴﻤﺔ ﺇﻓﺘﺭﺍﻀﻴﺔ ﻭﺍﻻﺴﺘﻐﻨﺎﺀ ﻋﻥ ﺘﻤﺭﻴﺭ ﻗﻴﻤﻪ ﻟﻪ ﻋﻨﺩ ﺍﻟﻁﻠﺏ ‪:‬‬
‫‪Procedure ProcedureName(var1,var2,var3: anytype ; var4:‬‬
‫; )‪anytype = Value ; var5:anytype= value‬‬
‫‪Begin‬‬
‫‪….‬‬
‫…‬
‫;‪end‬‬
‫‪37‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬

‫ﻤﺜﺎل ‪ :‬ﻋﺩل ﺍﻹﺠﺭﺍﺀ ‪ Add‬ﻟﻴﺼﺒﺢ ﺒﺎﻟﺸﻜل‬

‫;)‪procedure add(var x:integer;var y:integer=5‬‬

‫‪begin‬‬
‫;‪x:= x+y‬‬
‫;‪end‬‬
‫ﺍﻵﻥ ﻴﻤﻜﻥ ﺃﻥ ﻨﻁﻠﺏ ﺍﻹﺠﺭﺍﺀ ‪ Add‬ﺒﺄﺤﺩ ﺍﻟﺸﻜﻠﻴﻥ ﺍﻟﺘﺎﻟﻴﻴﻥ ‪:‬‬
‫) ‪Add ( I,j) or Add( I‬‬
‫ﻓﻲ ﺍﻟﺤﺎﻟﺔ ﻭﺍﻟﺜﺎﻨﻴﺔ ﺴﻴﻘﻭﻡ ﺍﻹﺠﺭﺍﺀ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻘﻴﻤﺔ ﺍﻻﻓﺘﺭﺍﻀﻴﺔ ﺍﻟﻤﻌﻁﺎﻩ ﻓﻲ ﺘﻌﺭﻴﻑ ﺍﻹﺠﺭﺍﺀ ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﺍﻟﻭﺴﻁﺎﺀ ﺍﻻﻓﺘﺭﺍﻀﻴﺔ ﻴﺠﺏ ﺃﻥ ﺘﻜﻭﻥ ﺁﺨﺭ ﺍﻟﻭﺴﻁﺎﺀ ﺍﻟﻤﻌﺭﻓﺔ ﻓﻲ ﺍﻟﺘﺎﺒﻊ‬

‫‪ 4‬ـ ﺘﻌﺭﻴﻑ ﺘﺎﺒﻊ ﻓﻭﻕ ﺘﺎﺒﻊ ﺃﻭ ﺇﺠﺭﺍﺀ ﻓﻭﻕ ﺇﺠﺭﺍﺀ ‪: overload‬‬

‫ﺘﻤﻜﻨﻨﺎ ﻫﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﻤﻥ ﺘﻌﺭﻴﻑ ﻤﺠﻤﻭﻋﺔ ﺘﻭﺍﺒﻊ ﻟﻬﺎ ﻨﻔﺱ ﺍﻷﺴﻡ ﻭﻟﻜل ﻤﻨﻬﺎ ﻭﻅﻴﻔﺔ ﻤﺤﺩﺩﺓ ‪.‬‬
‫ﻤﺜﺎل ‪ :‬ﺃﻀﻑ ﺜﻼﺜﺔ ﺃﺯﺭﺍﺭ ﻭﻋﻨﺼﺭﻱ ‪ Label‬ﺇﻟﻰ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ ﻭﺍﻜﺘﺏ ﺍﻹﺠﺭﺍﺀﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ‬
‫;‪procedure change( i :integer; var s :string) ; overload‬‬
‫‪begin‬‬
‫;)‪s:=inttostr(i‬‬
‫;‪end‬‬
‫;‪procedure change( i:tdatetime; var s :string) ; overload‬‬
‫‪begin‬‬
‫)‪s:= datetostr(i‬‬
‫;‪end‬‬
‫‪procedure‬‬ ‫(‪change‬‬ ‫;‪i:tdatetime‬‬ ‫‪var‬‬ ‫‪s1,s2‬‬ ‫)‪:string‬‬ ‫;‬
‫;‪overload‬‬
‫‪begin‬‬
‫;)‪S1:= datetostr(i‬‬
‫;)‪S2 := datetostr( i+1‬‬
‫;‪end‬‬

‫ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻻﻭل ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; ‪Var a:string‬‬
‫‪begin‬‬
‫; )‪change ( 5,a‬‬
‫;‪Label1.Caption := a ; end‬‬
‫ﻭﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺜﺎﻨﻲ ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪Var B:String ; begin‬‬
‫;)‪Change ( date,b‬‬
‫;‪Label2.Caption := b; End‬‬
‫ﻭﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺜﺎﻟﺙ ﺃﻜﺘﺏ ﻤﺎ ﻴﻠﻲ ‪:‬‬
‫‪Var A,B:string; begin‬‬
‫‪38‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫;)‪Change ( date,a,b‬‬
‫;‪Label1.Caption := A; Label2.Caption := B; end‬‬
‫‪ 6‬ـ ﻤﺘﺤﻭل ﺍﻟﻨﺘﻴﺠﺔ ‪: Result‬‬
‫‪ Result‬ﻫﻭ ﻋﺒﺎﺭﺓ ﻋﻥ ﻤﺘﺤﻭل ﺍﻓﺘﺭﺍﻀﻲ ﻓﻲ ﺒﻴﺌﺔ ﺩﻟﻔﻲ ﺘﻭﻀﻊ ﻗﻴﻤﺔ ﺍﻟﺘﺎﺒﻊ ‪:‬‬
‫ﻴﻤﻜﻥ ﻜﺘﺎﺒﺔ ﺍﻟﺘﺎﺒﻊ ‪ Add‬ﺒﺄﺤﺩ ﺍﻟﺸﻜﻠﻴﻥ ‪:‬‬
‫‪Function add( x,y:integer) : Function add( x,y:integer) :‬‬
‫;‪integer‬‬ ‫;‪integer‬‬
‫‪Begin‬‬ ‫‪Begin‬‬
‫;‪Add := x+y‬‬ ‫;‪result := x+y‬‬
‫;‪End‬‬ ‫;‪End‬‬

‫ﺠﻌل ﺍﻹﺠﺭﺍﺀ ﻤﺭﺌﻲ ﻤﻥ ﻗﺒل ﻭﺤﺩﺍﺕ ﺃﺨﺭﻯ ‪:‬‬

‫ﻨﻌﻠﻡ ﺃﻨﻪ ﻜﻲ ﻨﺴﺘﻁﻴﻊ ﺍﺴﺘﺩﻋﺎﺀ ﻤﺘﺤﻭل ﺃﻭ ﺘﺎﺒﻊ ﻤﻥ ﻭﺤـﺩﺓ ﺇﻟـﻰ ﺃﺨـﺭﻯ ﻴﺠـﺏ ﺃﻥ ﺘﻜـﻭﻥ ﻤﻭﺠـﻭﺩﺓ ﻓـﻲ ﺍﻟﻘـﺴﻡ‬
‫‪. Interface‬‬
‫ﻼ‪:‬‬
‫‪ 1‬ـ ﻭﻀﻊ ﺃﺴﻡ ﺍﻹﺠﺭﺍﺀ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Interface‬ﻗﺒل ‪ Var‬ﻤﺜ ﹰ‬
‫; )‪Procedure Add( x,y : integer‬‬
‫ﺜﻡ ﻨﻜﺘﺏ ﺍﻹﺠﺭﺍﺀ ﻤﻊ ﺠﺴﻤﻪ ) ‪ ( Begin… end‬ﻓﻲ ﺍﻟﻘﺴﻡ ‪: Implementation‬‬
‫; )‪Procedure Add( x,y : integer‬‬
‫‪Begin‬‬
‫; ‪Y:= x+y‬‬
‫;‪End‬‬
‫ﺒﻬﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﻨﺴﺘﻁﻴﻊ ﻁﻠﺏ ﺍﻹﺠﺭﺍﺀ ﻤﻥ ﺃﻱ ﻭﺤﺩﺓ ﺃﺨﺭﻯ ﻤﺭﺘﺒﻁﺔ ﺒﺎﻟﻭﺤﺩﺓ ﺍﻟﺘﻲ ﻋﺭﻑ ﻓﻲ ﺍﻹﺠﺭﺍﺀ ﻋﻥ ﻁﺭﻴﻕ ﺫﻜـﺭ‬
‫ﺍﺴﻤﻪ ﻓﻘﻁ ‪.‬‬
‫‪ 2‬ـ ﻴﻤﻜﻥ ﺃﻥ ﻨﻀﻴﻑ ﺍﺴﻡ ﺍﻹﺠﺭﺍﺀ ﻤﻊ ﻭﺴﻁﺎﺌﻪ ﺇﻟﻰ ﺍﻟﻘﺴﻡ ‪. Type‬‬
‫ﻤﺜﺎل ‪ :‬ﺃﻀﻑ ﺍﻟﺴﻁﺭ ﺍﻟﺘﺎﻟﻲ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Type‬ﻗﺒل ‪Private‬‬
‫; )‪Procedure Add( x,y : integer‬‬
‫ﻋﻠﻰ ﺃﻥ ﻨﻌﺭﻑ ﺍﻹﺠﺭﺍﺀ ‪ Add‬ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Implementation‬ﺒﺎﻟﺸﻜل ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫; )‪Procedure Tform1.Add( x,y : integer‬‬
‫‪Begin‬‬
‫; ‪Y:= x+y‬‬
‫;‪End‬‬
‫ﺃﻀﻑ ﻭﺤﺩﺓ ﺃﺨﺭﻯ ﺇﻟﻰ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺃﻁﻠﺏ ﻤﻨﻬﺎ ﺍﻟﺘﺎﺒﻊ ‪ Add‬ﺍﻟﻌﺎﺌﺩ ﻟل ‪ Form1‬ﺒﺎﻟﺸﻜل ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫; ) ‪Form1.add ( x,y‬‬

‫‪39‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ﺍﻟﺴﺎﺒﻌﺔ‬
‫ﺍﻟﺘﻭﺍﺒﻊ ﺫﺍﺕ ﺍﻟﻭﺴﻁﺎﺀ ﺍﻟﻤﺘﻌﺩﺩﺓ ‪:‬‬
‫‪Procedure procedureName ( var parameter1 : array of anytype‬‬
‫;) ‪; par2,par3:anytype‬‬
‫‪Begin‬‬
‫……………………‬
‫……‬
‫;‪end‬‬
‫ﻴﻌﺭﻑ ﻓﻲ ﻫﺫﻩ ﺍﻹﺠﺭﺍﺀﺍﺕ ) ﺍﻟﺘﻭﺍﺒﻊ ( ﻭﺴﻴﻁ ﻋﻠﻰ ﺃﻨﻪ ﻤﻥ ﻨﻭﻉ ﻤﺼﻔﻭﻓﺔ ﻏﻴﺭ ﻤﺤﺩﻭﺩﺓ ﺍﻟﻌﻨﺎﺼﺭ‬
‫ﻤﺜﺎل ‪:‬‬
‫; ‪Function add( a:array of integer): string‬‬
‫;‪var h,i,s : integer‬‬
‫‪begin‬‬
‫;‪s:=0‬‬
‫;)‪h := high(a‬‬
‫;]‪for i:= 0 to h do s:= s + a[i‬‬
‫;)‪result:= inttostr(s‬‬
‫;‪end‬‬
‫ﺍﺴﺘﺨﺩﻤﻨﺎ ﻫﻨﺎ ﺍﻟﺘﺎﺒﻊ ‪ High‬ﺍﻟﺫﻱ ﻴﻌﻴﺩ ﺭﻗﻡ ﺁﺨﺭ ﻋﻨﺼﺭ ﻓﻲ ﻤﺼﻔﻭﻓﺔ ) ﺇﻱ ﺇﺫﺍ ﻋﺭﻓﻨﺎ ﻤﺼﻔﻭﻓﺔ ﻤﺎ ﺒﺎﻟﺸﻜل‬
‫]‪ [0..3‬ﺴﻴﻌﻴﺩ ﺍﻟﺘﺎﺒﻊ ﺍﻟﻘﻴﻤﺔ ‪ 3‬ﻭﺇﺫﺍ ﻋﺭﻓﻨﻬﺎ ﺒﺎﻟﺸﻜل ]‪ [2..3‬ﺴﻴﻌﻴﺩ ﺍﻟﻘﻴﻤﺔ ‪ 3‬ﻭﺇﺫﺍ ﻋﺭﻓﺕ ﺒﺎﻟﺸﻜل‬
‫]‪ [22..88‬ﺴﻴﻌﻴﺩ ‪. 88‬‬
‫ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫)]‪form1.Caption := add([1,3,4,89‬‬
‫ﺴﻴﻘﻭﻡ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒﺠﻤﻊ ﺍﻷﻋﺩﺍﺩ ﻭﻭﻀﻊ ﺍﻟﻨﺎﺘﺞ ﻓﻲ ﻋﻨﻭﺍﻥ ﺍﻟﻨﺎﻓﺫﺓ‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﺍﻟﻤﺼﻔﻭﻓﺎﺕ ﺍﻟﻤﺘﻐﻴﺭﺓ ﺘﺒﺩﺃ ﺩﺍﺌﻤﹰﺎ ﺒﺎﻟﻌﻨﺼﺭ ﺭﻗﻡ ﺼﻔﺭ ﺃﻱ ]‪ A[0‬ﻭﺘﻨﺘﻬﻲ ﺒﺤﺴﺏ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﺘﻲ ﺃﺩﺨﻠﻬﺎ‬
‫ﺍﻟﻤﺴﺘﺨﺩﻡ ) ﻟﺫﻟﻙ ﺒﺩﺃﺕ ﺍﻟﺤﻠﻘﺔ ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﻓﻲ ﺍﻟﺘﺎﺒﻊ ‪ Add‬ﻤﻥ ﺍﻟﺼﻔﺭ ‪.‬‬
‫‪: ProgressBar‬‬ ‫ﺸﺭﻴﻁ ﺍﻟﻌﻤل‬
‫ﻫﻭ ﺸﺭﻴﻁ ﻴﺅﺸﺭ ﺇﻟﻰ ﻜﻤﻴﺔ ﺇﻨﺠﺎﺯ ﺍﻟﻌﻤل ﺤﺘﻰ ﻟﺤﻅﺔ ﻤﻌﻴﻨﺔ ) ﻨﻔﺱ ﺍﻟﺸﺭﻴﻁ ﺍﻟﺫﻱ ﻴﻅﻬﺭ ﻋﻨﺩ ﺒﺩﺃ ﺘﻨﺼﻴﺏ ‪ Setup‬ﺃﻱ‬
‫ﺒﺭﻨﺎﻤﺞ ( ﻜﻤﺎ ﻴﻤﻜﻥ ﺍﺴﺘﺨﺩﺍﻤﻪ ﻹﻅﻬﺎﺭ ﻗﻴﻤﺔ ﻤﻌﻴﻨﺔ ‪.‬‬
‫ﻤﺜﺎل ‪:‬‬
‫‪ Progress Bar‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪ Win32‬ﻭ‪ Timer‬ﺇﻟﻰ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ ‪:‬‬ ‫ﺃﻀﻑ‬
‫ﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ Interval‬ﻟﻠﻤﺅﻗﺕ ﺍﻟﻘﻴﻤﺔ ‪ 100‬ﻭﺍﻜﺘﺏ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnTimer‬ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪if progressbar1.Position < 100 then‬‬
‫;‪progressbar1.Position := progressbar1.Position+1‬‬
‫‪ ProgressBar‬ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﻤﻬﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬ ‫ﻟـ‬
‫‪ ProgressBar‬ﻭﺘﺄﺨﺫ ﻗﻴﻤﺔ ﺒﻴﻥ ‪ Min‬ﻭ‬ ‫‪ 1‬ـ ‪ : Position‬ﺘﻌﻁﻲ ﻤﻭﻗﻊ ﺍﻟﺸﺭﻴﻁ ﺍﻷﺯﺭﻕ ﺩﺍﺨل‬
‫‪. Max‬‬
‫‪40‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ 2‬ـ ‪ : Min‬ﺘﺤﺩﺩ ﺃﺼﻐﺭ ﻗﻴﻤﺔ ﻴﻤﻜﻥ ﺃﻥ ﺘﺄﺨﺫﻫﺎ ﺍﻟﺨﺎﺼﺔ ‪. Postion‬‬
‫‪ 3‬ـ ‪ : Max‬ﺘﺤﺩﺩ ﺃﻜﺒﺭ ﻗﻴﻤﺔ ﻴﻤﻜﻥ ﺃﻥ ﺘﺄﺨﺫﻫﺎ ﺍﻟﺨﺎﺼﺔ ‪. Postion‬‬
‫‪ 4‬ـ ‪ : Step‬ﻁﻭل ﺍﻟﺨﻁﻭﺓ ﻭﺘﺤﺩﺩ ﺍﻟﻤﺴﺎﻓﺔ ﺍﻟﺘﻲ ﻴﻘﻁﻌﻬﺎ ﺍﻟﺸﺭﻴﻁ ﺍﻷﺯﺭﻕ ﻓﻲ ﻜل ﻤﺭﺓ ﺘﻨﻔﺫ ﻓﻴﻬﺎ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪:‬‬
‫;‪progressbar1.Position := progressbar1.Position+1‬‬
‫‪ 5‬ـ ‪ : Smooth‬ﻋﻨﺩ ﺇﻋﻁﺎﺀ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻟﻬﺫﻩ ﺍﻟﺨﺎﺼﺔ ﻴﻅﻬﺭ ﺍﻟﺸﺭﻴﻁ ﺍﻷﺯﺭﻕ ﺒﺩﻭﻥ ﺘﻘﻁﻴﻌﺎﺕ ‪.‬‬
‫‪ ProgressBar‬ﻴﻌﻤل ﺒﺸﻜل‬ ‫‪ 6‬ـ ‪: orientation‬ﻋﻨﺩ ﺇﻋﻁﺎﺀ ﺍﻟﻘﻴﻤﺔ ‪ ، pbVertical‬ﺍﻟـ‬
‫ﻼ(‬
‫‪ ProgressBar‬ﻗﻴﻤﺔ ﻜﺒﻴﺭﺓ ‪ 100‬ﻤﺜ ﹰ‬ ‫ﻋﻤﻭﺩﻱ ) ﻟﻤﻼﺤﻅﺔ ﺫﻟﻙ ﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ Height‬ﻟـ‬
‫ﺸﺭﻴﻁ ﺍﻟﻘﻴﻤﺔ ‪: TrackBar:‬‬
‫ﻴﺸﺒﻪ ﻫﺫﺍ ﺍﻟﺸﺭﻴﻁ ﺍﻟﺸﺭﻴﻁ ﺍﻟﺴﺎﺒﻕ ﻭﻟﻜﻨﻪ ﻴﺨﺘﻠﻑ ﻋﻨﻪ ﺒﺈﻤﻜﺎﻨﻴﺔ ﺘﺤﺭﻴﻙ ﻤﺅﺸﺭﻩ ﺒﻭﺍﺴﻁﺔ ﺍﻟﻔﺄﺭﺓ ﻭﻤﻜﺎﻥ ﺍﻟﻤﺅﺸﺭ ﺴﻴﻌﻴﺩ‬
‫ﻗﻴﻤﺔ ﻟﻴﺴﺘﺨﺩﻤﻬﺎ ﺍﻟﺒﺭﻨﺎﻤﺞ‬
‫ﻤﺜﺎل ‪ :‬ﺃﻀﻑ ﺇﻟﻰ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟﺴﺎﺒﻕ ‪ TrackBar‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪ Win32‬ﻭﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ Max‬ﺍﻟﻘﻴﻤﺔ ‪1000‬‬
‫ﻭﺍﻟﺨﺎﺼﺔ ‪ Min‬ﺍﻟﻘﻴﻤﺔ ‪1‬‬
‫ﻭﺍﻜﺘﺏ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ Onchange‬ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ‬
‫; ‪timer1.Interval := trackbar1.Position‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺘﻐﻴﺭ ﺍﻟﺨﺎﺼﺔ ‪ Interval‬ﻜﻠﻤﺎ ﺘﻐﻴﺭ ﻤﻭﻗﻊ ﻤﺅﺸﺭ ﺍﻟـ ‪trackbar1‬‬
‫ﻋﺩل ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ‪ ontimer‬ﻟﺘﺼﺒﺢ ﺒﺎﻟﺸﻜل ‪:‬‬
‫‪if progressbar1.Position < 100 then‬‬
‫‪progressbar1.Position := progressbar1.Position+1‬‬
‫;‪else progressbar1.Position := 0‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺤﺭﻙ ﺍﻟﻤﺅﺸﺭ ﻟﺘﻼﺤﻅ ﻜﻴﻑ ﻴﻤﻜﻥ ﺃﻥ ﻨﺘﺤﻜﻡ ﺒﺴﺭﻋﺔ ﺍﻟﻤﺅﻗﺕ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ‪.‬‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺤﻠﻘﺎﺕ ‪:‬‬
‫ﻟﻥ ﺃﺸﺭﺡ ﻫﻨﺎ ﺍﻟﺤﻠﻘﺎﺕ ﻭﻟﻜﻥ ﺴﺄﺘﻌﺭﺽ ﻟﺒﻌﺽ ﺍﻟﺤﻠﻘﺎﺕ ﻭﻤﺸﺎﻜﻠﻬﺎ ‪:‬‬
‫ﺤﻠﻘﺔ ﺍﻟﺘﺄﺨﻴﺭ ﺍﻟﺯﻤﻨﻲ ‪:‬‬
‫ﺤﻠﻘﺔ ﺍﻟﺘﺄﺨﻴﺭ ﺍﻟﺯﻤﻨﻲ ﻴﻤﻜﻥ ﺘﻤﺜﻴﻠﻬﺎ ﺒﺄﻱ ﻨﻭﻉ ﻤﻥ ﺍﻟﺤﻠﻘﺎﺕ ) ‪ ( For ,Repeat ,While‬ﻭﺍﻟﻬﺩﻑ ﻤﻨﻬﺎ ﺘﺄﺨﻴﺭ‬
‫ﻋﻤل ﻤﺎ ﻟﻔﺘﺭﺓ ﺯﻤﻨﻴﺔ ﺒﺴﻴﻁﺔ ﻤﺜﺎل ‪ :‬ﺃﻀﻑ ﺯﺭ ﻭ ‪ progressbar‬ﺇﻟﻰ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ ﻭﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ‬
‫ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪:‬‬
‫;‪var i :integer‬‬
‫‪begin‬‬
‫‪for i := 0 to 100 do‬‬
‫‪progressbar1.Position := i‬‬
‫ﻨﻼﺤﻅ ﺃﻥ ﻤﺅﺸﺭ ﺍﻟﺨﻁ ﺍﻷﺯﺭﻕ ﻗﺩ ﺘﺤﺭﻙ ﺒﺴﺭﻋﺔ ﻜﺒﻴﺭﺓ ) ﻏﻴﺭ ﻤﻠﺤﻭﻅﺔ ( ﻟﺫﻟﻙ ﻨﻀﻴﻑ ﺤﻠﻘﺔ ﻟﻠﺘﺄﺨﻴﺭ ﺍﻟﺯﻤﻨﻲ ) ﻋﺩل‬
‫ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺴﺎﺒﻘﺔ ﻜﻤﺎ ﻴﻠﻲ‪:‬‬
‫;‪var i,j :integer‬‬
‫‪begin‬‬
‫‪for i := 0 to 100 do begin‬‬
‫; ‪for j := 0 to 90000 do‬‬
‫‪41‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪progressbar1.Position := i‬‬
‫;‪end‬‬
‫ﻨﻼﺤﻅ ﺃﻥ ﺍﻟﺤﻠﻘﺔ ; ‪ for j := 0 to 10000 do‬ﻻ ﺘﻨﻔﺫ ﺸﻲﺀ ﻟﻜﻨﻬﺎ ﺘﻌﻴﻕ ﺘﻨﻔﻴﺫ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﺒﻌﺽ‬
‫ﺍﻟﻭﻗﺕ ‪.‬‬
‫ﺃﻀﻑ ﺍﻵﻥ ﺇﻟﻰ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﺴﺎﺒﻕ ﺯﺭ ﺠﺩﻴﺩ ﻭﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻴﻪ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪Form1.color := clred‬‬
‫ﺤﺎﻭل ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺜﺎﻨﻲ ﺃﺜﻨﺎﺀ ﺘﻨﻔﻴﺫ ﺍﻟﺤﻠﻘﺔ ) ﺇﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻷﻭل ﺜﻡ ﺍﻟﺜﺎﻨﻲ ( ﻭﻻﺤﻅ ﺃﻨﻪ ﻻ ﻴﻤﻜﻥ ﺍﻟﻀﻐﻁ‬
‫ﻋﻠﻴﻪ ﺤﺘﻰ ﻴﻨﺘﻬﻲ ﺘﻨﻔﻴﺫ ﺍﻟﺤﻠﻘﺔ ‪.‬‬
‫ﻋﻨﺩﻤﺎ ﻨﺴﺘﺨﺩﻡ ﺍﻟﻤﺅﻗﺕ ﻟﺘﺤﺭﻴﻙ ﺍﻟـ ‪ progressbar‬ﻻ ﻴﺅﺜﺭ ﺜﻠﻙ ﻋﻠﻰ ﺒﻘﻴﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻟﻜﻥ ﻋﻨﺩ ﺍﺴﺘﺨﺩﺍﻡ‬
‫ﺍﻟﺤﻠﻘﺎﺕ ﻻ ﻴﻤﻜﻥ ﺘﻨﻔﻴﺫ ﺤﺩﺙ ﺠﺩﻴﺩ ﺤﺘﻰ ﺍﻟﺨﺭﻭﺝ ﻤﻥ ﺍﻟﺤﻠﻘﺔ ﻭﻟﺤل ﻫﺫﻩ ﺍﻟﻤﺸﻜﻠﺔ ﺃﻀﺎﻓﺕ ﺩﻟﻔﻲ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﻠﻘﺔ‬
‫ﺍﻟﺘﺄﺨﻴﺭ ﺍﻟﺯﻤﻨﻲ‬

‫‪For j := 0 to 90000000 do‬‬

‫; ‪Application.ProcessMessages‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺭﺴﺎﻟﺔ ﺒﺈﻋﻁﺎﺀ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻓﺭﺼﺔ ﻟﺘﻨﻔﻴﺫ ﺘﻌﻠﻴﻤﺎﺕ ﺃﺨﺭﻯ ﺨﺎﺭﺝ ﺍﻟﺤﻠﻘﺎﺕ ) ﺃﻱ ﻴﻤﻜﻨﻙ ﺍﻵﻥ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ‬
‫ﺍﻟﺜﺎﻨﻲ ﻭﺘﻨﻔﻴﺫ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﻤﺭﺘﺒﻁﺔ ﺒﻪ ﻋﻠﻰ ﺍﻟﺭﻏﻡ ﻤﻥ ﺃﻥ ﺍﻟﺤﻠﻘﺔ ﺘﻌﻤل ( ‪.‬‬

‫‪42‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ﺍﻟﺜﺎﻤﻨﺔ‬
‫ﺒﻌﺽ ﺍﻟﺘﻭﺍﺒﻊ ﺍﻟﻤﻌﺭﻓﺔ ﻓﻲ ﺩﻟﻔﻲ ‪:‬‬
‫ًﺃ ـ ﺘﻭﺍﺒﻊ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻷﻋﺩﺍﺩ ‪:‬‬
‫ﻤﻌﻅﻡ ﻫﺫﻩ ﺍﻟﺘﻭﺍﺒﻊ ﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﻭﺤﺩﺓ ‪ Math‬ﻟﺫﻟﻙ ﻴﺠﺏ ﺇﻀﺎﻓﺘﻬﺎ ﺇﻟﻰ ﺍﻟﻘﺴﻡ ‪ Uses‬ﻟﻠﻭﺤﺩﺓ ﺍﻟﺘﻲ ﺘﺴﺘﺩﻋﻲ ﻫﺫﻩ‬
‫ﺍﻟﺘﻭﺍﺒﻊ ‪.‬‬
‫ﻋﻤﻠﻪ‬ ‫ﺃﺴﻡ ﺍﻟﺘﺎﺒﻊ‬
‫ﻴﻌﻴﺩ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﻁﻠﻘﺔ ﻟﻌﺩﺩ ﻤﻌﻁﻰ ‪x‬‬ ‫)‪Abs(x‬‬

‫ﻴﻌﻴﺩ ﺍﻟﺘﺎﺒﻊ ﺍﻟﻘﻴﻤﺔ ‪eX‬‬ ‫)‪Exp(x‬‬

‫ﻴﻌﻴﺩ ﺃﻗﺭﺏ ﻋﺩﺩ ﻁﺒﻴﻌﻲ ﺃﻗل ﺃﻭ ﻴﺴﺎﻭﻱ ‪ X‬ﻤﺜﺎل ‪Floor (2.8) = 2; :‬‬ ‫)‪Floor(x‬‬
‫‪Floor(-2.8) = -3‬‬
‫ﻴﻌﻴﺩ ﺍﻟﺠﺯﺀ ﺍﻟﻌﺸﺭﻱ ﻟﻠﻌﺩﺩ ‪ X‬ﻤﺜﺎل ‪Frac(234.987)= 0.987:‬‬ ‫)‪Frac(x‬‬

‫ﺘﻌﻴﺩ ﺍﻟﻘﺴﻡ ﺍﻟﻁﺒﻴﻌﻲ ﻤﻥ ﻋﺩﺩ ﺤﻘﻴﻘﻲ ‪Int(234.987)= 234‬‬ ‫)‪Int(x‬‬

‫ﻴﻌﻴﺩ ﺍﻟﻘﻴﻤﺔ ‪ XY‬ﻤﺜﺎل‬ ‫)‪IntPower(X,y‬‬

‫‪intpower(2,3)=8;intpower(2,2)=4‬‬
‫ﻴﻌﻴﺩ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻓﻲ ﺤﺎل ﻜﺎﻥ ‪ X‬ﻴﺴﻌﻰ ﺇﻟﻰ ﺍﻟﻼﻨﻬﺎﻴﺔ ‪ ).‬ﻻ ﺤﻅ ﺍﻟﻤﺜﺎل ﻓﻲ‬ ‫)‪Isinfinite(X‬‬
‫ﺍﻷﺴﻔل (‬
‫ﻴﻌﻴﺩ ﺍﻟﺘﺎﺒﻊ ﺍﻟﻘﻴﻡ ‪X*2Y‬‬ ‫)‪LdExp(x,y‬‬

‫ﻴﻌﻴﺩ ﺍﻟﻠﻭﻏﺎﺭﻴﺘﻡ ﺍﻟﻁﺒﻴﻌﻲ ﻟﻠﻌﺩﺩ ‪Len(e) = 1 : X‬‬ ‫)‪Ln(x‬‬

‫ﻴﻌﻴﺩ ﺍﻟﻠﻭﻏﺎﺭﻴﺘﻡ ﺍﻟﻌﺸﺭﻱ ﻟﻠﻌﺩﺩ ‪Log10(10) = 1 : X‬‬ ‫)‪Log10(X‬‬

‫ﻴﻌﻴﺩ ﻟﻭﻏﺎﺭﻴﺘﻡ ﺍﻟﻘﻴﻤﺔ ‪ X‬ﺒﺎﻟﻨﺴﺒﺔ ﻟﻸﺴﺎﺱ ‪Y‬‬ ‫)‪LogN(Y,X‬‬

‫ﻴﻌﻴﺩ ﻗﻴﻤﺔ ﺍﻟﺭﻗﻡ ﺍﻷﻜﺒﺭ ‪Max(3,6) = 6 :‬‬ ‫)‪Max(X,Y‬‬

‫ﻴﻌﻴﺩ ﻗﻴﻤﺔ ﺍﻟﻌﺩﺩ ﺍﻷﺼﻔﺭ ‪Min(3,6) = 3:‬‬ ‫)‪Min ( X,Y‬‬

‫ﻴﻌﻴﺩ ﺍﻟﻘﻴﻤﺔ ‪3.14159265358932358‬‬ ‫‪Pi‬‬

‫‪ Y[0]*X0+Y[1]*X1+…..+Y[n]*Xn‬ﻻﺤﻅ‬ ‫ﻴﻌﻴﺩ ﻗﻴﻤﺔ ﺍﻟﺴﻠﺴﺔ‬ ‫‪Poly ( x,y:array‬‬

‫)‪of double‬‬
‫ﺍﻟﻤﺜﺎل ﻓﻲ ﺍﻷﺴﻔل‬
‫ﻴﻌﻴﺩ ﺍﻟﻘﻴﻤﺔ ‪XY‬‬ ‫)‪Power ( X,Y‬‬

‫ﻴﻌﻴﺩ ﺘﺩﻭﻴﺭ ﺍﻟﻌﺩﺩ ﺍﻟﺤﻘﻴﻘﻲ ‪Round ( 1.5) = : X‬‬ ‫)‪Round ( X‬‬

‫‪2;Round(1.4)=1;Round(1.6) =2‬‬
‫ﻴﻌﻴﺩ ﺍﻟﻘﻴﻤﺔ ‪ 1‬ﺇﺫﺍ ﻜﺎﻥ ‪ X‬ﻤﻭﺠﺒﹰﺎ ﻭ ‪ -1‬ﺇﺫﺍ ﻜﺎﻥ ‪ X‬ﺴﺎﻟﺒﹰﺎ ﻭ ‪ 0‬ﺇﺫﺍ ﻜﺎﻥ ‪X=0‬‬ ‫)‪Sing(X‬‬

‫ﻴﻌﻴﺩ ﺍﻟﻘﻴﻤﺔ ‪X2‬‬ ‫)‪Sqr(x‬‬

‫ﻴﻌﻴﺩ ﺍﻟﻘﻴﻤﺔ ‪X‬‬ ‫)‪Sqrt(x‬‬

‫ﻴﻌﻴﺩ ﺍﻟﺠﺯﺀ ﺍﻟﻁﺒﻴﻌﻲ ﻤﻥ ﺍﻟﻌﺩﺩ ‪Trunc(5.022) = : X‬‬ ‫)‪Trunc(x‬‬

‫‪43‬‬
 ‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪5;Trunc(5.999)=5‬‬
‫ﻤﺜﺎل ‪:‬‬
‫‪ 1‬ـ )‪: Isinfinite(X‬‬
‫ﺃﻀﻑ ﺯﺭ ﻭﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻴﻪ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪var v: variant‬‬
‫;‪x:double‬‬
‫‪begin‬‬
‫;‪x:=1/0‬‬
‫;)‪v:= isinfinite(x‬‬
‫‪if v then‬‬
‫;'‪form1.Caption := 'true‬‬
‫ﻻﺤﻅ ﺃﻨﻨﺎ ﻭﻀﻌﻨﺎ ﻓﻲ ‪ X‬ﺍﻟﻘﻴﻤﺔ ‪ 1/0‬ﻭﺍﻟﺘﻲ ﻟﻥ ﺘﻘﺒل ﻓﻲ ﺤﺎل ﻜﻭﻥ ‪ X‬ﻤﻥ ﺍﻟﻨﻭﻉ ‪. Integer‬‬
‫‪ 2‬ـ )‪: Poly ( x,y:array of double‬‬
‫ﺃﻀﻑ ﺯﺭ ﻭﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻴﻪ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪var v: variant‬‬
‫‪begin‬‬
‫;)]‪v:= poly (4,[2,3,4,5‬‬
‫;‪form1.Caption := v‬‬
‫ً‪ 2‬ـ ﺘﻭﺍﺒﻊ ﻗﻠﺏ ﻭﺘﺤﻭﻴل ﺍﻷﻨﻭﺍﻉ ‪ :‬ﺘﺭﻓﺽ ﻟﻐﺔ ﺩﻟﻔﻲ ﺇﻟﺤﺎﻕ ﺍﻷﻨﻭﺍﻉ ﺍﻟﻤﺨﺘﻠﻔﺔ ﺒﻌﻀﻬﺎ ﺒﺒﻌﺽ ﻟﺫﻟﻙ ﻭﺠﺩﺕ ﺒﻌﺽ‬
‫ﺍﻟﺘﻭﺍﺒﻊ ﻭﺍﻹﺠﺭﺍﺀﺍﺕ ﺍﻟﺘﻲ ﺘﻘﻭﻡ ﺒﻘﻠﺏ ﺒﻴﻥ ﺍﻷﻨﻭﺍﻉ ﺍﻟﺘﻲ ﻟﻬﺎ ﻨﻔﺱ ﺍﻟﺤﺠﻡ ﻭﻤﻥ ﻫﺫﻩ ﺍﻟﺘﻭﺍﺒﻊ ‪:‬‬
‫;‪Integer ('A') = 65; Integer ('a') = 97‬‬
‫;'‪Char ( 97 ) = 'a'; Char (48) = '0'; char (65)= 'A‬‬
‫;‪Boolean(0) = false; Boolean ( 1 ) = true‬‬
‫ﻜﻤﺎ ﻴﻤﻜﻥ ﺍﻟﺘﺤﻭﻴل ﺒﻴﻥ ﺍﻷﻨﻭﺍﻉ ﺍﻟﻤﺨﺘﻠﻔﺔ ﻓﻲ ﺍﻟﺤﺠﻡ ﺒﻭﺍﺴﻁﺔ ﺘﻭﺍﺒﻊ ﻤﻌﺭﻓﺔ ﻤﺴﺒﻘﹰﺎ ‪:‬‬
‫ﺍﻟﺠﺩﻭل ﺍﻟﺘﺎﻟﻲ ﻴﻭﻀﺢ ﺒﻌﺽ ﺘﻭﺍﺒﻊ ﺘﺤﻭﻴل ﺍﻷﻨﻭﺍﻉ ‪:‬‬
‫ﻋﻤﻠﻪ‬ ‫ﺃﺴﻡ ﺍﻟﺘﺎﺒﻊ‬
‫ﻴﺸﺒﻪ ﺍﻟﺘﺎﺒﻊ ‪ Strtoint‬ﻭﻟﻜﻨﻪ ﻴﺤﻭل ﺍﻟﻨﺹ ﺍﻟﻤﻌﻁﻰ ﺇﻟﻰ ﺍﻟﻨﻭﻉ ‪int64‬‬ ‫‪Strtoint64‬‬

‫ﻴﺤﻭل ﺍﻟﻌﺩﺩ ﺍﻟﺤﻘﻴﻘﻲ ‪ X‬ﺇﻟﻰ ﻨﺹ ‪:‬‬ ‫)‪Floattostr(X‬‬

‫'‪Floattostr(5.5e3)='5500';Floattostr(5.5)='5.5‬‬
‫)‪ FloattostrF(x,,,,‬ﻴﺤﻭل ﺍﻟﻌﺩﺩ ﺍﻟﺤﻘﻴﻘﻲ ‪ X‬ﺇﻟﻰ ﻨﺹ ﻭﻟﻜﻥ ﺒﺸﻜل ﻤﺤﺩﺩ ) ﺃﻨﻅﺭ ﺍﻷﻤﺜﻠﺔ ﻓﻲ ﺍﻷﺴﻔل ( ‪.‬‬
‫ﻴﺤﻭل ﺍﻟﻨﺹ ‪ S‬ﺇﻟﻰ ﺭﻗﻡ ﺫﻭ ﻓﺎﺼﻠﺔ ﻋﺎﺌﻤﺔ ‪Strtofloat(3.3)= 3.3; :‬‬ ‫)‪Strtofloat(s‬‬
‫‪Strtofloat( 3.3e4)=33000‬‬
‫ﻴﺤﻭل ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﺍﻟﻨﺹ ‪ S‬ﺇﻟﻰ ﺭﻗﻡ ﻤﻥ ﺍﻟﻨﻭﻉ ﻋﻤﻠﺔ ‪.‬‬ ‫)‪Strtocurr(S‬‬

‫ﻴﺤﻭل ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﺍﻟﻌﺩﺩ ﺍﻟﺼﺤﻴﺢ ‪ X‬ﺇﻟﻰ ﻋﺩﺩ ﺴﺕ ﻋﺸﺭﻱ ﻭﺘﻤﺜل ‪ y‬ﻋﺩﺩ ﺃﺭﻗﺎﻡ ﺍﻟﻨﺘﻴﺠﺔ ﻻ‬ ‫)‪Inttohex(X,y‬‬
‫ﺤﻅ ﺍﻟﻤﺜﺎل ‪:‬‬

‫‪44‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺃﻤﺜﻠﺔ ‪:‬‬
‫‪function FloatToStrF(Value: Extended; Format:‬‬ ‫ﺍﻟﺘﺎﺒﻊ ‪:‬‬
‫; ‪TFloatFormat ; Precision, Digits: Integer):string‬‬
‫‪ 1‬ـ ﻴﻅﻬﺭ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﺍﻟﻌﺩﺩ ﺍﻟﺤﻘﻴﻘﻲ ‪ Value‬ﺒﻌﺩﺓ ﻁﺭﻕ ﺤﺴﺏ ﺍﻟﻭﺴﻁﺎﺀ ﺍﻟﻤﻌﻁﺎﻩ ﻓﻲ ﺍﻟﺘﺎﺒﻊ ﻭﺨﺎﺼﺔ ﺍﻟﻭﺴﻴﻁ‬
‫‪ Format‬ﺍﻟﺫﻱ ﻴﺄﺨﺫ ﻋﺩﺓ ﻗﻴﻡ ﺴﻴﺘﻡ ﺸﺭﺤﻬﺎ ﻤﻊ ﺍﻷﻤﺜﻠﺔ ‪:‬‬
‫ﻤﺜﺎل ) ‪: ( 1‬‬
‫‪ 1‬ـ ‪Format = FFGeneral‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺘﺤﻭﻴل ﺍﻟﻌﺩﺩ ‪ Value‬ﺇﻟﻰ ﺃﻗﺭﺏ ﻋﺩﺩ ﺒﺎﻟﻔﺎﺼﻠﺔ ﺍﻟﺜﺎﺒﺘﺔ ﺃﻭ ﺍﻟﻌﺎﺌﻤﺔ ﻤﻊ ﺇﺯﺍﻟﺔ ﻜﺎﻓﺔ ﺍﻷﺼﻔﺎﺭ ﻋﻠﻰ‬
‫ﻴﺴﺎﺭ ﺍﻟﻔﺎﺼﻠﺔ ﻭﺘﺘﺄﺜﺭ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺒﺎﻟﻘﻴﻤﺔ ‪ Precision‬ﺍﻟﺘﻲ ﺘﺤﺩﺩ ﺍﻟﻌﺩﺩ ﺍﻷﻋﻅﻤﻲ ﻷﺭﻗﺎﻡ ﺍﻟﻨﺘﻴﺠﺔ ‪.‬ﻭﺍﻟﻘﻴﻤﺔ‬
‫‪ Digits‬ﺍﻟﺘﻲ ﺘﺤﺩﺩ ﻋﺩﺩ ﺃﺭﻗﺎﻡ ﺍﻷﺱ‬
‫ﺃﻀﻑ ﺇﻟﻰ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;)‪form1.caption := floattostrf(55.2723e+3, ffgeneral,5,2‬‬
‫ﻼ ﺍﻟﻘﻴﻡ ﺒﻌﺩ ﺍﻟﻔﺎﺼﻠﺔ ﻷﻨﻪ ﺍﻟﻭﺴﻴﻁ ‪ Precision‬ﻴﺴﺎﻭﻱ ‪ ، 5‬ﻏﻴﺭ ﺍﻵﻥ‬
‫ﺴﻴﻌﻴﺩ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﺍﻟﻘﻴﻤﺔ ‪ 55272‬ﻤﺘﺠﺎﻫ ﹰ‬
‫ﺍﻟﺭﻗﻡ ‪ 5‬ﺇﻟﻰ ‪ 7‬ﻭﻻﺤﻅ ﺘﻐﻴﺭ ﺍﻟﻨﺘﻴﺠﺔ ﺇﻟﻰ ﺍﻟﺸﻜل ‪ ، 55272.3‬ﻏﻴﺭ ﺍﻟﺭﻗﻡ ﺍﻟﺴﺎﺒﻕ ﺇﻟﻰ ‪ 4‬ﻭﻻﺤﻅ ﻅﻬﻭﺭ ﺍﻟﻨﺘﻴﺠﺔ‬
‫ﺒﺎﻟﺸﻜل ‪. 527e4 :‬‬
‫‪ 2‬ـ ‪Format = FFExponent‬‬
‫ﺴﺘﻘﻭﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺘﺤﻭﻴل ﺍﻟﻌﺩﺩ ﺍﻟﺤﻘﻴﻘﻲ ﺇﻟﻰ ﻋﺩﺩ ﺫﻱ ﻓﺎﺼﻠﺔ ﻋﺎﺌﻤﺔ ﻤﻥ ﺍﻟﺸﻜل )‪ (ddd.edd‬ﻭﺘﺤﺩﺩ ﺍﻟﺨﺎﺼﺔ‬
‫‪ Precision‬ﻫﻨﺎ ﻋﺩﺩ ﺃﺭﻗﺎﻡ ﺍﻟﻨﺘﻴﺠﺔ ﻭﺍﻟﻘﻴﻤﺔ ‪ Digits‬ﺘﺘﺭﺍﻭﺍﺡ ﺒﻴﻥ ‪ 0..4‬ﻭﺘﺤﺩﺩ ﻋﺩﺩ ﺃﺭﻗﺎﻡ ﺍﻷﺱ ‪.‬‬
‫;)‪form1.caption := floattostrf(52.34, ffexponent,8,3‬‬
‫ﺴﻴﻌﻴﺩ ﺍﻟﺘﺎﺒﻊ ﺍﻟﻨﺘﻴﺠﺔ ‪ 5.2340000e+001‬ﻓﻲ ﺤﺎل ﺘﻐﻴﺭ ﺍﻟﺭﻗﻡ ‪ 8‬ﺇﻟﻰ ‪ 4‬ﻭﺍﻟﺭﻗﻡ ‪ 3‬ﺇﻟﻰ ‪ 2‬ﺘﺼﺒﺢ ﺍﻟﻨﺘﻴﺠﺔ ‪:‬‬
‫‪5.234E+01‬‬
‫‪ 3‬ـ ‪Format = fffixed‬‬
‫ﺴﺘﻘﻭﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺘﺤﻭﻴل ﺍﻟﻌﺩﺩ ﺍﻟﺤﻘﻴﻘﻲ ﺇﻟﻰ ﻋﺩﺩ ﺫﻭ ﻓﺎﺼﻠﺔ ﺜﺎﺒﺘﺔ ﺤﻴﺙ ﻴﺤﺩﺩ ﻋﺩﺩ ﺍﻷﺭﻗﺎﻡ ﺒﻌﺩ ﺍﻟﻔﺎﺼﻠﺔ ﺒﺎﻟﻘﻴﻤﺔ‬
‫‪: Digits‬‬
‫;)‪form1.caption := floattostrf(100.36, fffixed,6,1‬‬
‫ﺴﻴﻌﻴﺩ ﺍﻟﺘﺎﺒﻊ ﺍﻟﻘﻴﻤﺔ ‪ 100.4‬ﻷﻨﻪ ﻹﻅﻬﺎﺭ ﺭﻗﻡ ﻭﺍﺤﺩ ﺒﻌﺩ ﺍﻟﻨﺘﻴﺠﺔ ﻗﺎﻡ ﺍﻟﺘﺎﺒﻊ ﺒﺘﺩﻭﻴﺭ ﺍﻟﻨﺘﻴﺠﺔ ‪.‬‬
‫ﻓﻲ ﺤﺎل ﻜﺎﻨﺕ ﻗﻴﻤﺔ ‪ Precision‬ﺃﺼﻐﺭ ﻤﻥ ﻋﺩﺩ ﺃﺭﻗﺎﻡ ﺍﻟﻌﺩﺩ ﺴﻴﻌﻴﺩ ﺍﻟﺘﺎﺒﻊ ﺍﻟﻨﺘﻴﺠﺔ ﺒﺎﻟﻔﺎﺼﻠﺔ ﺍﻟﻌﺎﺌﻤﺔ ‪.‬‬
‫‪ 4‬ـ ‪Format = ffNumber‬‬
‫ﺘﺸﺒﻪ ﺍﻟﺤﺎﻟﺔ ﺍﻟﺴﺎﺒﻘﺔ ﻭﻟﻜﻥ ﻤﻊ ﺇﻅﻬﺎﺭ ﻓﻭﺍﺼل ﺒﻴﻥ ﺍﻵﻻﻑ ﻤﻊ ﺘﻘﺭﻴﺏ ﺍﻟﻨﺘﻴﺠﺔ ‪.‬‬
‫;)‪form1.caption := floattostrf(195784430.36, ffnumber,10,5‬‬
‫ﺴﻴﻌﻴﺩ ﺍﻟﺘﺎﺒﻊ ﺍﻟﻘﻴﻤﺔ ‪. 195,784,430.4000‬‬

‫‪45‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ 5‬ـ ‪: Format = ffcurrency‬‬
‫ﺴﻴﻌﻴﺩ ﺍﻟﺘﺎﺒﻊ ﻨﻔﺱ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺴﺎﺒﻘﺔ ﻭﻟﻜﻥ ﻤﻊ ﺫﻜﺭ ل‪.‬ﺱ ﺒﺠﺎﻨﺏ ﺍﻟﻨﺎﺘﺞ ) ﻴﻌﻴﺩ ﺍﻟﺘﺎﺒﻊ ﺍﺴﻡ ﺍﻟﻌﻤﻠﺔ ﺍﻟﻤﺤﺩﺩﺓ ﻓﻲ ﺍﻟﺠﻬﺎﺯ ﻋﻥ‬
‫ﻁﺭﻴﻕ ﺍﻋﺩﺍﺩﺍﺕ ﺇﻗﻠﻴﻤﻴﺔ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﻟﻭﺤﺔ ﺍﻟﺘﺤﻜﻡ ( ‪.‬‬
‫;)‪form1.caption := floattostrf(195784430.36, ffcurrency,10,5‬‬
‫ل‪.‬ﺱ ‪195,784,430.4000‬‬
‫ﺍﻟﺘﺎﺒﻊ)‪: Inttohex(X,Y‬‬
‫ﻤﺜﺎل ‪ inttohex(2345,1); :‬ﺴﻴﻌﻴﺩ ﺍﻟﻘﻴﻤﺔ ‪ 929‬ﺍﻟﺘﻲ ﺘﻜﺎﻓﺊ ﺍﻟﻌﺩﺩ ﺍﻟﻌﺸﺭﻱ ‪2345‬‬
‫ﻻ ﺤﺎﺠﺔ ﻟﺘﺤﻭﻴل ﺍﻟﻌﺩﺩ ﺍﻟﺴﺕ ﻋﺸﺭﻱ ﺇﻟﻰ ﻋﺩﺩ ﻁﺒﻴﻌﻲ ﻓﻲ ﺩﻟﻔﻲ ﻷﻨﻪ ﻴﻤﻜﻥ ﺇﻟﺤﺎﻕ ﺍﻹﻋﺩﺍﺩ ﺍﻟﺴﺕ ﻋﺸﺭﻴﺔ ﻤﺒﺎﺸﺭﺓ ﻓﻲ‬
‫ﺍﻟﻤﺘﺤﻭﻻﺕ ﺍﻟﻁﺒﻴﻌﻴﺔ ‪ Integer‬ﺃﻭ ﺍﻟﺤﻘﻴﻘﻴﺔ ‪ I:= $929 ) ...‬ﺘﻜﺎﻓﺊ ‪ I:=2345‬ﻭ ‪ J:=$F‬ﺘﻜﺎﻓﺊ‬
‫‪( J=15‬‬
‫ﻫﻨﺎﻙ ﺁﻻﻑ ﺍﻟﺘﻭﺍﺒﻊ ﻭﺍﻹﺠﺭﺍﺀﺍﺕ ﺍﻟﻤﻌﺭﻓﺔ ﻓﻲ ﺩﻟﻔﻲ ﻭﻻ ﻴﻤﻜﻥ ﺸﺭﺤﻬﺎ ﻜﻠﻬﺎ ﻟﺫﻟﻙ ﺴﻨﺘﻌﺭﻑ ﺍﻵﻥ ﻋﻠﻰ ﻁﺭﻕ ﺍﻟﺒﺤﺙ ﻋﻥ‬
‫ﺘﺎﺒﻊ ﻤﻠﻔﺎﺕ ﻓﻲ ﻤﻠﻔﺎﺕ ﺍﻟﻤﺴﺎﻋﺩﺓ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺩﻟﻔﻲ ‪:‬‬
‫ﺍﻟﺤﺎﻟﺔ ﺍﻷﻭﻟﻰ ‪ :‬ﺍﻟﺘﺎﺒﻊ ﻤﻌﺭﻭﻑ ﻭﻟﻜﻨﻨﺎ ﺒﺤﺎﺠﺔ ﺇﻟﻰ ﺘﺫﻜﺭ ﺍﻟﻭﺴﻁﺎﺀ ﺍﻟﺘﺎﺒﻌﺔ ﻟﻪ ‪:‬‬
‫ﺍﻜﺘﺏ ﺇﺴﻡ ﺍﻟﺘﺎﺒﻊ ﻓﻲ ﺃﻱ ﻤﻜﺎﻥ ﻓﻲ ﻤﺤﺭﺭ ﺍﻟﺸﻴﻔﺭﺓ ﻭﺇﻀﻐﻁ ‪ F1‬ﺴﻴﻅﻬﺭ ﺸﺭﺡ ﻜﺎﻤل ﻟﻠﺘﺎﺒﻊ ﺒﺎﻟﻠﻐﺔ ﺍﻹﻨﻜﻠﻴﺯﻴﺔ ‪ ،‬ﺇﺫﺍ ﻜﺎﻥ‬
‫ﻷﺤﺩ ﺍﻟﻭﺴﻁﺎﺀ ﻋﺩﺓ ﻗﻴﻡ ) ﻜﻤﺎ ﻫﻲ ﺍﻟﺤﺎﻟﺔ ﻓﻲ ﺍﻟﻭﺴﻴﻁ ‪ Format‬ﻟﻠﺘﺎﺒﻊ ‪ ( Floattostrf‬ﺴﻴﻅﻬﺭ ﻨﻭﻉ ﻫﺫﺍ‬
‫ﺍﻟﻭﺴﻴﻁ ﺒﺎﻟﻠﻭﻥ ﺍﻷﺨﻀﺭ ﻴﻤﻜﻨﻨﺎ ﺒﺎﻟﻀﻐﻁ ﻋﻠﻴﻪ ﺍﻻﻨﺘﻘﺎل ﻟﺼﻔﺤﺔ ﺘﺸﺭﺡ ﻫﺫﻩ ﺍﻟﻘﻴﻡ ‪.‬‬
‫ﺍﻟﺤﺎﻟﺔ ﺍﻟﺜﺎﻨﻴﺔ ‪ :‬ﺍﻟﺘﺎﺒﻊ ﻏﻴﺭ ﻤﻌﺭﻭﻑ ﻭﻟﻜﻨﻨﺎ ﻨﺘﺫﻜﺭ ﺘﺎﺒﻊ ﻗﺭﻴﺏ ﺃﻭ ﻤﺸﺎﺒﻪ ﻟﻪ ‪:‬‬
‫ﻓﺭﻀ ﹰﺎ ﺃﺭﻴﺩ ﺃﻥ ﺃﺠﺩ ﺍﻟﺘﺎﺒﻊ ﺍﻟﺫﻱ ﻴﺤﻭل ﺍﻟﻨﺹ ﺇﻟﻰ ﺍﻟﻌﺩﺩ ﺍﻟﺤﻘﻴﻘﻲ ﻤﻥ ﻨﻭﻉ ﻋﻤﻠﺔ ‪ ، Currency‬ﻨﺤﻥ ﻨﻌﻠﻡ ﺒﻭﺠﻭﺩ‬
‫ﺘﺎﺒﻊ ﻴﺤﻭل ﺍﻟﻨﺹ ﺇﻟﻰ ﻋﺩﺩ ﺤﻘﻴﻘﻲ ﻭﻫﻭ ‪ Strtofloat‬ﻟﺫﻟﻙ ﻨﻜﺘﺏ ﺍﺴﻡ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﻓﻲ ﻤﺤﺭﺭ ﺍﻟﺸﻴﻔﺭﺓ ﻭﻨﻀﻐﻁ‬
‫‪ ، F1‬ﺴﻴﻅﻬﺭ ﺍﻵﻥ ﺸﺭﺡ ﻟﻠﺘﺎﺒﻊ ‪ ، Strtofloat‬ﺴﺘﻼﺤﻅ ﺍﻵﻥ ﻭﺠﻭﺩ ﺍﻟﻜﻠﻤﺔ ‪ See Also‬ﺒﺎﻟﻠﻭﻥ ﺍﻷﺨﻀﺭ‬
‫ﻓﻲ ﺃﻋﻠﻰ ﺍﻟﺼﻔﺤﺔ ‪ ،‬ﻓﻲ ﺤﺎل ﺍﻟﻀﻐﻁ ﻋﻠﻴﻬﺎ ﺴﺘﻅﻬﺭ ﻫﺫﻩ ﺍﻟﻭﺼﻠﺔ ﻗﺎﺌﻤﺔ ﺒﺎﻟﺘﻭﺍﺒﻊ ﺍﻟﻤﺘﻌﻠﻘﺔ ﺒﺎﻟﺘﺎﺒﻊ ﺍﻟﻤﺫﻜﻭﺭ ﺃﻭ ﺍﻟﺘﻭﺍﺒﻊ‬
‫ﺍﻟﻤﺸﺎﺒﻬﺔ ﻟﻪ ) ﻴﻤﻜﻥ ﺃﻥ ﻨﺨﺘﺎﺭ ﻤﻨﻬﺎ ‪ ،( Strtocurr‬ﻜﻤﺎ ﻴﻭﺠﺩ ﺃﺤﻴﺎﻨﹰﺎ ﺍﻟﻭﺼﻠﺔ ﺒﻌﺩ ﺍﻟﻌﻨﻭﺍﻥ ‪ ) Category‬ﻓﻲ‬
‫ﻤﺜﺎﻟﻨﺎ ‪ ( Floating point Conversion Routines‬ﺒﺎﻟﻀﻐﻁ ﻋﻠﻴﻬﺎ ﺴﺘﻅﻬﺭ ﻜل ﺍﻟﺘﻭﺍﺒﻊ‬
‫ﺍﻟﻤﺘﺼﻠﺔ ﺒﻤﻭﻀﻭﻉ ﺍﻟﺘﺎﺒﻊ ‪ Strtofloat‬ﻓﻲ ﻤﺜﺎﻟﻨﺎ ) ﺴﺘﻅﻬﺭ ﻜل ﺍﻟﺘﻭﺍﺒﻊ ﺍﻟﻤﺘﻌﻠﻘﺔ ﺒﺘﺤﻭﻴل ﺍﻟﻌﺩﺩ ﺍﻟﺤﻘﻴﻘﻲ ﺇﻟﻰ‬
‫ﺼﻴﻐﺔ ﺃﺨﺭﻯ ( ‪.‬‬
‫ﺍﻟﺤﺎﻟﺔ ﺍﻟﺜﺎﻟﺜﺔ ‪ :‬ﻨﺭﻴﺩ ﺃﻥ ﻨﺒﺤﺙ ﻋﻥ ﺘﺎﺒﻊ ﻟﻪ ﺼﻔﺔ ﻤﻌﻴﻨﺔ ‪:‬‬
‫) ﻓﺭﻀﹰﺎ ﻨﺭﻴﺩ ﺃﻥ ﻨﺒﺤﺙ ﻋﻥ ﺘﺎﺒﻊ ﺭﻴﺎﻀﻲ ( ﻤﻥ ﺍﻟﻤﻌﺭﻭﻑ ﺃﻥ ﻤﻌﻅﻡ ﺍﻟﺘﻭﺍﺒﻊ ﺍﻟﺭﻴﺎﻀﻴﺔ ﺘﻨﺘﻤﻲ ﺇﻟﻰ ﺍﻟﻭﺤﺩﺓ ‪Math‬‬
‫ﻼ ( ﻭﻨﻀﻐﻁ ‪ F1‬ﺴﻴﻅﻬﺭ ﺸﺭﺡ ﺍﻟﺘﺎﺒﻊ‬
‫ﻟﺫﻟﻙ ﻴﻤﻜﻥ ﺃﻥ ﻨﻜﺘﺏ ) ﺃﻱ ﺘﺎﺒﻊ ﻴﻨﺘﻤﻲ ﻟﻠﻭﺤﺩﺓ ‪ ) math‬ﺍﻟﺘﺎﺒﻊ ‪ Power‬ﻤﺜ ﹰ‬
‫‪ Power‬ﻤﻊ ﻅﻬﻭﺭ ﺃﺴﻡ ﺍﻟﻭﺤﺩﺓ ﻓﻲ ﺍﻷﻋﻠﻰ ) ﺒﺎﻟﻀﻐﻁ ﻋﻠﻴﻪ ﺘﻅﻬﺭ ﻗﺎﺌﻤﺔ ﺒﺠﻤﻴﻊ ﺍﻟﺘﻭﺍﺒﻊ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﻭﺤﺩﺓ‬
‫‪.( math‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻤﻌﻅﻡ ﺘﻭﺍﺒﻊ ﺍﻟﺘﺤﻭﻴل ) ‪( ..... Strtoint‬ﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﻭﺤﺩﺓ ‪. Sysutil‬‬

‫‪46‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺤﺎﻟﺔ ﺍﻟﺭﺍﺒﻌﺔ ‪ :‬ﻻﻨﻌﺭﻑ ﺃﻱ ﺸﻲﺀ ﻤﻥ ﺍﻟﺤﺎﻻﺕ ﺍﻟﺴﺎﺒﻘﺔ ‪:‬‬
‫ﻼ ( ﻤﻥ ﻗﻭﺍﺌﻡ ﺍﻟﺩﻟﻔﻲ ﻨﺨﺘﺎﺭ ‪Help Æ‬‬‫ﻨﺭﻴﺩ ﺃﻥ ﻨﻭﺠﺩ ﺘﺎﺒﻊ ﻤﺎ ﻴﻘﻭﻡ ﺒﻌﻤﻠﻴﺔ ﻤﻌﻴﻨﺔ ) ﺘﺎﺒﻊ ﺍﻟﺠﻴﺏ ﺠﺏ ) ﻴﻪ ( ﻤﺜ ﹰ‬
‫‪Delphi help‬‬
‫ﻨﺨﺘﺎﺭ ﺒﻌﺩﻫﺎ ﺍﻟﺼﻔﺤﺔ ‪) Find‬ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺼﻔﺤﺔ ‪ Find‬ﻷﻭل ﻤﺭﺓ ﻴﻅﻬﺭ ﺼﻨﺩﻭﻕ ﺤﻭﺍﺭ ﻟﺘﺤﺩﻴﺩ ﻁﺭﻕ‬
‫ﺍﻟﺒﺤﺙ )ﺃﺨﺘﺭ ﺍﻟﺨﻴﺎﺭﺍﺕ ﺍﻷﻓﺘﺭﺍﻀﻴﺔ(‬
‫ﻴﻅﻬﺭ ﺒﻌﺩﻫﺎ ﺼﻨﺩﻭﻕ ﺤﻭﺍﺭ ﻨﻜﺘﺏ ﻓﻴﻪ ﺍﺴﻡ ﺍﻟﺘﺎﺒﻊ ﻓﻲ ﺍﻟﻠﻐﺔ ﺍﻹﻨﻜﻠﻴﺯﻴﺔ ) ‪ Sin‬ﻓﻲ ﻤﺜﺎﻟﻨﺎ ( ﻓﻴﻅﻬﺭ ﻓﻲ ﺍﻷﺴﻔل ﺠﻤﻴﻊ‬
‫ﺍﻟﻜﻠﻤﺎﺕ ﺍﻟﻤﻜﺘﻭﺒﺔ ﻓﻲ ﻤﻠﻔﺎﺕ ﺍﻟﻤﺴﺎﻋﺩﺓ ﻭﺍﻟﺘﻲ ﺘﺒﺩﺃ ﺒﺎﻷﺤﺭﻑ ﺍﻟﻤﻜﺘﻭﺒﺔ ) ‪ ( Sin‬ﻭﻴﻅﻬﺭ ﺃﺴﻔل ﻫﺫﻩ ﺍﻟﻘﺎﺌﻤﺔ ﻗﺎﺌﻤﺔ ﺃﺨﺭﻯ‬
‫ﺒﺎﻟﻌﻨﻭﺍﻨﻴﻥ ﺍﻟﺘﻲ ﺘﺤﻭﻱ ﻫﺫﻩ ﺍﻟﻜﻠﻤﺔ ﺤﺎﻭل ﺃﻥ ﺘﺨﺘﺎﺭ ﻤﻨﻬﺎ ﻁﻠﺒﻙ ﻭﺍﻀﻐﻁ ﻋﻠﻴﻪ ﻤﺭﺘﻴﻥ ﻓﻴﻅﻬﺭ ﻨﺹ ﺍﻟﻤﺴﺎﻋﺩﺓ ﺍﻟﻤﺭﺘﺒﻁ‬
‫‪Help‬‬ ‫ﺒﻬﺫﺍ ﺍﻟﻌﻨﻭﺍﻥ ) ﻓﻲ ﻤﺜﺎﻟﻨﺎ ‪Other Standard routine‬ﻭﻟﻠﻌﻭﺩﺓ ﺇﻟﻰ ﺍﻟﻘﺎﺌﻤﺔ ﺃﺨﺘﺭ ﺍﻟﺴﺎﺒﻘﺔ‬
‫‪. ( topic‬‬
‫ﻤﻼﺤﻅﺎﺕ ‪:‬‬
‫ﻟﻤﻌﺭﻓﺔ ﻋﻤل ﺃﻱ ﻋﻨﺼﺭ ﻓﻲ ﺩﻟﻔﻲ ﺃﺨﺘﺭﻩ ﻭﺃﻀﻐﻁ ﻋﻠﻰ ‪. F1‬‬
‫ﻟﻤﻌﺭﻓﺔ ﻋﻤل ﺃﻱ ﺨﺎﺼﺔ ﺘﺎﺒﻌﺔ ﻟﻌﻨﺼﺭ ﻤﺎ ﻓﻲ ﺩﻟﻔﻲ ﺃﺨﺘﺭ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ‪.... F1‬‬

‫‪47‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ﺍﻟﺘﺎﺴﻌﺔ‬
‫ﺼﻨﺎﺩﻴﻕ ﺍﻟﺤﻭﺍﺭ ‪: Dialog‬‬
‫ﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻥ ﺼﻨﺎﺩﻴﻕ ﺠﺎﻫﺯﺓ ﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﺼﻔﺤﺔ ‪ Dialogs‬ﻭﻤﻬﻤﺘﻬﺎ ﻓﺘﺢ ﻨﻭﺍﻓﺫ ﺨﺎﺼﺔ ﺒﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ) ﻟﻔـﺘﺢ‬
‫ﻭﺤﻔﻅ ﻤﻠﻑ ﻭﻟﺘﺤﺩﻴﺩ ﻟﻭﻥ ﻭﻟﻔﺘﺢ ﻤﻠﻑ ﺼﻭﺭﺓ ﻭﻟﻠﻁﺒﺎﻋﺔ ﻭﻟﻠﺒﺤﺙ ‪ ( ....‬ﻭﺴﻨﺩﺭﺱ ﺒﻌﺽ ﻫﺫﻩ ﺍﻟﺼﻨﺎﺩﻴﻕ ﺒﺎﻟﺘﻔﺼﻴل ‪:‬‬
‫ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ﻓﺘﺢ ﻤﻠﻑ ‪: OpenDialog‬‬
‫ﻴﺴﺘﺨﺩﻡ ﻟﻔﺘﺢ ﻤﻠﻑ ﻤﺎ ‪،‬ﺤﻴﺙ ﻴﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻤﻌﺭﻭﻓﺔ ﻟﻔﺘﺢ‬
‫ﻤﻠﻑ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﻭﻴﻨﺩﻭﺯ ﻭﺤﻴﺙ ﻴﻤﻜﻨﻨـﺎ ﻤـﻥ ﻫـﺫﻩ‬
‫ﺍﻟﻨﺎﻓﺫﺓ ﺍﺨﺘﻴﺎﺭ ﺍﻟﻤﻠﻑ ﻭﺍﻟﻀﻐﻁ ﻋﻠـﻰ ﻓـﺘﺢ ) ‪( Open‬‬
‫ﻭﺴﻴﻌﻴﺩ ﺍﻟﻌﻨـﺼﺭ ﺃﺴـﻡ ﺍﻟﻤﻠـﻑ ﺍﻟﻤﺨﺘـﺎﺭ ﺒﺎﻟﺨﺎﺼـﺔ‬
‫‪FileName‬‬
‫ـ ﺴﻨﺒﺩﺃ ﺒﻤﺜﺎل ﺒﺴﻴﻁ ﻭﺴﻨﺤﺎﻭل ﺍﻟﺘﻌﺭﻑ ﻋﻠﻰ ﺍﻟﻌﻨـﺼﺭ‬
‫ﺒﺸﻜل ﺃﻓﻀل ﻻﺤﻘﹰﺎ ‪:‬‬
‫ﻤﺜﺎل ‪ :‬ﺃﻀﻑ ﻋﻨﺼﺭ ﻤﺫﻜﺭﺓ ‪ Memo‬ﻭﺯﺭ ﺇﻟﻰ ﻤﺸﺭﻭﻉ‬
‫ﺠﺩﻴﺩ ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺍﻟﻌﻨﺼﺭ ‪Opendialog‬‬
‫ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪IF Opendialog1.Execute then‬‬
‫; ) ‪memo1.Lines.LoadFromFile(opendialog1.FileName‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺴﻴﻅﻬﺭ ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ﺃﺨﺘﺭ ﺃﻱ ﻤﻠﻑ ﻨﺼﻲ ) ‪ ( TXT‬ﻭﺍﻀـﻐﻁ ﻋﻠـﻰ ‪open‬‬
‫ﺴﻴﻤﻜﻨﻙ ﺍﻵﻥ ﻤﺸﺎﻫﺩﺓ ﻤﺤﺘﻭﻴﺎﺕ ﺍﻟﻤﻠﻑ ﻓﻲ ﺍﻟﻤﺫﻜﺭﺓ ‪.‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ OpenDialog1.Execute‬ﺘﻘﻭﻡ ﺒﺈﻅﻬﺎﺭ ﻨﺎﻓﺫﺓ ﺍﻟﺤﻭﺍﺭ ﻓﺘﺢ ﻤﻠﻑ ﻭﺘﻌﻴﺩ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻓـﻲ ﺤـﺎل‬
‫ﺍﺨﺘــﺎﺭ ﺍﻟﻤــﺴﺘﺨﺩﻡ ﺃﺤــﺩ ﺍﻟﻤﻠﻔــﺎﺕ ﻭﻀــﻐﻁ ﻋﻠــﻰ ﺍﻟــﺯﺭ ﻓــﺘﺢ ) ‪ ( Open‬ﻭﻓــﻲ ﻫــﺫﻩ ﺍﻟﺤﺎﻟــﺔ‬
‫‪ opendialog1.FileName‬ﺴﺘﺤﺘﻭﻱ ﻋﻠﻰ ﺍﺴﻡ ﺍﻟﻤﻠﻑ‪ ،‬ﻭﺘﻌﻴﺩ ﺍﻟﻘﻴﻤﺔ ‪ False‬ﻓﻲ ﺤﺎل ﺃﻏﻠﻕ ﺍﻟﻤـﺴﺘﺨﺩﻡ‬
‫ﺼــﻨﺩﻭﻕ ﺍﻟﺤــﻭﺍﺭ ﺃﻭ ﻀــﻐﻁ ﻋﻠــﻰ ﺍﻟــﺯﺭ ﺇﻟﻐــﺎﺀ ﺍﻷﻤــﺭ) ‪ ( Cancel‬ﻭﻓــﻲ ﻫــﺫﻩ ﺍﻟﺤﺎﻟــﺔ‬
‫‪ opendialog1.FileName‬ﺴﺘﺤﺘﻭﻱ ﻋﻠﻰ ﻓﺭﺍﻍ‪.‬‬
‫ﺍﻟﺨﺎﺼﺔ ‪ : Filter‬ﺘﺤﺩﺩ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﻨﻭﻉ ﺍﻟﻤﻠﻔﺎﺕ ﺍﻟﺘﻲ ﺴﺘﻅﻬﺭ ﻓﻲ ﺍﻟﻨﺎﻓﺫﺓ ‪ ،‬ﺍﺨﺘـﺭ ﺍﻟﺨﺎﺼـﺔ ‪ Filter‬ﻤـﻥ‬
‫‪Filter‬‬ ‫ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﻨﻘﺎﻁ ﺍﻟﺜﻼﺙ ‪ ...‬ﻓﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﻲ ﺘﺤﺩﺩ ﻨﻭﻉ ﺍﻟﻤﻠﻔﺎﺕ ﻓـﻲ ﺍﻟﻌﻤـﻭﺩ‬
‫‪ Name‬ﺃﻜﺘﺏ ﻤﻠﻑ ﻨﺹ ‪ ،‬ﻭﺍﻟﻌﻤﻭﺩ ‪ Filter‬ﺃﻜﺘﺏ ‪ *.txt‬ﺃﻏﻠﻕ ﺍﻟﻨﺎﻓﺫﺓ ﻭﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺴـﺘﻼﺤﻅ ﺃﻥ ﺼـﻨﺩﻭﻕ‬
‫ﺍﻟﺤﻭﺍﺭ ﻻ ﻴﻅﻬﺭ ﺇﻻ ﺍﻟﻤﺠﻠﺩﺍﺕ ﻭﺍﻟﻤﻠﻔﺎﺕ ﻤﻥ ﺍﻟﻨﻭﻉ ﺍﻟﻨﺼﻲ ‪ ، Txt‬ﻭﺴﺘﻅﻬﺭ ﻓﻲ ﺃﺴﻔل ﺍﻟﺼﻨﺩﻭﻕ ﻓﻲ ﺍﻟﻌﻨـﻭﺍﻥ ﺍﻟـﺫﻱ‬
‫ﻴﺸﻴﺭ ﺇﻟﻰ ﻨﻭﻉ ﺍﻟﻤﻠﻔﺎﺕ ‪ " Files Type‬ﻤﻠﻑ ﻨﺹ " ‪ ،‬ﻋﺩ ﺇﻟﻰ ﺍﻟﺨﺎﺼﺔ ‪ Filter‬ﺃﺩﺨل ﻓﻲ ﺍﻟـﺴﻁﺭ ﺍﻟﺜـﺎﻨﻲ‬
‫ﻟﻠﻌﻤﻭﺩ ‪ " Filter Name‬ﻤﻠﻑ ﺩﻓﻌﻲ "ﻭﻓﻲ ﺍﻟﻌﻤﻭﺩ ‪ "*.Bat " Filter‬ﺜﻡ ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺘﺎﻟﻲ ﺍﻟﻌﻤﻭﺩ ﺍﻷﻭل "‬
‫ﺠﻤﻴﻊ ﺍﻟﻤﻠﻔﺎﺕ " ﻭﺒﺠﺎﻨﺒﻪ " *‪. " *.‬‬

‫‪48‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻵﻥ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺴﻴﻅﻬﺭ ﺼﻨﺩﻭﻕ ﻓﺘﺢ ﺍﻟﻤﻠﻔﺎﺕ ﺤﻴﺙ ﻴﻤﻜﻨﻙ ﺍﻵﻥ ﺍﺨﺘﻴﺎﺭ ﻨـﻭﻉ ﺍﻟﻤﻠﻔـﺎﺕ ﺍﻟﺘـﻲ‬
‫ﺴﺘﻅﻬﺭ ﻋﻥ ﻁﺭﻴﻕ ‪. Files Type‬‬
‫ﺍﻟﺨﺎﺼﺔ ‪ : FilterIndex‬ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﻟﺘﺤﺩﻴﺩ ﻨﻭﻉ ﺍﻟﻤﻠﻔﺎﺕ ﺍﻻﻓﺘﺭﺍﻀﻲ ﻭﺘﺄﺨﺫ ﺍﻟﻘﻴﻤﺔ ‪ 1‬ﻟﺘـﺸﻴﺭ ﺇﻟـﻰ‬
‫ﺍﻟﻔﻠﺘﺭ ﺍﻷﻭل ﻭ‪ 2‬ﺇﻟﻰ ﺍﻟﺜﺎﻨﻲ ‪....‬‬
‫ﺍﻟﺨﺎﺼﺔ ‪ : InitialDir‬ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺒﺘﺤﺩﻴﺩ ﺍﻟﻔﻬﺭﺱ ﺍﻻﺒﺘﺩﺍﺌﻲ ﺍﻟﺫﻱ ﺴﻴﻌﻤل ﻓﻴﻪ ﺍﻟﺼﻨﺩﻭﻕ ﺃﻜﺘﺏ ﻓﻲ ﻫﺫﻩ‬
‫ﺍﻟﺨﺎﺼﺔ ﺍﻟﻘﻴﻤﺔ \‪ C:‬ﻭﺴﻴﻔﺘﺢ ﻋﻨﺩﻫﺎ ﺍﻟﺼﻨﺩﻭﻕ ﻓﻲ ﺍﻟﻔﻬﺭﺱ \‪... C:‬‬
‫ﺍﻟﺨﺎﺼﺔ ‪ : Title‬ﺘﻤﻜﻨﻙ ﺇﻅﻬﺎﺭ ﺍﻟﺨﺎﺼﺔ ﻤﻥ ﺇﻅﻬﺎﺭ ﻨﺹ ﻤﻌﻴﻥ ﻓﻲ ﺸﺭﻴﻁ ﺍﻟﻌﻨﻭﺍﻥ ﻟﻨﺎﻓﺫﺓ ﻓﺘﺢ ﺍﻟﻤﻠﻔﺎﺕ ﺍﺩﺨل ﺍﻟﻘﻴﻤﺔ‬
‫"ﺃﺨﺘﺭ ﻤﻠﻑ ﻤﺎ ﻟﻴﻘﻭﻡ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒﻔﺘﺤﻪ "‪.‬‬
‫ﺍﻟﺨﺎﺼﺔ ‪ : Option‬ﻴﻨﺒﺜﻕ ﻋﻥ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﻟﻌﺩﻴﺩ ﻤﻥ ﺍﻟﺨﻭﺍﺹ ﺤﺎﻭل ﻤﺭﺍﺠﻌﺔ ﺘﻌﻠﻴﻤﺎﺕ ﺩﻟﻔـﻲ ﻟﻠﺤـﺼﻭل ﻋﻠـﻰ‬
‫ﻤﻌﻠﻭﻤﺎﺕ ﻋﻥ ﻋﻤل ﻜل ﺨﺎﺼﺔ‪.‬‬
‫ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ﺤﻔﻅ ﻤﻠﻑ ‪: SaveDialog‬‬
‫ﻴﻘﻭﻡ ﻫﺫﺍ ﺍﻟﻤﻠﻑ ﺒﻔﺘﺢ ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ﺤﻔﻅ ﻤﻠﻑ ﻭﻫﻭ ﻴﺸﺒﻪ ﺍﻟﺼﻨﺩﻭﻕ ﺍﻟﺴﺎﺒﻕ ﺒﻁﺭﻴﻘﺔ ﺍﻻﺴﺘﺩﻋﺎﺀ ﻭﺍﻟﺨﺼﺎﺌﺹ ﻟﺫﻟﻙ ﻻ‬
‫ﺩﺍﻋﻲ ﻹﻋﺎﺩﺓ ﺸﺭﺡ ﺍﻟﺨﺼﺎﺌﺹ ‪.‬‬
‫ﻤﺜﺎل ‪:‬‬
‫‪ Caption‬ﻟﻠﺯﺭ ﺍﻟﻘﻴﻤﺔ " ﺤﻔﻅ " ﺜﻡ ﺃﻋﻁ‬ ‫ﺃﻀﻑ ﺯﺭ ﻭ ‪ SaveDialog‬ﺇﻟﻰ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﺴﺎﺒﻕ ﻭﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ‬
‫‪ SaveDialog‬ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ 1‬ـ ﺍﻟﺨﺎﺼﺔ ‪ : Filter‬ﻤﻠﻑ ﻨﺹ ‪*.txt ........‬‬
‫‪ :‬ﻤﻠﻑ ﺩﻓﻌﻲ ‪*.bat .......‬‬
‫‪ 2‬ـ ﺍﻟﺨﺎﺼﺔ ‪ : Defaultext‬ﺍﻟﻘﻴﻤﺔ ‪ : .Txt‬ﻫﺫﻩ ﺍﻟﻘﻴﻤﺔ ﻀﺭﻭﺭﻴﺔ ﻟﺘﺤﺩﻴﺩ ﺍﻤﺘﺩﺍﺩ ﺍﻟﻤﻠﻑ ﺍﻟﺫﻱ ﺴﻴﺘﻡ ﺤﻔﻅﻪ ‪.‬‬
‫ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪if savedialog1.Execute then‬‬
‫) ‪memo1.Lines.SaveToFile(savedialog1.FileName‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺤﻔﻅ ﻭﺍﻜﺘﺏ ﺍﻻﺴﻡ ﺍﻟﺫﻱ ﺘﺭﻴﺩ ‪....‬‬
‫‪ Option‬ﻫﻲ ﺍﻟﺨﺎﺼﺔ ‪OfOverwritePrompt‬‬ ‫ﺇﺤﺩﻯ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﻤﻬﻤﺔ ﻟﻬﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻭﺍﻟﺘﺎﺒﻌﺔ ﻟﻠﺨﺎﺼﺔ‬
‫ﺃﻋﻁ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﻟﻘﻴﻤﺔ ‪ Ture‬ﻟﻜﻲ ﻴﺘﻡ ﺘﻨﺒﻴﻪ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻗﺒل ﺃﻥ ﻴﺤﻔﻅ ﻤﻠﻑ ﻓﻭﻕ ﻤﻠﻑ ﻤﻥ ﻨﻔﺱ ﺍﻹﺴﻡ ‪.‬‬
‫ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ‪: OpenPictureDialog‬‬
‫ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ﻫﺫﺍ ﻴﺸﺒﻪ ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ﻓﺘﺢ ﻤﻠﻑ ﻭﻴﺨﺘﻠﻑ ﻋﻨﻪ ﺒﻅﻬﻭﺭ ﻗﺴﻡ ﻴﺠﺎﻨﺏ ﺍﻟﻤﻠﻔﺎﺕ ﻹﻅﻬﺎﺭ ﺍﻟﺼﻭﺭ ﻗﺒـل‬
‫ﻓﺘﺤﻬﺎ ‪ ،‬ﻤﻥ ﺍﻟﻤﻼﺤﻅ ﺃﻥ ﺍﻟﺨﺎﺼﺔ ‪ Filter‬ﻟﻬﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻤﺠﻬﺯﺓ ﺒﺄﻨﻭﺍﻉ ﺍﻟﻤﻠﻔﺎﺕ ﺍﻟﺘﻲ ﻴﻤﻜﻥ ﻟﻠﺩﻟﻔﻲ ﺍﻟﺘﻌﺎﻤل ﻤﻌﻬﺎ ‪.‬‬
‫ﻤﺜﺎل‪:‬‬
‫ﺃﻀﻑ ﺯﺭ ﻭﻋﻨﺼﺭ ‪ Image‬ﺇﻟﻰ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ ﻭﺃﻀﻑ ﻜﺫﻟﻙ ﺍﻟﻌﻨﺼﺭ ‪. OpenPictureDialog‬‬
‫ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪if OpenPictureDialog1.Execute then‬‬
‫) ‪image1.Picture.LoadFromFile(OpenPictureDialog1.FileName‬‬
‫‪49‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﻭﺍﺨﺘﺭ ﺃﻱ ﺼﻭﺭﺓ ﻟﺘﻼﺤﻅ ﻅﻬﻭﺭﻫﺎ ﺇﻟﻰ ﻴﻤﻴﻥ ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ﻭﺒﺎﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟـﺯﺭ‬
‫‪ Open‬ﺴﺘﻅﻬﺭ ﺍﻟﺼﻭﺭﺓ ﻓﻲ ﺍﻟﻌﻨﺼﺭ ‪. Image‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﺭﻏﻡ ﻭﺠﻭﺩ ﻤﻠﻔﺎﻥ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Jpg‬ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ Filter‬ﻻ ﺘﻅﻬﺭ ﺍﻟﻤﻠﻔﺎﺕ ‪ *.jpg‬ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴـﺫ ﻭﺇﺫﺍ‬
‫ﺃﺭﺩﺕ ﺇﻅﻬﺎﺭﻫﺎ ﻗﻡ ﺒﺈﻀﺎﻓﺔ ﺍﺴﻡ ﺍﻟﻭﺤﺩﺓ ‪ Jpeg‬ﺇﻟﻰ ﺍﻟﻘﺴﻡ ‪. Uses‬‬
‫ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ‪: SavePictureDialog‬‬
‫‪ ) ..........................................................................................‬ﻨﻔﺱ ﺍﻟﻜﻼﻡ ﺍﻟﺴﺎﺒﻕ (‬
‫‪.............‬‬
‫ﻤﺜﺎل ‪:‬‬
‫ﺃﻀﻑ ﺯﺭ ﻭﻋﻨﺼﺭ ‪ SavePictureDialog‬ﺇﻟﻰ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﺴﺎﺒﻕ ﻭ ﺃﻋﻁ ‪SavePictureDialog‬‬
‫ﺍﻟﺨﺎﺼﺔ‬
‫‪ DefaultExt‬ﺍﻟﻘﻴﻤﺔ ‪ .Bmp‬ﻭﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪if SavePictureDialog1.Execute then‬‬
‫)‪image1.Picture.SaveToFile(SavePictureDialog1.FileName‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺜﻡ ﺍﻓﺘﺢ ﺼﻭﺭﺓ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﺯﺭ ﺍﻷﻭل ﻭﺍﺤﻔﻅﻬﺎ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﺯﺭ ﺍﻟﺜﺎﻨﻲ ) ﻴﻤﻜﻨﻙ ﺃﻴﻀﹰﺎ ﺘﻐﻴﺭ ﺍﻤﺘﺩﺍﺩ ﻤﻠﻑ‬
‫ﺍﻟﺼﻭﺭﺓ ﺃﻱ ﺘﻐﻴﺭ ﻨﻭﻋﻬﺎ ﻋﻥ ﻁﺭﻴﻕ ﺘﻐﻴﺭ ﺍﻻﻤﺘﺩﺍﺩ ﻓﻲ ﺃﺴﻔل ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ‪. ( Save As Type‬‬
‫ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ﺍﻟﺨﻁﻭﻁ ‪: FontDialog‬‬
‫ﻴﻘﻭﻡ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﺒﺈﻅﻬﺎﺭ ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ﺍﺨﺘﻴﺎﺭ ﺨﻁ ﺤﻴﺙ ﻴﻤﻜﻨﻨﺎ ﻫﺫﺍ ﺍﻟﺼﻨﺩﻭﻕ ﻤﻥ ﺘﺤﺩﻴﺩ ﻨﻭﻉ ﻭﻨﻤﻁ ﻭﺤﺠﻡ ﻭﻟـﻭﻥ‬
‫ﺍﻟﺨﻁ ‪.‬‬
‫ﺃﻀﻑ ﺯﺭ ﻭﻋﻨﺼﺭ ‪ Label‬ﻭ ﻋﻨﺼﺭ ‪ FontDialog‬ﺇﻟﻰ ﺒﺭﻨﺎﻤﺞ ﺠﺩﻴﺩ ﻭﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟـﺯﺭ‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪if Fontdialog1.Execute then‬‬
‫; ‪label1.Font := fontdialog1.Font‬‬
‫ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ﺘﺤﺩﻴﺩ ﻟﻭﻥ ‪: ColorDialog‬‬
‫ﻴﻘﻭﻡ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﺒﺈﻅﻬﺎﺭ ﺼﻨﺩﻭﻕ ﺤﻭﺍﺭ ﻻﺨﺘﻴﺎﺭ ﻟﻭﻥ ﺤﻴﺙ ﻴﻤﻜﻥ ﺍﺨﺘﻴﺎﺭ ﺍﻟﻠﻭﻥ ﻤﻥ ﻋﺩﺩ ﻜﺒﻴﺭ ﺠﺩﹰﺍ ﻤﻥ ﺍﻷﻟﻭﺍﻥ ‪.‬‬
‫ﺃﻀﻑ ﺯﺭ ﻭﻋﻨﺼﺭ ‪ ColorDialog‬ﺇﻟﻰ ﺒﺭﻨﺎﻤﺞ ﺠﺩﻴﺩ ﻭﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪if colorDialog1.Execute then‬‬
‫; ‪form1.Color := colordialog1.Color‬‬
‫ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ‪ ColorDialog‬ﻴﻅﻬﺭ ﻓﻴﻪ ﺯﺭ ﻋﻨﻭﺍﻨﻪ ‪ Define Custom colors‬ﺒﺎﻟﻀﻐﻁ ﻋﻠﻴـﻪ‬
‫ﻴﻅﻬﺭ ﻟﻭﺡ ﺍﻷﻟﻭﺍﻥ ﺍﻟﺫﻱ ﻴﻤﻜﻥ ﻤﻥ ﺨﻼﻟﻪ ﺘﺤﺩﻴﺩ ﺍﻟﻠﻭﻥ ﺃﻭ ﻴﻤﻜﻥ ﻜﺘﺎﺒﺔ ‪ RGB‬ﻜﺘﺎﺒﺔ ﻓﻲ ﺤﺎل ﻤﻌﺭﻓﺘﻬﺎ ‪.‬‬
‫ﻤﻼﺤﻅـﺔ ‪ :‬ﺘﺘﺒﻊ ﺠﻤﻴﻊ ﺼﻨﺎﺩﻴﻕ ﺍﻟﺤﻭﺍﺭ ‪ Dialog‬ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ﺍﻟﻤﺴﺘﺨﺩﻡ‪ ،‬ﺃﻱ ﺃﻨﻬﺎ ﺴﺘﺨﺘﻠﻑ ﺤﺴﺏ ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل‬
‫ﻓﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ﻓﺘﺢ ﻤﻠﻑ ﻓﻲ ﻭﻴﻨﺩﻭﺯ ‪ 98‬ﻴﺨﺘﻠﻑ ﻋﻨﻪ ﻓﻲ ﻭﻴﻨﺩﻭﺯ ‪ Xp‬ﻭﺒﺎﻟﺘﺎﻟﻲ ﺴﻴﺨﺘﻠﻑ ﺸﻜل ﺍﻟﺼﻨﺩﻭﻕ ﻤﻥ ﻨﻅـﺎﻡ‬
‫ﺘﺸﻐﻴل ﺇﻟﻰ ﺁﺨﺭ ﻭﻟﻜﻨﻪ ﺴﻴﺅﺩﻱ ﻨﻔﺱ ﺍﻟﻭﻅﻴﻔﺔ ﺒﻨﻔﺱ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ‪ ،‬ﻜﻤﺎ ﺘﺘﺄﺜﺭ ﻫﺫﻩ ﺍﻟﺼﻨﺎﺩﻴﻕ ﺒﻠﻐﺔ ﺍﻟﻨﻅﺎﻡ ﺃﻱ ﺃﻨﻬﺎ ﺴـﺘﻅﻬﺭ‬

‫‪50‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺒﺎﻟﻠﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ ﻓﻲ ﺤﺎل ﻜﺎﻨﺕ ﻭﺍﺠﻬﺎﺕ ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ﺍﻟﻤﺴﺘﺨﺩﻡ ﺒﺎﻟﻌﺭﺒﻴﺔ ﻭﺒﺎﻟﻠﻐﺔ ﺍﻹﻨﻜﻠﻴﺯﻴﺔ ﻓﻲ ﺤﺎل ﻜﺎﻨـﺕ ﻭﺍﺠﻬـﺎﺕ‬
‫ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ﺒﺎﻟﻠﻐﺔ ﺍﻹﻨﻜﻠﻴﺯﻴﺔ ‪.‬‬

‫‪51‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ﺍﻟﻌﺎﺸﺭﺓ‬
‫ﺍﻟﺘﻌﺭﻑ ﻋﻠﻰ ﺍﻟﻌﻨﺼﺭ ‪ ) : MaskEdit‬ﺍﻟﺼﻔﺤﺔ ‪( Additional‬‬
‫ﻴﺸﺒﻪ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻋﻨﺼﺭ ﺍﻟﺘﺤﺭﻴﺭ ‪ Edit‬ﻭﻴﺨﺘﻠﻑ ﻋﻨﻪ ﺒﺈﻤﻜﺎﻨﻴﺔ ﺘﺤﺩﻴﺩ ﺸﻜل ﺍﻟﻨﺹ ﺍﻟﻤﺩﺨل ﻭﻟﻠﺘﻌﺭﻑ ﻋﻠﻰ ﻫﺫﻩ ﺍﻤﻴـﺯﺓ‬
‫ﺍﺫﻫﺏ ﺇﻟﻰ ﺍﻟﺨﺎﺼﺔ ‪ Editmask‬ﻤﻥ ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ﻭﺒﺎﻟﻀﻐﻁ ﻋﻠﻰ ‪ ...‬ﺴﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫ﲢﺪﻳﺪ ﺍﻟﻘﻨﺎﻉ‬

‫ﺃﻗﻨﻌﺔ ﺟﺎﻫﺰﺓ‬
‫ﺍﻟﺮﻣﺰ ﺍﻟﺬﻱ ﺳﻴﻈﻬﺮ‬ ‫) ﺃﻣﺜﻠﺔ (‬
‫ﻣﻜﺎﻥ ﺍﻟﻔﺮﺍﻍ‬

‫ﻟﺘﺠﺮﺑﺔ ﺍﻟﻨﺺ ﺍﳌﺪﺧﻞ‬

‫ﲢﻤﻴﻞ ﺃﻗﻨﻌﺔ ﺟﺎﻫﺰﺓ‬

‫ﻤﺜﺎل ‪:‬‬
‫‪ 1‬ـ ﺃﻀﻑ ﻋﻨﺼﺭ ‪ MaskEdit‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪ Additional‬ﺇﻟﻰ ﺒﺭﻨﺎﻤﺞ ﺠﺩﻴﺩ ﻭﺍﺨﺘﺭ ﺍﻟﺨﺎﺼـﺔ ‪ Editmask‬ﻤـﻥ‬
‫ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ﻭﺍﺨﺘﺭ ﻤﻥ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺴﺎﺒﻘﺔ ﻓﻲ ﺍﻟﻘﺴﻡ ) ‪ Date ( Sample Masks‬ﻭﺍﻀﻐﻁ ﻋﻠﻰ ‪ Ok‬ﻋﻨﺩﻫﺎ ﺴﻴﻅﻬﺭ‬
‫ﺍﻟﻌﻨﺼﺭ ﺒﺎﻟﺸﻜل __‪ __/__/‬ﺍﻵﻥ ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺤﺎﻭل ﺍﻹﺩﺨﺎل ﺇﻟﻰ ﺍﻟﻌﻨﺼﺭ ﻭﻻﺤﻅ ﺃﻨﻪ ﻻ ﻴﻤﻜﻨـﻙ ﺇﺩﺨـﺎل ﺴـﻭﻯ‬
‫ﺍﻷﺭﻗﺎﻡ ‪.‬‬
‫ﺘﺤﺩﻴﺩ ﺍﻟﻘﻨﺎﻉ ‪:‬‬
‫ﻨﻼﺤﻅ ﺃﻥ ﺍﻟﻘﻴﻡ ﻓﻲ ﺍﻟﺤﻘل ﺘﺤﺩﻴﺩ ﺍﻟﻘﻨﺎﻉ ﻋﺒﺎﺭﺓ ﻋﻥ ‪ 0‬ﺃﻭ ‪ 9‬ﺃﻭ ‪ L‬ﺃﻭ … ﻓﻤﺎﺫﺍ ﺘﻌﻨﻲ ﻫﺫﻩ ﺍﻟﺭﻤﻭﺯ ‪:‬‬
‫‪ : 9‬ﻴﺴﺘﻁﻴﻊ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺇﺩﺨﺎل ﺭﻗﻡ ﻓﻲ ﻤﻜﺎﻥ ﻫﺫﺍ ﺍﻟﺭﻤﺯ ﻭﻻ ﻴﻤﻜﻥ ﺇﺩﺨﺎل ﺍﻷﺤﺭﻑ ﻤﻊ ﺇﻤﻜﺎﻨﻴﺔ ﻋﺩﻡ ﺇﺩﺨﺎل ﺃﻱ ﺭﻗـﻡ )‬
‫ﻼ ﻓﻲ ﺤﺎل ﻜﺎﻥ ﺍﻟﻘﻨﺎﻉ ‪، 99999‬ﻴﺴﺘﻁﻴﻊ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺇﺩﺨﺎل ﻋﺩﺩ ﻤﻜﻭﻥ ﻤﻥ ﺨﻤﺱ ﺃﺭﻗﺎﻡ ﺃﻭ ﺃﺭﺒﻊ ﺃﻭ ﺜﻼﺙ ‪ ....‬ﻭﻻ‬
‫ﻤﺜ ﹰ‬
‫ﻴﺴﺘﻁﻴﻊ ﺇﺩﺨﺎل ﺍﻷﺤﺭﻑ (‬
‫‪ : 0‬ﻴﺴﺘﻁﻴﻊ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺇﺩﺨﺎل ﺭﻗﻡ ﻓﻲ ﻤﻜﺎﻥ ﻫﺫﺍ ﺍﻟﺭﻤﺯ ﻭﻻ ﻴﻤﻜﻥ ﺇﺩﺨﺎل ﺍﻷﺤﺭﻑ ) ﻓﻲ ﺤﺎل ﻜﺎﻥ ﺍﻟﻘﻨـﺎﻉ ‪، 00000‬‬
‫ﻓﻌﻠﻰ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺇﺩﺨﺎل ﺨﻤﺱ ﺃﺭﻗﺎﻡ ﺤﺼﺭﹰﺍ ﻭﻻ ﻴﻤﻜﻥ ﺃﺭﺒﻌﺔ ‪ (...‬ﻭﻓﻲ ﺤﺎل ﺍﺩﺨل ﺍﻟﻤﺴﺘﺨﺩﻡ ﺃﺭﺒﻌﺔ ﺴﻴﺼﺩﺭ ﺍﻟﺒﺭﻨـﺎﻤﺞ‬
‫ﺭﺴﺎﻟﺔ ﺨﻁﺄ ﻋﻥ ﺨﺭﻭﺝ ﺍﻟﻤﺅﺸﺭ ﻤﻥ ﺍﻟﻌﻨﺼﺭ ‪.‬‬
‫‪ : L‬ﻴﺴﺘﻁﻴﻊ ﺍﻟﻤﺴﺘﺨﺩﻡ‪ ،‬ﺇﺩﺨﺎل ﺃﺤﺭﻑ ﻤﻜﺎﻥ ﻫﺫﺍ ﺍﻟﺭﻤﺯ ﻭﻻ ﻴﻤﻜﻥ ﺇﺩﺨﺎل ﺍﻷﺭﻗﺎﻡ ) ﻓﻲ ﺤﺎل ﻜﺎﻥ ﺍﻟﻘﻨﺎﻉ ‪ LLLL‬ﻓﻌﻠﻰ‬
‫ﺍﻟﻤﺴﺘﺨﺩﻡ ﺇﺩﺨﺎل ﺃﺭﺒﻊ ﺃﺤﺭﻑ ﺤﺼﺭﹰﺍ (‪.‬‬
‫‪ : l‬ﺇﺩﺨﺎل ﺃﺤﺭﻑ ﻓﻘﻁ ﻤﻊ ﺇﻤﻜﺎﻨﻴﺔ ﻋﺩﻡ ﺍﻹﺩﺨﺎل ‪.....‬‬
‫‪52‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ : a‬ﺇﺩﺨﺎل ﺃﺤﺭﻑ ﻤﻊ ﺃﺭﻗﺎﻡ ﻤﻊ ﺇﻤﻜﺎﻨﻴﺔ ﻋﺩﻡ ﺍﻹﺩﺨﺎل ‪....‬‬
‫‪ : A‬ﺇﺩﺨﺎل ﺃﺤﺭﻑ ﻤﻊ ﺃﺭﻗﺎﻡ ‪ ...‬ﺤﺼﺭﹰﺍ ‪.‬‬
‫ﻴﻭﺠﺩ ﻤﺠﻤﻭﻋﺔ ﺃﺨﺭﻯ ﻤﻥ ﺍﻟﺭﻤﻭﺯ ﻴﻤﻜﻥ ﻤﺭﺍﺠﻌﺘﻬﺎ ﻓﻲ ﻤﻠﻔﺎﺕ ﺍﻟﻤﺴﺎﻋﺩﺓ ﺍﻟﺘﺎﺒﻌﺔ ﻟﻠﺩﻟﻔﻲ ‪............‬‬
‫ﺍﻟﻌﻨﺼﺭ ‪ ) : MonthCalendar‬ﺍﻟﺼﻔﺤﺔ ‪( Win32‬‬
‫ﻴﺴﺘﺨﺩﻡ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻹﻅﻬﺎﺭ ﺍﻟﺘﺎﺭﻴﺦ‪ ،‬ﻭﻴﺴﺘﻁﻴﻊ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺇﺩﺨﺎل ﺍﻟﺘﺎﺭﻴﺦ ﻋﺒﺭﻩ ‪...‬‬
‫ﻓﻲ ﺤﺎل ﺃﺭﺩﻨﺎ ﻤﻥ ﺍﻟﻌﻨﺼﺭ ﺇﻅﻬﺎﺭ ﺘﺎﺭﻴﺦ ﺍﻟﻴﻭﻡ ﻓﻲ ﻜل ﻤﺭﺓ ﻨﻔﺘﺢ ﺍﻟﺒﺭﻨﺎﻤﺞ‪ ،‬ﻋﻠﻴﻨﺎ ﺇﺩﺨﺎل ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓـﻲ ﺍﻟﺤـﺩﺙ‬
‫ـﺼﺭ ‪:‬‬ ‫ـﻭﻱ ﺍﻟﻌﻨـــ‬ ‫ـﻲ ﺘﺤـــ‬ ‫ـﺫﺓ ﺍﻟﺘـــ‬
‫‪ OnCreate‬ﻟﻠﻨﺎﻓـــ‬
‫;‪MonthCalendar1.Date := date‬‬
‫ﻟﻠﺤﺼﻭل ﻋﻠﻰ ﺍﻟﺘﺎﺭﻴﺦ ﺍﻟﻤﺩﺨل ﻤﻥ ﻗﺒل ﺍﻟﻤﺴﺘﺨﺩﻡ ﻨﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺃﻭ ﺤﺩﺙ ﺍﻟـﻀﻐﻁ‬
‫ﻋﻠﻰ ﺍﻟﻌﻨﺼﺭ ﻨﻔﺴﻪ ‪:‬‬
‫;)‪form1.Caption := datetostr(MonthCalendar1.Date‬‬
‫ﻋﻥ ﺇﻋﻁﺎﺀ ﺍﻟﺨﺎﺼﺔ ‪ Align‬ﻟﻬﺫﺍ ﺍﻟﻌﻨﺼﺭ ﺍﻟﻘﻴﻤﺔ ‪ alClient‬ﻴﻅﻬﺭ ﻤﻔﻜﺭﺓ ﺒﻌﺩﺓ ﺃﺸﻬﺭ ) ﺤﺴﺏ ﺤﺠﻡ ﺍﻟﻨﻤﻭﺫﺝ ( ‪..‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻴﻭﺠﺩ ﻓﻲ ﺍﻟﺼﻔﺤﺔ ‪ Sample‬ﺍﻟﻌﻨﺼﺭ ‪ Calendar‬ﻭﻫﻭ ﻴﺸﺒﻪ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺴﺎﺒﻕ ﺇﻟﻰ ﺤﺩ ﻤﺎ ‪.‬‬
‫ﺍﻟﻌﻨﺼﺭ ‪ ) : DateTimePicker‬ﺍﻟﺼﻔﺤﺔ ‪( Win32‬‬
‫ﻴﺴﺘﺨﺩﻡ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻹﻅﻬﺎﺭ ) ﺇﺩﺨﺎل ( ﺍﻟﺘﺎﺭﻴﺦ ﺃﻭ ﺍﻟﻭﻗﺕ ‪:‬‬
‫‪ 1‬ـ ﻴﻅﻬﺭ ﺍﻟﺘﺎﺭﻴﺦ ﻓﻲ ﺤﺎل ﻜﺎﻨﺕ ﺍﻟﺨﺎﺼﺔ ‪ Kind‬ﺘﺴﺎﻭﻱ ‪ dtkDate‬ﻭﻴﻤﻜﻥ ﺘﻐﻴﺭ ﺍﻟﺘﺎﺭﻴﺦ ﻋﻥ ﻁﺭﻴﻕ ﻤﻔﺎﺘﻴﺢ ﺍﻷﺴﻬﻡ‬
‫ﺃﻭ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺴﻬﻡ ﺍﻟﻤﺠﺎﻭﺭ ﻟﻠﻌﻨﺼﺭ ﺤﻴﺙ ﻴﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺸﻜل ﻤـﺸﺎﺒﻪ ﻟﻠﻌﻨـﺼﺭ ‪MonthCalendar‬‬
‫ﺍﻟﺫﻱ ﻴﻤﻜﻥ ﺘﺤﺩﻴﺩ ﺍﻟﺘﺎﺭﻴﺦ ﻤﻥ ﺨﻼﻟﻪ‪ ،‬ﻜﻤﺎ ﻴﻤﻜﻥ ﺘﻐﻴﺭ ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﺔ ‪ DateMode‬ﺇﻟﻰ ‪ dmUpDown‬ﻴﻅﻬﺭ ﺴﻬﻤﻴﻥ‬
‫ﺃﻋﻠﻰ ﻭﺃﺴﻔل ﻹﺩﺨﺎل ﺍﻟﺘﺎﺭﻴﺦ ‪....‬‬
‫‪ 2‬ـ ﻴﻅﻬﺭ ﺍﻟﻭﻗﺕ ﻓﻲ ﺤﺎل ﻜﺎﻨﺕ ﺍﻟﺨﺎﺼﺔ ‪ Kind‬ﺘﺴﺎﻭﻱ ‪ dtkTime‬ﻭﺤﺘﻰ ﻴﺘﻡ ﺘﺤﺩﻴﺙ ﺍﻟﻭﻗﺕ ﻴﺠﺏ ﺇﻀﺎﻓﺔ ‪Timer‬‬
‫ﻭﻜﺘﺎﺒﺔ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺍﻟﺤﺩﺙ ‪: OnTimer‬‬
‫;‪DateTimePicker1.Time := time‬‬
‫‪ 3‬ـ ﻴﻤﻜﻥ ﺍﻟﺤﺼﻭل ﻋﻠﻰ ﺍﻟﻭﻗﺕ ﻤﻥ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;) ‪Form1.Caption := TimeToStr(DateTimePicker1.Time‬‬
‫ﻭﻴﻜﻭﻥ ﺍﻟﺤﺼﻭل ﻋﻠﻰ ﺍﻟﺘﺎﺭﻴﺦ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪:‬‬
‫;) ‪Form1.Caption := Datetostr(DateTimePicker1.date‬‬
‫ﺍﻟﻌﻨﺼﺭ ‪ ) : PageControl‬ﺍﻟﺼﻔﺤﺔ ‪( Win32‬‬
‫ﻴﻘﻭﻡ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﺒﺈﻅﻬﺎﺭ ﺼﻔﺤﺎﺕ ﻤﺴﺘﻘﻠﺔ ﻭﻟﻠﺘﻌﺭﻑ ﻋﻠﻰ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﺴﻨﺒﺩﺃ ﺒﻤﺜﺎل ‪:‬‬
‫ﻤﺜﺎل ‪:‬‬
‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﻋﻨﺼﺭ ﺍﻟﺼﻔﺤﺎﺕ ‪ PageControl‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪ ،Win32‬ﺍﻀﻐﻁ ﻋﻠـﻰ ﺍﻟﻌﻨـﺼﺭ‬
‫ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﻤﻴﻨﻲ ﻭﺃﺨﺘﺭ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪ New Page‬ﻋﻨﺩﻫﺎ ﺴﺘﻅﻬﺭ ﺼﻔﺤﺔ ﺠﺩﻴﺩﺓ ﺒﺎﺴﻡ ‪ ، Tabsheet1‬ﺃﻋﺩ ﺍﻟﺨﻁـﻭﺓ‬
‫ﺍﻷﺨﻴﺭﺓ ﻤﺭﺘﻴﻥ ﻹﻅﻬﺎﺭ ‪ TabSheet2‬ﻭ ‪. TabSheet3‬‬

‫‪53‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﺨﺘﺭ ﺍﻟﺼﻔﺤﺔ ﺍﻷﻭﻟﻰ ‪ Tabsheet1‬ﻭﺃﻋﻁﻬﺎ ﺍﻟﺨﺎﺼـﺔ ‪ " Caption‬ﺍﻟﺘـﺎﺭﻴﺦ " ﻭﺃﻀـﻑ ﻓـﻲ ﺩﺍﺨﻠﻬـﺎ ﺍﻟﻌﻨـﺼﺭ‬
‫‪. MonthCalendar‬‬
‫ـﺼﺭ‬
‫ـﺎ ﺍﻟﻌﻨـ‬
‫ـﻑ ﺇﻟﻴﻬـ‬
‫ـﺕ " ﻭﺃﻀـ‬
‫ـﺔ ‪ " Caption‬ﺍﻟﻭﻗـ‬
‫ـﺎ ﺍﻟﺨﺎﺼـ‬
‫ـﺔ ‪ TabSheet2‬ﻭﺃﻋﻁﻬـ‬
‫ـﺼﻔﺤﺔ ﺍﻟﺜﺎﻨﻴـ‬
‫ـﺭ ﺍﻟـ‬
‫ﺍﺨﺘـ‬
‫‪ DateTimePicker‬ﻭﺃﻋﻁﻪ ﺍﻟﺨﺎﺼﺔ ‪ Kind‬ﺍﻟﻘﻴﻤﺔ ‪ dtkTime‬ﻭﻻ ﺘﻨﺱ ﺇﻀﺎﻓﺔ ﻤﺅﻗﺕ ﻟﺘﺤﺩﻴﺙ ﺍﻟﻭﻗﺕ‪...‬‬
‫ﺍﺨﺘﺭ ﺍﻟﺼﻔﺤﺔ ﺍﻟﺜﺎﻟﺜﺔ ‪ TabSheet3‬ﻭﺃﻋﻁﻬﺎ ﺍﻟﺨﺎﺼﺔ ‪ " Caption‬ﺍﻟﺘـﺎﺭﻴﺦ ﻭﺍﻟﻭﻗـﺕ " ﻭﺃﻀـﻑ ﺇﻟﻴﻬـﺎ ﻋﻨـﺼﺭﻴﻥ‬
‫‪ DateTimePicker‬ﺃﻋﻁ ﺇﺤﺩﺍﻫﻤﺎ ﺍﻟﺨﺎﺼﺔ ‪ Kind‬ﺍﻟﻘﻴﻤﺔ ‪.... dtkTime‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻻﺤﻅ ﻜﻴﻔﻴﺔ ﺍﻻﻨﺘﻘﺎل ﺒﻴﻥ ﺍﻟﺼﻔﺤﺎﺕ ‪..‬‬
‫ﺍﺨﺘﺭ ﺍﻟﻌﻨﺼﺭ ‪ ) PageControl‬ﻴﻤﻜﻥ ﺍﻻﻨﺘﻘﺎل ﻤﻥ ﻋﻨﺼﺭ ﺍﺒﻥ ﺇﻟﻰ ﻋﻨﺼﺭ ﺃﺏ ﺒﺎﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﻤﻔﺘـﺎﺡ ‪ ESC‬ﻤـﻥ‬
‫ﻟﻭﺤﺔ ﺍﻟﻤﻔﺎﺘﻴﺢ ( ﻭﺃﻋﻁﻪ ﺍﻟﺨﺎﺼﺔ ‪ Align‬ﺍﻟﻘﻴﻤﺔ ‪ alClient‬ﻋﻨﺩﻫﺎ ﺴﻴﺄﺨﺫ ﺍﻟﻌﻨﺼﺭ ﺤﺠﻡ ﺍﻟﻨﻤﻭﺫﺝ ﺒﺎﻟﻜﺎﻤل ‪.‬‬
‫ﺃﻀﻑ ﺍﻟﻌﻨﺼﺭ ‪ ImageList‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪ Win32‬ﻭﺍﻀﻐﻁ ﻋﻠﻴﺔ ﻤﺭﺘﻴﻥ ﻴﻅﻬﺭ ﺼﻨﺩﻭﻕ ﺤـﻭﺍﺭ ﺍﺨﺘـﺭ ﻤﻨـﻪ ‪Add‬‬
‫ﻹﻀﺎﻓﺔ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﺼﻭﺭ‪ ،‬ﺍﻀﻐﻁ ﺒﻌﺩﻫﺎ ﻋﻠﻰ ‪ ،Ok‬ﻋﺩ ﺒﻌﺩﻫﺎ ﺇﻟﻰ ﺍﻟﻌﻨـﺼﺭ ‪ PageControl‬ﻭﺃﻋـﻁ ﺍﻟﺨﺎﺼـﺔ‬
‫‪ Images‬ﺍﻟﻘﻴﻤﺔ ‪ ImageList1‬ﻭﻋﻨﺩﻫﺎ ﺴﺘﻅﻬﺭ ﺍﻟﺼﻭﺭ ﺒﺠﺎﻨﺏ ﻋﻨﻭﺍﻨﻴﻥ ﺍﻟﺼﻔﺤﺎﺕ‪ ،‬ﻨﺴﺘﻁﻴﻊ ﺍﺨﺘﻴﺎﺭ ﺼـﻭﺭ ﻤﺤـﺩﺩﺓ‬
‫ﻟﺼﻔﺤﺔ ﻤﺎ ﺒﺎﺨﺘﻴﺎﺭ ﺍﻟﺼﻔﺤﺔ ‪ tabSheet‬ﺜﻡ ﻜﺘﺎﺒﺔ ﺭﻗﻡ ﺍﻟﺼﻭﺭﺓ ﺍﻟﻤﻁﻠﻭﺒﺔ ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪... ImageIndex‬‬
‫ـ ﻴﻤﻜﻥ ﺘﺤﻭﻴل ﻤﻭﻀﻊ ﺍﺨﺘﻴﺎﺭ ﺍﻟﺼﻔﺤﺎﺕ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﺨﺎﺼﺔ ‪ TapPosition‬ﺤﻴﺙ ﻴﻤﻜﻥ ﺃﻥ ﺘﻜﻭﻥ ﻓﻲ ﺍﻷﺴـﻔل ﺃﻭ‬
‫ﻋﻠﻰ ﺍﻟﻴﻤﻴﻥ ﺃﻭ ﻋﻠﻰ ﺍﻟﻴﺴﺎﺭ‬
‫ـ ﻴﻤﻜﻥ ﺘﺤﻭﻴل ﺸﻜل ﺍﻟﺼﻔﺤﺎﺕ ﺇﻟﻰ ﺃﺯﺭﺍﺭ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﺨﺎﺼﺔ ‪ Style‬ﻟﻠﻌﻨﺼﺭ ‪ PageControl‬ﺒﺈﻋﻁﺎﺌﻬـﺎ ﺍﻟﻘﻴﻤـﺔ‬
‫‪ tsButtons‬ﺃﻭ ‪ ) tsFlatButtons‬ﻻ ﺘﻌﻤل ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺇﻻ ﺇﺫﺍ ﻜﺎﻨﺕ ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﺔ ‪ TapPosition‬ﺘﺴﺎﻭﻱ ‪tpTop‬‬
‫(‪.‬‬
‫ـ ﺍﻟﺨﺎﺼﺔ ‪ ActivePage‬ﺘﺤﺩﺩ ﺍﻟﺼﻔﺤﺔ ﺍﻟﻔﻌﺎﻟﺔ ﻋﻨﺩ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪.‬‬
‫ـ ﺍﻟﺨﺎﺼﺔ ‪ : HotTrack‬ﻋﻨﺩ ﺇﻋﻁﺎﺀ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻴﺘﺤﻭل ﻟﻭﻥ ﺨﻁ ﻋﻨﻭﺍﻥ ﺍﻟﺼﻔﺤﺔ ﺇﻟﻰ ﺍﻟﻠﻭﻥ ﺍﻷﺯﺭﻕ‬
‫ﻋﻨﺩ ﻤﺭﻭﺭ ﺍﻟﻔﺄﺭﺓ ﻓﻭﻗﻪ ) ﻓﻲ ﻭﻗﺕ ﺍﻟﺘﻨﻔﻴﺫ ( ‪.‬‬
‫ﺍﻟﻌﻨﺼﺭ ‪ ) : TabControl‬ﺍﻟﺼﻔﺤﺔ ‪( Win32‬‬
‫ﻴﺸﺒﻪ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﺍﻟﻌﻨﺼﺭ ‪ PageControl‬ﻭﻴﺨﺘﻠﻑ ﻋﻨﻪ ﺒﻜﻭﻨﻪ ﻻ ﻴﻌﻁﻲ ﺼﻔﺤﺎﺕ ﻤﺴﺘﻘﻠﺔ ﺤﻴﺙ ﺃﻨـﻪ ﻤﻜـﻭﻥ ﻤـﻥ‬
‫ﺼﻔﺤﺔ ﻭﺍﺤﺩﺓ ) ﺃﻱ ﺃﻥ ﺍﻟﻌﻨﺎﺼﺭ ﺘﻭﻀﻊ ﻓﻲ ﺼﻔﺤﺔ ﻭﺍﺤﺩﺓ ﻭﻴﺘﻡ ﺘﻁﺒﻴﻕ ﺘﻐﻴﺭﺍﺕ ﻋﻠﻰ ﻫﺫﻩ ﺍﻟﻌﻨﺎﺼﺭ ﻋﻨـﺩﻤﺎ ﻴـﻀﻐﻁ‬
‫ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻠﻰ ﺃﺯﺭﺍﺭ ﺍﻟﺼﻔﺤﺎﺕ ‪:‬‬
‫ﻤﺜﺎل ‪ :‬ﺴﻨﻘﻭﻡ ﺒﻜﺘﺎﺒﺔ ﺒﺭﻨﺎﻤﺞ ﻴﻌﻁﻲ ﺠﺩﻭل ﻀﺭﺏ ﺍﻟﻌﺩﺩ ‪. 5‬‬
‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﺍﻟﻌﻨﺼﺭ ‪ ، TabControl‬ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ Tabs‬ﺃﻜﺘﺏ ﺍﻟﻘﻴﻡ ‪ 1,2,3,4,5,6,7,8,9‬ﻜل‬
‫ﻤﻨﻬﺎ ﻓﻲ ﺴﻁﺭ‬
‫ﺃﻀﻑ ﻋﻨﺼﺭﻱ ‪ Label‬ﺩﺍﺨل ﺍﻟﻌﻨﺼﺭ ‪. TabControl‬‬
‫ﻤﺴﺘﻘل ﻭﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnChange‬ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪var i :integer‬‬
‫‪begin‬‬

‫‪54‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫;) ]‪i := strtoint(tabcontrol1.Tabs[tabcontrol1.tabindex‬‬
‫;' = ‪label1.Caption := inttostr(i) + ' * 5‬‬
‫;)‪label2.Caption := inttostr(i * 5‬‬
‫ﺤﻴﺙ ‪ TabControl1.TabIndex‬ﺘﻌﻴﺩ ﺭﻗﻡ ﺍﻟﺼﻔﺤﺔ ﺍﻟﺘﻲ ﻀﻐﻁ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻠﻴﻬﺎ ‪.‬‬
‫ﻭ ] [‪ Tabcontrol1.Tabs‬ﺘﻌﻴﺩ ﻋﻨﻭﺍﻥ ﺍﻟﺼﻔﺤﺔ ﺍﻟﺘﻲ ﻴﻭﺠﺩ ﺭﻗﻤﻬﺎ ﺒﻴﻥ ﺍﻟﻘﻭﺴﻴﻥ ] [ ‪.‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺼﻔﺤﺎﺕ ﻭﻻﺤﻅ ﺍﻟﻨﺘﺎﺌﺞ ‪...‬‬
‫ﺒﺎﻟﻨﺴﺒﺔ ﻟﺒﺎﻗﻲ ﺍﻟﺨﺼﺎﺌﺹ ﻓﻬﻲ ﻤﺸﺎﺒﻬﺔ ﺘﻤﺎﻤﹰﺎ ﻟﺨﺼﺎﺌﺹ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺴﺎﺒﻕ ‪.‬‬
‫ﺍﻟﻌﻨﺼﺭ ‪ ) : UpDown‬ﺍﻟﺼﻔﺤﺔ ‪( Win32‬‬
‫ﺃﻀﻑ ﻋﻨﺼﺭ ‪ UpDown‬ﻭﻋﻨﺼﺭ ‪ Edit‬ﺇﻟﻰ ﻤﺸﺭﻭﻉ ﺠﺩﻴـﺩ ‪ ،‬ﺤـﺩﺩ ﺍﻟﻌﻨـﺼﺭ ‪ UpDown1‬ﻭﺍﻋـﻁ ﺍﻟﺨﺎﺼـﺔ‬
‫‪ Associate‬ﺍﻟﻘﻴﻤﺔ ‪ ، Edit1‬ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺃﺴﻬﻡ ﺍﻟﻌﻨﺼﺭ ‪ UpDown‬ﻭﻻﺤﻅ ﺘﻐﻴﺭ ﺍﻟﺭﻗﻡ ﺩﺍﺨل ‪Edit‬‬
‫ﺍﻟﺨﺎﺼﺔ ‪ Increment‬ﻟﻠﻌﻨﺼﺭ ﺘﺤﺩﺩ ﻤﻘﺩﺍﺭ ﺍﻟﺯﻴﺎﺩﺓ ﺃﻭ ﺍﻟﻨﻘﺼﺎﻥ ﻓﻲ ﺍﻟﻌﺩﺩ ﺩﺍﺨل ﺍﻟـ ‪. Edit‬‬
‫ﺍﻟﺨﺎﺼﺘﺎﻥ ‪ Min‬ﻭ ‪ Max‬ﺘﺤﺩﺩﺍﻥ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺩﻨﻴﺎ ﻭﺍﻟﻌﻠﻴﺎ ﻟﻠﻌﺩﺩ ﺩﺍﺨل ‪. Edit‬‬
‫ﺍﻟﺨﺎﺼﺔ ‪ Position‬ﺘﺤﺩﺩ ﺍﻟﻘﻴﻤﺔ ﺍﻻﺒﺘﺩﺍﺌﻴﺔ ﻟﻠﻌﻨﺼﺭ ‪.‬‬
‫ﺍﻟﺨﺎﺼﺔ ‪ Orientation‬ﺘﺤﺩﺩ ﺍﺘﺠﺎﻩ ﺍﻷﺴﻬﻡ ) ﻋﺎﻤﻭﺩﻱ ﺃﻭ ﺃﻓﻘﻲ ( ‪.‬‬
‫ﺍﻟﺨﺎﺼﺔ ‪ : Warp‬ﻋﻨﺩ ﺇﻋﻁﺎﺀ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻴﺘﺤﻭل ﺍﻟﻌﺩﺩ ﻤﻥ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺴﻔﻠﻰ ﺇﻟﻰ ﺍﻟﻌﻠﻴﺎ ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ‬
‫ﺍﻟﺯﺭ ‪ Down‬ﺒﻌﻜﺱ ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪. Up‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻴﻭﺠﺩ ﻓﻲ ﺍﻟﺼﻔﺤﺔ ‪ Sample‬ﺍﻟﻌﻨﺼﺭﻴﻥ ‪ SpinEdit‬ﻭ ‪ SpinButton‬ﺍﻟﺫﻴﻥ ﻴﺸﺒﻬﺎﻥ ﻋﻤل ﻫـﺫﺍ ﺍﻟﻌﻨـﺼﺭ‬
‫ﺇﻟﻰ ﺤﺩ ﻤﺎ ‪.‬‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺴﻼﺴل ﺍﻟﻨﺼﻴﺔ ‪:‬‬
‫‪ 1‬ـ ﺍﻟﺘﺎﺒﻊ ‪: Concat‬‬
‫‪Concat ( s1, [s2..sn]) :string‬‬
‫ﻴﻘﻭﻡ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﺒﻭﺼل ﺍﻟﺴﻼﺴل ‪ S1..Sn‬ﻤﻊ ﺒﻌﻀﻬﺎ‬
‫ﻤﺜﺎل ‪:‬‬
‫ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ‪:‬‬
‫;‪var s1,s2,s3 : string‬‬
‫‪begin‬‬
‫;'‪s1:= 'abc‬‬
‫;'‪s2 := 'efg‬‬
‫;'‪s3:= 'hij‬‬
‫)‪form1.caption:=concat(s1,s2,s3‬‬
‫ﻴﺸﺒﻪ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﻋﻤﻠﻴﺔ ﺠﻤﻊ ﺍﻟﺴﻼﺴل ﺍﻟﻨﺼﻴﺔ ﺃﻱ ﺃﻥ ﺍﻟﻨﺘﻴﺠﺔ ﺴﺘﻜﻭﻥ ﻤﺸﺎﺒﻪ ﻟﻭ ﻜﺎﻨﺕ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻷﺨﻴﺭﺓ‬
‫;‪Form1.Caption := s1+s2+s3‬‬
‫‪ 2‬ـ ﺍﻟﺘﺎﺒﻊ ‪: Copy‬‬
‫‪Copy ( S:string , Index,Count :Integer ) :String‬‬
‫ﻴﻌﻴﺩ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﺴﻠﺴﻠﺔ ﺭﻤﺯﻴﺔ ﺠﺯﺌﻴﺔ ﻤﻥ ﺍﻟﺴﻠﺴﺔ ‪ S‬ﺘﺒﺩﺃ ﻤﻥ ﺍﻟﺤﺭﻑ ﺍﻟﺫﻱ ﺘﺭﺘﺒﻪ ‪ Index‬ﻭﺒﻁﻭل ‪. Count‬‬

‫‪55‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪... Copy ( 'Hello All',5,1) = o ; Copy ( 'Hello All',2,6) = ello A‬‬ ‫ﻤﺜﺎل ‪:‬‬
‫‪ 3‬ـ ﺍﻹﺠﺭﺍﺀ ‪: Delete‬‬
‫; ) ‪Delete ( Var S:string ,Index,Count‬‬
‫ﻴﻌﻴﺩ ﻫﺫﺍ ﺍﻹﺠﺭﺍﺀ ﻓﻲ ﺍﻟﻤﺘﺤﻭل ‪ S‬ﻗﻴﻤﺔ ﻨﻔﺱ ﺍﻟﺴﻠﺴﻠﺔ ﺒﻌﺩ ﺤﺫﻑ ﺍﻟﺭﻤﻭﺯ ﺍﺒﺘﺩﺍﺀ ﻤﻥ ﺍﻟﺭﻤﺯ ﺍﻟﺫﻱ ﺘﺭﺘﻴﺒﻪ ‪ Index‬ﻭﺒﻁﻭل‬
‫‪Count‬‬
‫ﻤﺜﺎل ‪:‬‬
‫ﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪var s1 : String‬‬
‫‪Begin‬‬
‫; '‪s1:= 'Hello All‬‬
‫;)‪Delete (s1,1,3‬‬
‫;‪Form1.Caption := s1‬‬
‫ﺴﺘﻜﻭﻥ ﻨﺘﻴﺠﺔ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﻘﻴﻤﺔ ‪ ، lo All‬ﻭﺇﺫﺍ ﻏﻴﺭﻨﺎ ﻭﺴﻁﺎﺀ ﺍﻹﺠﺭﺍﺀ ﺇﻟﻰ ﺍﻟـﺸﻜل )‪ Delete ( S1,4,3‬ﺴـﺘﻜﻭﻥ‬
‫ﺍﻟﻨﺘﻴﺠﺔ ‪. HelAll‬‬
‫‪ 4‬ـ ﺍﻟﺘﺎﺒﻊ ‪: DupeString‬‬
‫;‪DupeString ( S: String ,Count :Integer) :String‬‬
‫ﻴﻌﻴﺩ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﺍﻟﻘﻴﻤﺔ ‪ S‬ﻤﻜﺭﺭﺓ ‪ Count‬ﻤﺭﺓ‬
‫‪DupeString( 'Ha ',5) = Ha Ha Ha Ha Ha‬‬ ‫ﻤﺜﺎل ‪:‬‬
‫ﻤﻼﺤﻅﺔ ﻟﺘﻨﻔﻴﺫ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﻨﺤﺘﺎﺝ ﻻﺴﺘﺩﻋﺎﺀ ﺍﻟﻭﺤﺩﺓ ‪StrUtils‬‬
‫‪ 5‬ـ ﺍﻷﺠﺭﺍﺀ ‪: Insert‬‬
‫; ) ‪Insert ( S1:String , var S:string ; Index :Integer‬‬
‫ﻴﻘﻭﻡ ﻫﺫﺍ ﺍﻹﺠﺭﺍﺀ ﺒﺤﺸﺭ ﺍﻟﺴﻠﺴﺔ ‪ S1‬ﻓﻲ ﺍﻟﺴﻠﺴﺔ ‪ S‬ﺍﺒﺘﺩﺍﺀ ﻤﻥ ﺍﻟﺭﻤﺯ ‪ Index‬ﻓﻲ ﺍﻟﺴﻠﺴﺔ ‪ S‬ﻭﻴﻌﻴﺩ ﺍﻟﻨﺘﻴﺠﺔ ﻓﻲ ‪. S‬‬
‫ﻤﺜﺎل ‪ :‬ﺘﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ‪:‬‬

‫;‪var s : string‬‬
‫‪begin‬‬
‫; '‪s:= 'Hello Friends‬‬
‫;)‪insert ( 'All ' ,s,7‬‬
‫;‪form1.Caption := s‬‬
‫ﺍﻟﺘﺎﺒﻊ ‪: StuffString‬‬
‫;‪StuffString( s:string , start, length :integer , S1:string ) :string‬‬
‫ﻴﻘﻭﻡ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﺒﺤﺸﺭ ﺍﻟﺴﻠﺴﺔ ﻗﻴﻤﺔ ‪ S1‬ﻓﻲ ﻗﻴﻤﺔ ﺍﻟﺴﻠﺴﻠﺔ ‪ S‬ﺍﺒﺘﺩﺍﺀ ﻤﻥ ﺍﻟﺭﻤﺯ ﺍﻟﺫﻱ ﺘﺭﺘﻴﺒﻪ ‪ Start‬ﻤﻊ ﺤﺫﻑ ﻋﺩﺩ ﻤـﻥ‬
‫ﺍﻟﺭﻤﻭﺯ ﻤﻥ ﻗﻴﻤﺔ ‪ S‬ﺒﻁﻭل ‪: Length‬‬
‫ﻤﺜﺎل ‪ stuffstring('Hello Friend',7,6,'all') = 'Hello all' :‬ﻗﺎﻡ ﺍﻟﺘﺎﺒﻊ ﺒﺤﺫﻑ ﺴﺘﺔ ﺃﺤﺭﻑ ﺍﺒﺘﺩﺍﺀ ﻤﻥ ﺍﻟﺤـﺭﻑ‬
‫ﺍﻟﺴﺎﺒﻊ ﻭﺤﺸﺭ ﺍﻟﺴﻠﺴﺔ ‪ ، all‬ﻓﻲ ﺤﺎل ﺘﻐﻴﺭ ﺍﻟﺭﻗﻡ ‪ 6‬ﺇﻟﻰ ‪ 0‬ﺴﻴﻌﻤل ﺍﻟﺘﺎﺒﻊ ﻋﻤل ﺍﻹﺠﺭﺍﺀ ‪. Insert‬‬
‫ﻴﺨﺘﻠﻑ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﻋﻥ ﺴﺎﺒﻘﺔ ﺒـ ‪:‬‬
‫‪56‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ 1‬ـ ﺍﻟﺘﺎﺒﻊ ﻴﻘﻭﻡ ﺒﺤﺫﻑ ﻗﺴﻡ ﻤﻥ ﺍﻟﺴﻠﺴﺔ ﻭﺇﺩﺭﺍﺝ ﻏﻴﺭﻩ ‪.‬‬
‫‪ 2‬ـ ﺍﻹﺠﺭﺍﺀ ‪ Insert‬ﺒﺤﺎﺠﺔ ﺇﻟﻰ ﻤﺘﺤﻭل ‪ S‬ﺴﺘﻌﺎﺩ ﻗﻴﻤﺔ ﺍﻟﺘﺎﺒﻊ ﻓﻴﻪ ﺒﻴﻨﻤﺎ ﺍﻟﺘـﺎﺒﻊ ‪ StuffString‬ﻴﻌﻴـﺩ ﺍﻟﺴﻠـﺴﺔ‬
‫ﺍﻟﻨﺘﻴﺠﺔ ﺒﺩﻭﻥ ﺍﻟﺘﺄﺜﻴﺭ ﻋﻠﻰ ﻭﺴﻁﺎﺀﻩ ( ‪.‬‬
‫ﻤﻼﺤﻅﺔ ﻟﺘﻨﻔﻴﺫ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﻨﺤﺘﺎﺝ ﻻﺴﺘﺩﻋﺎﺀ ﺍﻟﻭﺤﺩﺓ ‪StrUtils‬‬

‫ﺍﻟﺘﺎﺒﻊ ‪: LeftStr‬‬
‫‪LeftStr(S:String ,Count : integer) :string‬‬
‫ﻴﻌﻴﺩ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﺴﻠﺴﻠﺔ ﻨﺼﻴﺔ ﺘﺒﺩﺃ ﻤﻥ ﻴﺴﺎﺭ ﺍﻟﺴﻠﺴﻠﺔ ‪ S‬ﻭﺒﻁﻭل ‪: Count‬‬
‫ﻤﺜﺎل ‪. LeftStr( 'Good Morning,4 ) = Good ، LeftStr( 'Hello Frind',6) = Hello :‬‬
‫ﺍﻟﺘﺎﺒﻊ ‪ : RightStr‬ﻴﺸﺒﻪ ﺍﻟﺘﺎﺒﻊ ﺍﻟﺴﺎﺒﻕ ﻭﻟﻜﻨﻪ ﻴﻌﻴﺩ ﺍﺒﺘﺩﺍﺀ ﻤﻥ ﻨﻬﺎﻴﺔ ﺍﻟﺴﻠﺴﺔ ‪:‬‬
‫ﻤﺜﺎل ‪Rightstr( 'Hello Friend',6)=Friend :‬‬
‫ﺍﻟﺘﺎﺒﻊ ‪: LowerCase‬‬
‫ﻴﻌﻴﺩ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﺍﻟﺴﻠﺴﻠﺔ ‪ S‬ﺒﻌﺩ ﺘﺤﻭﻴل ﺠﻤﻴﻊ ﺤﺭﻭﻓﻬﺎ ﺇﻟﻰ ﺤﺭﻭﻑ ﺼﻐﻴﺭﺓ ) ﺍﻷﺤﺭﻑ ﺍﻟﻼﺘﻴﻨﻴﺔ ( ‪.‬‬
‫ﻤﺜﺎل ‪LowerCase(Hello Friend) = hello friend :‬‬
‫ﺍﻟﺘﺎﺒﻊ ‪: UpperCase‬‬
‫ﻋﻜﺱ ﺍﻟﺘﺎﺒﻊ ﺍﻟﺴﺎﺒﻕ ‪،‬ﻤﺜﺎل ‪UpperCase (' Hello Friend') = HELLO FRIEND‬‬
‫ﺍﻟﺘﺎﺒﻊ ‪: Trim‬‬
‫ﻴﻘﻭﻡ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﺒﺤﺫﻑ ﺍﻟﻔﺭﺍﻏﺎﺕ ﻤﻥ ﺒﺩﺍﻴﺔ ﻭﻨﻬﺎﻴﺔ ﺍﻟﺴﻠﺴﺔ ‪S‬‬
‫ﻤﺜﺎل ‪:‬‬
‫ﺃﻀﻑ ﺯﺭ ﻭﻋﻨﺼﺭ ‪ Edit‬ﺇﻟﻰ ﺒﺭﻨﺎﻤﺞ ﺠﺩﻴﺩ ﻭﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;) ‪edit1.Text:= Trim(edit1.Text‬‬
‫ﺃﻜﺘﺏ ﻨﺼﹰﺎ ﻤﺎ ﻓﻲ ﺍﻟﻌﻨﺼﺭ ‪ Edit1‬ﻭﺤﺎﻭل ﺘﺭﻙ ﻓﺭﺍﻏﺎﺕ ﻓﻲ ﺒﺩﺍﻴﺔ ﻫﺫﻩ ﺍﻟﻨﺹ ﺃﻭ ﺁﺨﺭﺓ ' ‪ ' Hello All‬ﻭﺍﻀـﻐﻁ‬
‫ﻋﻠﻰ ﺍﻟﺯﺭ ﻓﻴﻘﻭﻡ ﺍﻟﺘﺎﺒﻊ ﺒﺤﺫﻑ ﺍﻟﻔﺭﺍﻏﺎﺕ ﻭﺇﻋﺎﺩﺓ ﺍﻟﻘﻴﻤﺔ '‪. 'Hello All‬‬
‫ﺍﻟﺘﺎﺒﻌﻴﻥ ‪ TrimLeft‬ﻭ ‪ TrimRight‬ﻟﻬﻤﺎ ﻨﻔﺱ ﺍﻟﺘﺄﺜﻴﺭ ﻏﻴﺭ ﺃﻨﻬﻤﺎ ﻴﺤﺫﻓﺎﻥ ﺍﻟﻔﺭﺍﻏﺎﺕ ﻤﻥ ﺒﺩﺍﻴﺔ ﺍﻟﺴﻠﺴﺔ ﺃﻭ ﻨﻬﺎﻴﺘﻬﺎ ﻋﻠﻰ‬
‫ﺍﻟﺘﻭﺍﻟﻲ ‪.‬‬
‫ﺍﻟﺘﺎﺒﻊ ‪: Format‬‬
‫; ) ‪Format ( S :String ; A:array of const‬‬
‫ﺩﺍﺨﻠﻬﺎ ﻭﻓﻘﹰﺎ ﻟﺒﻌﺽ ﺍﻟﻤﻌﺎﻴﻴﺭ ‪ A...‬ﺒﻌﺩ ﺇﺩﺭﺍﺝ ﺍﻟﻘﻴﻡ ﻓﻲ ‪S‬ﻴﻌﻴﺩ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﺍﻟﺴﻠﺴﻠﺔ‬
‫ﻤﺜﺎل ‪:‬‬
‫ﺃﻀﻑ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ‪:‬‬
‫;‪var s1:string‬‬
‫;‪var i,j :integer; z:real‬‬
‫‪begin‬‬
‫;‪i:= 200;j:=5; z:= i/j‬‬
‫‪57‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫;)]‪s1:= format('If You Divide %d by %d the result will be %g',[i,j,z‬‬
‫;‪form1.Caption := s1‬‬
‫ﺴﻴﻌﻴﺩ ﺍﻟﺘﺎﺒﻊ ﺍﻟﻘﻴﻤﺔ ‪. If You Divide 200 by 5 the result will be 40‬‬
‫‪ ( I‬ﺇﻟﻰ ﺍﻟﻭﺴﻴﻁ ‪ %d‬ﻭﻗﻴﻤﺔ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺜﺎﻨﻲ ﺇﻟﻰ ﺍﻟﻭﺴﻴﻁ ‪%d‬‬ ‫ﻗﺎﻡ ﺍﻟﺘﺎﺒﻊ ﺒﺈﻋﻁﺎﺀ ﻗﻴﻤﺔ ﺍﻟﻌﻨﺼﺭ ﺍﻷﻭل ﻓﻲ ﺍﻟﻤﺼﻔﻭﻓﺔ )‬
‫ﺍﻟﺜﺎﻨﻲ ﻭﻗﻴﻤﺔ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺜﺎﻟﺙ ‪ Z‬ﺇﻟﻰ ﺍﻟﻭﺴﻴﻁ ‪. %g‬‬
‫ﺇﺫﹰﺍ ﻴﻤﻜﻨﻙ ﺍﻟﺘﺎﺒﻊ ‪ Format‬ﻤﻥ ﺇﺩﺭﺍﺝ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﺜﻭﺍﺒﺕ ﺩﺍﺨل ﺍﻟﺠﻤﻠﺔ ﻋﻥ ﻁﺭﻴﻕ ﻜﺘﺎﺒﺔ ﺍﻟﺭﻤﺯ ‪ %‬ﺩﺍﺨل ﺍﻟﺠﻤﻠـﺔ‬
‫ﻤﻠﺤﻘﹰﺎ ﺒﺭﻤﺯ ﻴﺩل ﻋﻠﻰ ﻨﻭﻉ ﺍﻟﻭﺴﻴﻁ ﺍﻟﻤﺭﺍﺩ ﺇﺩﺭﺍﺠﻪ ﺤﺴﺏ ﺍﻟﺠﺩﻭل ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫)‪ d (decimal‬ﻋﺸﺭﻱ‪ ،‬ﻗﻴﻤﺔ ﺍﻟﻌﺩﺩ ﺍﻟﺼﺤﻴﺢ ﻴﺤﻭ‪‬ل ﺇﻟﻰ ﺠﻤﻠﺔ ﻤﻥ ﺍﻟﺨﺎﻨﺎﺕ ﺍﻟﻌﺸﺭﻴﺔ‪.‬‬
‫‪x‬‬
‫ﺴﺕ ﻋﺸﺭﻱ‪ ،‬ﻗﻴﻤﺔ ﺍﻟﺭﻗﻡ ﺍﻟﺼﺤﻴﺢ ﺘﹸﺤﻭ‪‬ل ﺇﻟﻰ ﺠﻤﻠﺔ ﻤﻥ ﺍﻟﺨﺎﻨﺎﺕ ﺍﻟﺴﺕ ﻋﺸﺭﻴﺔ‪.‬‬
‫)‪(hexadecimal‬‬
‫)‪ p (pointer‬ﻤﺅﺸﹼﺭ‪ ،‬ﻗﻴﻤﺔ ﺍﻟﻤﺅﺸﺭ ﻴﺤﻭ‪‬ل ﺇﻟﻰ ﺠﻤﻠﺔ ﻤﻌﺒ‪‬ﺭ ﻋﻨﻬﺎ ﺒﺄﻋﺩﺍﺩ ﺴﺕ ﻋﺸﺭﻴﺔ‪.‬‬

‫)‪ s (string‬ﻗﻴﻤﺔ ﺍﻟﺠﻤﻠﺔ‪ ،‬ﺍﻟﺤﺭﻑ‪ ،‬ﺃﻭ ﻨﻭﻉ ‪ PChar‬ﻴﺘﻡ ﻨﺴﺨﻬﺎ ﻓﻲ ﻤﺨﺭﺠﺎﺕ ﺍﻟﺠﻤﻠﺔ‪.‬‬
‫‪e‬‬
‫ﻤﺭﻓﻭﻉ ﺍﻟﻘﻭﺓ‪ ،‬ﻗﻴﻤﺔ ﺍﻟﻨﻘﻁﺔ ﺍﻟﻌﺎﺌﻤﺔ ﺘﺤﻭ‪‬ل ﺇﻟﻰ ﺠﻤﻠﺔ ﻤﺒﻨﻴﺔ ﻋﻠﻰ ﺘﺭﻤﻴﺯ ﻤﺭﻓﻭﻉ ﺍﻟﻘﻭﺓ‪.‬‬
‫)‪(exponential‬‬
‫‪f (floating‬‬
‫ﻨﻘﻁﺔ ﻋﺎﺌﻤﺔ‪ ،‬ﻗﻴﻤﺔ ﺍﻟﻨﻘﻁﺔ ﺍﻟﻌﺎﺌﻤﺔ ﺘﺤﻭ‪‬ل ﺇﻟﻰ ﺠﻤﻠﺔ ﻤﺒﻨﻴﺔ ﻋﻠﻰ ﺘﺭﻤﻴﺯ ﺍﻟﻨﻘﻁﺔ ﺍﻟﻌﺎﺌﻤﺔ‪.‬‬
‫)‪point‬‬
‫ﻋﺎﻡ‪ ،‬ﻗﻴﻤﺔ ﺍﻟﻨﻘﻁﺔ ﺍﻟﻌﺎﺌﻤﺔ ﺘﺤﻭ‪‬ل ﺇﻟﻰ ﺠﻤﻠﺔ ﻋﺸﺭﻴﺔ ﺒﺄﻗﺭﺏ ﻤﺎ ﻴﻤﻜﻥ ﻤﺴﺘﺨﺩﻤﺔ ﺇﻤﺎ ﺘﺭﻤﻴﺯ ﺍﻟﻨﻘﻁﺔ‬
‫)‪g (general‬‬
‫ﺍﻟﻌﺎﺌﻤﺔ ﺃﻭ ﻤﺭﻓﻭﻉ ﺍﻟﻘﻭﺓ‪.‬‬

‫)‪ n (number‬ﺭﻗﻡ‪ ،‬ﻗﻴﻤﺔ ﺍﻟﻨﻘﻁﺔ ﺍﻟﻌﺎﺌﻤﺔ ﺘﺤﻭ‪‬ل ﺇﻟﻰ ﺠﻤﻠﺔ ﻨﻘﻁﺔ ﻋﺎﺌﻤﺔ ﻟﻜﻨﻬﺎ ﺃﻴﻀﺎ ﺘﺴﺘﺨﺩﻡ ﻓﻭﺍﺼل ﺍﻵﻻﻑ‪.‬‬

‫ﻨﻘﻭﺩ‪ ،‬ﻗﻴﻤﺔ ﺍﻟﻨﻘﻁﺔ ﺍﻟﻌﺎﺌﻤﺔ ﺘﺤﻭ‪‬ل ﺇﻟﻰ ﺠﻤﻠﺔ ﺘﻤﺜل ﻤﻘﺩﺍﺭ ﺍﻟﻌﻤﻠﺔ‪ .‬ﺍﻟﺘﺤﻭﻴل ﻴﻌﺘﻤﺩ ﻋﻠﻰ ﺍﻟﺘﻭﺼﻴﻑ‬
‫)‪ m (money‬ﺍﻹﻗﻠﻴﻤﻲ ﻟﺒﻴﺌﺔ ﺍﻟﺘﺸﻐﻴل‪ -‬ﺍﻨﻅﺭ ﻤﻠﻑ ﻤﺴﺎﻋﺩﺓ ﺩﻟﻔﻲ ﺘﺤﺕ ﻤﻭﻀﻭﻉ‪Currency and :‬‬
‫‪.date/time formatting variables‬‬
‫ﻤﺜﺎل ‪:‬‬
‫ﺃﻀﻑ ﻋﻨﺼﺭ ‪ Edit‬ﻭﺯﺭ ﺇﻟﻰ ﺒﺭﻨﺎﻤﺞ ﺠﺩﻴﺩ ‪ ،‬ﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;))]‪ %s',[Edit1.Text‬ﻤﺭﺤﺒﺎﹰ'( ‪ShowMessage( Format‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﻜﺘﺏ ﺃﺴﻤﻙ ﻓﻲ ﺍﻟﻌﻨﺼﺭ ‪ Edit‬ﻭﺃﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪......‬‬

‫‪58‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ﺍﻟﺤﺎﺩﻴﺔ ﻋﺸﺭﺓ‬
‫ﺍﻟﻠﻭﺍﺌﺢ ﺍﻟﻨﺼﻴﺔ ‪:‬‬
‫ﻴﺴﺘﺨﺩﻡ ﺍﻟﻨﻭﻉ ‪ TSrings‬ﻟﺘﻌﺭﻴﻑ ﺍﻟﻠﻭﺍﺌﺢ ﺍﻟﻨﺼﻴﺔ ﺤﻴﺙ ﻴﻘﻭﻡ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﺒﺘﺨﺯﻴﻥ ﻋﺩﺩ ﻤﻥ ﺍﻟﺴﻼﺴل ﺍﻟﻨـﺼﻴﺔ ﻀـﻤﻥ‬
‫ﺴﻁﻭﺭ ﻭﻗﺩ ﺘﻌﺎﻤﻠﻨﺎ ﻤﻌﻪ ﻓﻲ ﺍﻟﺴﺎﺒﻕ ﻓﺎﻟﺨﺎﺼﺔ ‪ Items‬ﺍﻟﺘﺎﺒﻌﺔ ﻟـ ‪ ListBox‬ﻭﺍﻟﺨﺎﺼﺔ ‪ Lines‬ﺍﻟﺘﺎﺒﻌﺔ ﻟﻌﻨﺼﺭ ﺍﻟﻤﺫﻜﺭﺓ‬
‫‪ Memo‬ﻤﻥ ﺍﻟﻨﻭﻉ ‪. Tstrings‬‬
‫ﻴﺒﺩﺃ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻨﻭﻉ ‪ TStrings‬ﺒﺎﻟﺘﻌﻠﻴﻤﺔ ‪ TStringList.Create‬ﺍﻟﺘﻲ ﺘﻘﻭﻡ ﺒﺤﺠﺯ ﻤﻜﺎﻥ ﻟﻬﺫﺍ ﺍﻟﻨﻭﻉ ﻓﻲ ﺍﻟـﺫﺍﻜﺭﺓ‪،‬‬
‫ﻋﻠﻤﹰﺎ ﺃﻥ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻗﺩ ﻴﺄﺨﺫ ﻤﺠﺎل ﻜﺒﻴﺭ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ ﺘﺒﻌﹰﺎ ﻟﺤﺠﻡ ﺍﻟﺴﻼﺴل ﺍﻟﻨﺼﻴﺔ ﺍﻟﻤﺭﺍﺩ ﺘﺨﺯﻴﻨﻬﺎ ﻓﻴﻪ‪ ،‬ﻭﻴﻨﺘﻬﻲ ﺍﺴـﺘﺨﺩﺍﻡ‬
‫ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﺒﺎﻟﺘﻌﻠﻴﻤﺔ ‪ Free‬ﻟﺘﺤﺭﻴﺭ ﺍﻟﺫﺍﻜﺭﺓ ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﻤﻥ ﻗﺒل ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪:‬‬
‫ﻋﻨﺩ ﺇﻨﻬﺎﺀ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺩﻭﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ Free‬ﺴﻴﺒﻘﻰ ﺤﻴﺯ ﺍﻟﺫﺍﻜﺭﺓ ﺍﻟﻤﺤﺠﻭﺯ ﻤﻥ ﻗﺒل ﺍﻟﻤﺘﺤﻭل ‪ Tstrings‬ﻤـﺸﻐﻭ ﹰ‬
‫ﻻ‬
‫ﻤﻤﺎ ﻴﻌﻁل ﻤﻭﺍﺭﺩ ﺍﻟﺠﻬﺎﺯ ) ﺘﻅﻬﺭ ﻫﺫﻩ ﺍﻟﻤﺸﻜﻠﺔ ﻤﻊ ﺍﻟﻌﺩﻴﺩ ﻤﻥ ﺍﻟﺒﺭﺍﻤﺞ ﺍﻟﻌﺭﺒﻴﺔ ( ‪.‬‬
‫ﻭﺘﻘﺴﻡ ﺍﻟﻠﻭﺍﺌﺢ ﺍﻟﻨﺼﻴﺔ ﺇﻟﻰ ﻗﺴﻤﻴﻥ ‪:‬‬
‫‪ 1‬ـ ﺍﻟﻠﻭﺍﺌﺢ ﺍﻟﻨﺼﻴﺔ ﻗﺼﻴﺭﺓ ﺍﻷﻤﺩ ‪:‬‬
‫ﺘﻜﻭﻥ ﺍﻟﻼﺌﺤﺔ ﻗﺼﻴﺭﺓ ﺍﻷﻤﺩ ﺇﺫﺍ ﺘﻡ ﺇﻨﺸﺎﺅﻫﺎ ﻭﺘﺤﺭﻴﺭﻫﺎ ﻓﻲ ﻨﻔﺱ ﺍﻹﺠﺭﺍﺀ ﺃﻭ ﺍﻟﺘﺎﺒﻊ ‪.‬‬
‫ﻤﺜﺎل ‪:‬‬
‫ﺃﻨﺸﺊ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﻋﻨﺼﺭ ﺍﻟﻼﺌﺤﺔ ‪ ListBox‬ﻭﺯﺭ ﻭﻋﻨﺼﺭ ‪ ، Edit‬ﺃﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟـﻀﻐﻁ ﻋﻠـﻰ‬
‫ﺍﻟﺯﺭ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪var a:TStrings‬‬
‫‪Begin‬‬
‫ﺇﻨﺸﺎﺀ ﺍﻟﻼﺌﺤﺔ ﻭﺤﺠﺯ ﻤﻜﺎﻥ ﻟﻬﺎ ﻓﻲ ﺍﻟﺫﺍﻜﺭﺓ ‪a := TStringList.Create; //‬‬
‫ﺇﻀﺎﻓﺔ ﺍﻟﻨﺹ ﺍﻟﻤﻭﺠﻭﺩ ﻓﻲ ﺼﻨﺩﻭﻕ ﺍﻟﻨﺹ ﺇﻟﻰ ﺍﻻﺌﺤﺔ ‪a.Add(Edit1.text); //‬‬
‫ﻭﻀﻊ ﺍﻟﺴﻁﺭ ) ‪ ( 0‬ﻤﻥ ﺴﻁﻭﺭ ﺍﻟﻼﺌﺤﺔ ﻓﻲ ﻋﻨﻭﺍﻥ ﺍﻟﻨﻤﻭﺫﺝ ‪Form1.Caption := a.Strings [0]; //‬‬
‫‪ListBox‬‬ ‫‪a‬‬
‫‪ListBox1.Items.AddStrings(a); //‬‬ ‫ﺇﻀﺎﻓﺔ ﻋﻨﺎﺼﺭ ﺍﻟﻼﺌﺤﺔ ﺇﻟﻰ ﻋﻨﺼﺭ ﺍﻟﻼﺌﺤﺔ‬
‫; ‪a.Free‬‬
‫;‪end‬‬
‫ﺤﺎﻭل ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒﺩﻭﻥ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪TsrtingList.Create‬‬
‫‪ 2‬ـ ﺍﻟﻠﻭﺍﺌﺢ ﺍﻟﻨﺼﻴﺔ ﻁﻭﻴﻠﺔ ﺍﻷﻤﺩ ‪:‬‬
‫ﺘﻜﻭﻥ ﺍﻟﻼﺌﺤﺔ ﻁﻭﻴﻠﺔ ﺍﻷﻤﺩ ﻋﻨﺩ ﺘﻌﺭﻴﻑ ﻤﺘﺤﻭل ﻋﺎﻡ ﺃﻭ ﺨﺎﺹ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ TStrings‬ﻭﻫﻨﺎ ﻋﻠﻴﻨﺎ ﺘﺤﺭﻴﺭﻩ ﻋﻨﺩ ﺇﻏﻼﻕ‬
‫ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺫﻱ ﻗﺎﻡ ﺒﺈﻨﺸﺎﺌﻪ ‪:‬‬
‫ﻤﺜﺎل ‪:‬‬
‫ﺃﻀﻑ ﻤﺘﺤﻭل ‪ A‬ﻤﻥ ﺍﻟﻨﻭﻉ ‪ TStrings‬ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Puplic‬ﻤﻥ ﺒﺭﻨﺎﻤﺞ ﺠﺩﻴﺩ ‪.‬‬
‫ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnCreat‬ﻟﻠﻨﻤﻭﺫﺝ ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪A := TStringList.Create‬‬
‫‪59‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnDestroy‬ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪A.Free‬‬
‫ﺒﺈﻤﻜﺎﻨﻙ ﺍﻵﻥ ﺍﺴﺘﺨﺩﺍﻡ ﻋﻨﺼﺭ ﺍﻟﻼﺌﺤﺔ ﻓﻲ ﺃﻱ ﺠﺯﺀ ﻤﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪.‬‬
‫ﺍﻟﺤﺩﺙ ‪ OnDestroy‬ﻴﺘﻡ ﺘﻨﻔﻴﺫﻩ ﻋﻨﺩ ﺇﻏﻼﻕ ﺍﻟﻨﺎﻓﺫﺓ ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻤﻌﻅﻡ ﺍﻷﻨﻭﺍﻉ ﺍﻟﺘﻲ ﺘﺤﺘﺎﺝ ﺇﻟﻰ ‪ Create‬ﺘﺤﺘﺎﺝ ﺇﻟﻰ ‪ Free‬ﻋﻨﺩ ﺍﻨﺘﻬﺎﺀ ﺍﻟﺘﻌﺎﻤل ﻤﻌﻬﺎ‪ ،‬ﻭﻫﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﺘﺸﺒﻪ‬
‫ﻁﺭﻴﻘﺔ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻤﺅﺸﺭﺍﺕ ﺤﻴﺙ ﻴﺠﺏ ﺇﻨﻬﺎﺀ ﺍﻟﻤﺅﺸﺭ ﺒﻌﺩ ﺍﻻﻨﺘﻬﺎﺀ ﻤﻨﻪ ‪.‬‬
‫ﻤﻌﺎﻟﺠﺔ ﺍﻷﺨﻁﺎﺀ ﻓﻲ ﺩﻟﻔﻲ ‪:‬‬
‫ﻴﺠﺏ ﻋﻠﻰ ﻜل ﺘﻁﺒﻴﻕ ﺠﻴﺩ ﺃﻥ ﻴﻌﺎﻟﺞ ﺠﻤﻴﻊ ﺍﺤﺘﻤﺎﻻﺕ ﺍﻷﺨﻁﺎﺀ ﻭﺃﻥ ﻴﻭﺠﻪ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺇﻟﻰ ﺤل ﻤﺎ ﻟﻠﺨﺭﻭﺝ ﻤـﻥ ﺤﺎﻟـﺔ‬
‫ﺍﻟﺨﻁﺄ ﺃﻭ ﻴﻘﻭﻡ ﺒﺈﻨﻬﺎﺀ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒﺄﺴﻠﻭﺏ ﺠﻴﺩ ﻋﻠﻰ ﺍﻷﻗل ‪....‬‬
‫ﺘﺩﻋﻰ ﺤﺎﻻﺕ ﺤﺩﻭﺙ ﺍﻟﺨﻁﺄ ﻓﻲ ﺩﻟﻔﻲ ﺒﺎﻻﻋﺘﺭﺍﻀﺎﺕ ‪ Exceptions‬ﻭﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻥ ﺃﻫﺩﺍﻑ ) ﻤﺘﺤـﻭﻻﺕ‪ ،‬ﺘﻭﺍﺒـﻊ ‪،‬‬
‫ﺇﺠﺭﺍﺀﺍﺕ ﻤﻌﺭﻓﺔ ( ﺘﺤﻭﻱ ﻤﻌﻠﻭﻤﺎﺕ ﻋﻥ ﻭﻗﻭﻉ ﺍﻟﺨﻁﺄ ﻭﻤﻜﺎﻥ ﺤﺩﻭﺜﻪ‪.‬‬
‫ﺘﺴﺘﺨﺩﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ Try‬ﻟﺤﻤﺎﻴﺔ ﻜﺘل ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻭﺍﻟﺘﻲ ﻟﻬﺎ ﺸﻜﻠﻴﻥ ﺴﻨﺸﺭﺡ ﻜل ﻤﻨﻬﻤﺎ ﺒﺎﻟﺘﻔﺼﻴل ‪.‬‬
‫‪ 1‬ـ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪: Try. . . . . . Except‬‬
‫ﺒﻔﺭﺽ ﺃﻨﻨﺎ ﻨﺘﻭﻗﻊ ﺤﺩﻭﺙ ﺨﻁﺄ ﻤﺎ ﻓﻲ ﻜﺘﻠﺔ ﻤﻥ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ) ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ ( ﻟﻤﻌﺎﻟﺠﺔ ﻫـﺫﺍ ﺍﻟﺨﻁـﺄ ﻨـﻀﻊ ﻫـﺫﻩ‬
‫ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻀﻤﻥ ﺍﻟﻜﺘﻠﺔ ‪ Try‬ﻭﺍﻟﺘﻲ ﺘﻨﺘﻬﻲ ﺒـ ‪ ، End‬ﻭﺘﺴﺘﺨﺩﻡ ‪ Except‬ﻗﺒل ‪ End‬ﻟﺘﻭﺠﻴﻪ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻟﺘﻨﻔﻴﺫ ﻋﻤﻠﻴـﺎﺕ‬
‫ﻤﺤﺩﺩﺓ ﻋﻨﺩ ﺤﺩﻭﺙ ﺍﻟﺨﻁﺄ ‪.‬‬
‫ﻤﺜﺎل ‪:‬‬
‫ﺃﻀﻑ ﺯﺭ ﻭ‪ Edit‬ﺇﻟﻰ ﺒﺭﻨﺎﻤﺞ ﺠﺩﻴﺩ ﻭﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪var i :integer‬‬
‫‪begin‬‬
‫;)‪i:= strtoint(edit1.text‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﻜﺘﺏ ﻨﺼﹰﺎ ﻓﻲ ‪ ) Edit‬ﻻ ﺘﻜﺘﺏ ﺃﺭﻗﺎﻡ ( ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺴﻴﺘﻭﻗﻑ ﻋﻨﺩﻫﺎ ﺘﺸﻐﻴل ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺘﻅﻬـﺭ‬
‫ﺩﻟﻔﻲ ﺍﻟﺭﺴﺎﻟﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫أﺳﻢ ﺍﻟﱪﻧﺎﻣﺞ‬ ‫ﺃﺳﻢ ﺍﻹﻋﺘﺮﺍﺽ‬ ‫ﺍﻟﺮﺳﺎﻟﺔ ﺍﳌﻮﺿﺤﺔ ﻟﺴﺒﺐ ﺍﻻﻋﺘﺮﺍﺽ‬

‫‪60‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻭﺍﻟﺘﻲ ﺘﻌﻨﻲ ﺃﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻗﺩ ﺭﻓﻊ ﺍﻋﺘﺭﺍﻀﹰﺎ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ EconvertError‬ﻤﻊ ﺭﺴﺎﻟﺔ "ﺍﻟﻨﺹ ﺍﻟﺫﻱ ﺃﺩﺨﻠﺘﻪ " ﻟﻴﺱ ﻋـﺩﺩ‬
‫ﺼﺤﻴﺢ ‪ ،‬ﺘﻡ ﺇﻴﻘﺎﻑ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻀﻐﻁ ﻋﻠﻰ ﺘﻨﻔﻴﺫ ﻤﺭﺓ ﺃﺨﺭﻯ ﻹﻜﻤﺎل ﻋﻤل ﺍﻟﺒﺭﻨﺎﻤﺞ ‪.‬‬
‫ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺘﻨﻔﻴﺫ ﺘﻅﻬﺭ ﺍﻟﺭﺴﺎﻟﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫ﻭﺍﻟﺘﻲ ﺘﻌﻨﻲ ﺃﻥ ﺍﻟﻨﺹ ﺍﻟﻤﺩﺨل ﻟﻴﺱ ﻋﺩﺩ ﺼﺤﻴﺢ ‪..‬‬

‫ﺍﺤﻔﻅ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒﺎﺴﻡ ‪ Exception1‬ﻭﻨﻔﺫﻩ ‪ ..‬ﺜﻡ ﺍﺫﻫﺏ ﺇﻟﻰ ﻓﻬﺭﺱ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺸﻐل ﺍﻟﻤﻠﻑ ﺍﻟﺘﻨﻔﻴـﺫﻱ ‪، Exception1‬‬
‫ﺃﻜﺘﺏ ﻨﺼﹰﺎ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺴﺘﻼﺤﻅ ﻅﻬﻭﺭ ﺍﻟﺭﺴﺎﻟﺔ ﺍﻟﺜﺎﻨﻴﺔ ﻓﻘﻁ ‪ ، ..‬ﺇﺫﹰﺍ ﻓﻬﺫﻩ ﻫﻲ ﺍﻟﺭﺴﺎﻟﺔ ﺍﻟﺘﻲ ﺴﺘﻅﻬﺭ ﻟﻠﻤـﺴﺘﺨﺩﻡ‬
‫ﻭﻋﻠﻰ ﻓﺭﺽ ﺃﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻻ ﻴﻌﺭﻑ ﺍﻟﻠﻐﺔ ﺍﻹﻨﻜﻠﻴﺯﻴﺔ ﻓﺈﻨﻪ ﻻ ﻴﻔﻬﻡ ﺴﺒﺏ ﺍﻟﻤﺸﻜﻠﺔ ﻭﺴﻴﻌﺘﻘﺩ ﺃﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺴﻴﺊ ‪.‬‬
‫ﻟﻤﻌﺎﻟﺠﺔ ﻫﺫﺍ ﺍﻟﺨﻁﺄ ﻋﺩل ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﺴﺎﺒﻕ ﻟﻴﺼﺒﺢ ﺒﺎﻟﺸﻜل ‪:‬‬
‫;‪Var i :integer‬‬
‫‪Begin‬‬
‫‪Try‬‬
‫;) ‪i:= strtoint(edit1.text‬‬
‫‪Except‬‬
‫) ’ﺃﺩﺨل ﻋﺩﺩ ﺼﺤﻴﺢ ﻤﻥ ﻓﻀﻠﻙ‘ ( ‪Showmessage‬‬
‫;‪end‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻵﻥ ﺒﺎﻟﻁﺭﻴﻘﺔ ﺍﻟﺴﺎﺒﻘﺔ ﻭﺴﺘﻼﺤﻅ ﻅﻬﻭﺭ ﺍﻟﺭﺴﺎﻟﺔ ﺍﻷﻭﻟﻰ ﻨﻔﺴﻬﺎ ) ﺘﻅﻬﺭ ﻫﺫﻩ ﺍﻟﺭﺴﺎﻟﺔ ﻟﺘﻨﺒﻴﻪ ﺍﻟﻤﺒﺭﻤﺞ ﻋـﻥ‬
‫ﻭﺠﻭﺩ ﺨﻁﺄ ﻫﻨﺎ ( ﻭﻟﻜﻥ ﺍﻟﺭﺴﺎﻟﺔ ﺍﻟﺜﺎﻨﻴﺔ ﻟﻥ ﺘﻅﻬﺭ ﻭﻟﻜﻥ ﺴﺘﻨﻔﺫ ﻤﻜﺎﻨﻬﺎ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﻲ ﻭﺭﺩﺕ ﺒﻌﺩ ﺍﻟﻘﺴﻡ ‪ Except‬ﻤـﻥ‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ‪. Try‬‬
‫ﺃﺤﻔﻅ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭ ﺃﻋﺩ ﺘﺸﻐﻴﻠﻪ ﻤﻥ ﻓﻬﺭﺱ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻻﺤﻅ ﺍﻟﻨﺘﺎﺌﺞ ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻤﻥ ﺍﻟﻭﺍﻀﺢ ﺃﻥ ﺍﻟﻜﺘﻠﺔ ‪ Try . . End‬ﻟﻡ ﺘﻤﻨﻊ ﺤﺩﻭﺙ ﺍﻟﺨﻁﺄ ﻭﻟﻜﻨﻬﺎ ﺘﻌﺎﻤﻠﺕ ﻤﻊ ﺍﻟﺨﻁﺄ ﺒﺄﺴـﻠﻭﺏ ﻤﺘﻁـﻭﺭ‬
‫ﻭﺍﻟﺒﺭﺍﻤﺞ ﺍﻷﻗﻭﻯ ﻫﻲ ﺍﻟﺒﺭﺍﻤﺞ ﺍﻟﺘﻲ ﺘﻤﻨﻊ ﺤﺩﻭﺙ ﺍﻟﺨﻁﺄ ﻗﺩﺭ ﺍﻟﻤﺴﺘﻁﺎﻉ ﻗﺒل ﺍﻟﺘﻌﺎﻤل ﻤﻌﻪ ﻓﻤﺜ ﹰ‬
‫ﻼ ﻓﻲ ﺒﺭﻨﺎﻤﺠﻨﺎ ﻫﻨـﺎ ﻤـﻥ‬
‫ﺍﻷﻓﻀل ﻤﻨﻊ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻤﻥ ﺇﺩﺨﺎل ﺍﻷﺤﺭﻑ ﺩﺍﺨل ‪ Edit‬ﻭﺒﺎﻟﺘﺎﻟﻲ ﻟﻥ ﻴﺤﺩﺙ ﺍﻟﺨﻁﺄ‪.‬‬
‫ﺘﺤﺩﻴﺩ ﻨﻭﻉ ﺍﻟﺨﻁﺄ ‪:‬‬
‫ﻤﺜﺎل ‪: 2‬‬
‫ﺃﻀﻑ ﻋﻨﺼﺭ ‪ Edit‬ﺇﻟﻰ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﺴﺎﺒﻕ ﻭﻋﺩﻟﻪ ﻟﻴﺼﺒﺢ ﺒﺎﻟﺸﻜل ‪:‬‬
‫;‪var i,j :integer;z:real‬‬
‫‪Begin‬‬
‫‪Try‬‬
‫;)‪i:= strtoint(edit1.text‬‬
‫;) ‪j:= strtoint(edit2.text‬‬
‫;‪z:= i/j‬‬
‫;)‪edit3.Text := floattostr(z‬‬
‫‪Except‬‬

‫‪61‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫;) ’ﺃﺩﺨل ﻋﺩﺩ ﺼﺤﻴﺢ ﻤﻥ ﻓﻀﻠﻙ‘ ( ‪Showmessage‬‬
‫;‪end‬‬
‫‪ Except‬ﻓﻲ ﺤﺎل ﺤﺩﻭﺙ ﺍﻟﺨﻁﺄ ﻋﻨﺩ ﺇﺩﺨﺎل ﻨـﺹ ﻓـﻲ ‪ Edit1‬ﺃﻭ ﻓـﻲ‬ ‫ﺍﺤﻔﻅ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻨﻔﺫﻩ ﻭﻻﺤﻅ ﺘﻨﻔﻴﺫ ﺍﻟﻘﺴﻡ‬
‫‪ Edit2‬ﺃﻱ ﺃﻥ ﺠﻤﻴﻊ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺒﻴﻥ ‪ Try‬ﻭ‪ Except‬ﺴﻭﻑ ﺘﺨﻀﻊ ﻟﻠﻔﺤﺹ ﻭ ﺠﻤﻴﻊ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺒﻴﻥ ‪ Except‬ﻭ ‪End‬‬
‫ﺴﻴﺘﻡ ﺘﻨﻔﻴﺫﻫﺎ ﻓﻲ ﺤﺎل ﺤﺩﻭﺙ ﺨﻁﺄ ‪.‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻵﻥ ﻭﺃﺩﺨل ﻓﻲ ‪ Edit1‬ﺍﻟﻘﻴﻤﺔ ‪ /232/‬ﻭﺃﺩﺨل ﻓﻲ ‪ Edit2‬ﺍﻟﻘﻴﻤﺔ ‪ / 0 /‬ﻨﻔﺫ ﺍﻟﺒﺭﻨـﺎﻤﺞ ﻭﺴـﺘﻅﻬﺭ ﺩﻟﻔـﻲ‬
‫ﺭﺴﺎﻟﺔ ﺨﻁﺄ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ EzeorDivide‬ﻭﺍﻟﺭﺴﺎﻟﺔ ﺍﻟﺜﺎﻨﻴﺔ ﺴﺘﻅﻬﺭ ﻤﻥ ﻗﺒل ﺒﺭﻨﺎﻤﺞ ) " ﺃﺩﺨل ﻋﺩﺩ ﺼﺤﻴﺢ ﻤﻥ ﻓﻀﻠﻙ" (‬
‫ﺒﺎﻟﺭﻏﻡ ﻤﻥ ﻗﻴﺎﻤﻙ ﺒﺈﺩﺨﺎل ﻋﺩﺩ ﺼﺤﻴﺢ ﻟﺫﻟﻙ ﺃﻭﺠﺩﺕ ﺩﻟﻔﻲ ﺃﺴﻠﻭﺒﹰﺎ ﻟﺘﺤﺩﻴﺩ ﻨﻭﻉ ﺍﻟﺨﻁﺄ ﻭﺘﻨﻔﻴﺫ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﻤﻨﺎﺴﺒﺔ ﻟﻠﺘﻌﺎﻤل‬
‫ﻤﻌﻪ ‪ ،‬ﻋﺩل ﺍﻵﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﺴﺎﺒﻕ ﻟﻴﺼﺒﺢ ﺒﺎﻟﺸﻜل ‪:‬‬

‫;‪Var i,j :integer;z:real‬‬

‫‪Begin‬‬
‫‪Try‬‬
‫;)‪i:= strtoint(edit1.text‬‬
‫;)‪j:= strtoint(edit2.text‬‬
‫;‪z:= i/j‬‬
‫;)‪edit3.Text := floattostr(z‬‬
‫‪Except‬‬
‫;) ’ﺃﺩﺨل ﻋﺩﺩ ﺼﺤﻴﺢ ﻤﻥ ﻓﻀﻠﻙ‘ ( ‪On Econverterror Do Showmessage‬‬
‫; ) 'ﻻ ﻴﻤﻜﻥ ﺍﻟﻘﺴﻤﺔ ﻋﻠﻰ ﺼﻔﺭ'(‪On EZeroDivide Do shOwmessage‬‬
‫;‪end‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ On Econverterror Do‬ﺘﻌﻨﻲ ‪ :‬ﻋﻨﺩ ﻭﻗﻭﻉ ﺨﻁﺄ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ EconvertError‬ﻨﻔﺫ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﻌﺩ ‪Do‬‬
‫ﻭﺒﺫﻟﻙ ﻨﺴﺘﻁﻴﻊ ﺘﺤﺩﻴﺩ ﻜﻴﻔﻴﺔ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻜل ﺨﻁﺄ ﻋﻠﻰ ﺤﺩﻯ ‪...‬‬
‫ﻫﻨﺎﻙ ﻋﺩﺩ ﻜﺒﻴﺭ ﻤﻥ ﺍﻻﻋﺘﺭﺍﻀﺎﺕ ﻭﺍﻟﺘﻲ ﺘﺼﻨﻑ ﻓﻲ ﻤﺠﻤﻭﻋﺎﺕ ﺭﺌﻴﺴﻴﺔ ) ‪ : EmathError‬ﺍﻻﻋﺘﺭﺍﻀﺎﺕ ﺍﻟﺭﻴﺎﻀـﻴﺔ‬
‫ﺃﻭ ‪ EintError‬ﺍﻋﺘﺭﻀﺎﺕ ﺍﻷﻋﺩﺍﺩ ﺍﻟﺼﺤﻴﺤﺔ ‪ ( ....‬ﻴﻨﺒﺜﻕ ﻋﻨﻬـﺎ ﺍﻋﺘﺭﺍﻀـﺎﺕ ﺠﺯﺌﻴـﺔ ) ﻤﺜـل ‪ EzerDivide‬ﺃﻭ‬
‫‪ ( ErangeError‬ﻭﺃﻓﻀل ﻁﺭﻴﻘﺔ ﻟﻠﺘﻌﺭﻑ ﻋﻠﻰ ﻫﺫﻩ ﺍﻹﻋﺘﺭﺍﻀﺎﺕ ﻫﻲ ﺍﻟﺘﻌﺎﻤل ﻤﻌﻬﺎ ﺃﺜﻨﺎﺀ ﻅﻬﻭﺭﻫـﺎ ﺤﻴـﺙ ﻴﻤﻜﻨﻨـﺎ‬
‫ﺍﻟﺤﺼﻭل ﻋﻠﻰ ﺍﺴﻡ ﺍﻻﻋﺘﺭﺍﺽ ﻤﻥ ﺍﻟﺭﺴﺎﻟﺔ ﺍﻟﺘﻲ ﺘﻅﻬﺭﻫﺎ ﺩﻟﻔﻲ ﻋﻨﺩ ﺤﺩﻭﺜﻪ ﻜﻤﺎ ﺭﺃﻴﻨﺎ ﻋﻨﺩ ﻅﻬـﻭﺭ ‪EconvertError‬‬
‫‪............‬‬
‫‪ 2‬ـ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪: Try .. .. Finally‬‬
‫ﺴﻨﺒﺩﺃ ﺒﺎﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻟﺸﺭﺡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪:‬‬
‫ﻤﺜﺎل ‪: 1‬‬
‫ﺃﻀﻑ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; ‪Var a:tstrings‬‬
‫;‪i:integer‬‬
‫‪begin‬‬
‫ﺇﻨﺸﺎﺀ ﺍﻟﻤﺘﺤﻭل ﻭﺤﺠﺯ ﻤﻜﺎﻥ ﻟﻪ ﻓﻲ ﺍﻟﺫﺍﻜﺭﺓ ‪a:= Tstringlist.Create ; //‬‬
‫‪62‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻭﻀﻊ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﻋﻨﺼﺭ ﺍﻟﺘﺤﺭﻴﺭ ﺩﺍﺨل ﻋﻨﺼﺭ ﺍﻟﺘﺤﺭﻴﺭ ‪i:= strtoint(edit1.text);//‬‬
‫;‪i:= i * 5‬‬
‫ﺇﻀﺎﻓﺔ ﻗﻴﻤﺔ ﺍﻟﻤﺘﺤﻭل ﺇﻟﻰ ﺍﻟﻼﺌﺤﺔ ‪a.Add(inttostr(i)); //‬‬
‫'‪Form1.Caption := 'Done‬‬
‫; ‪a.Free‬‬
‫ﻟﻨﻔﺭﺽ ﺃﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺃﺩﺨل ﻨﺼﹰﺎ ﻓﻲ ﻋﻨﺼﺭ ﺍﻟﺘﺤﺭﻴـﺭ ‪ Edit‬ﻭﻟـﻡ ﻴـﺩﺨل ﺃﺭﻗﺎﻤـﹰﺎ ﺴﻴﻨـﺸﺊ ﻋﻨـﺩﻫﺎ ﺍﻻﻋﺘـﺭﺍﺽ‬
‫‪ EConvertErrorr‬ﻭﺴﻴﺨﺭﺝ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻤﻥ ﺍﻹﺠﺭﺍﺀ ﻗﺒل ﺘﻨﻔﻴﺫ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ a.Free‬ﻤﻤﺎ ﺴـﻴﺅﺩﻱ ﺇﻟـﻰ ﺒﻘـﺎﺀ ﺍﻟـﺫﺍﻜﺭﺓ‬
‫ﻤﺤﺠﻭﺯﺓ ﻤﻥ ﻗﺒل ﺍﻟﻤﺘﺤﻭل ‪ ) ، a‬ﺠﻤﻴﻊ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﻲ ﺘﻠﻲ ﻤﻜﺎﻥ ﺍﻻﻋﺘﺭﺍﺽ ﻻ ﻴﺘﻡ ﺘﻨﻔﻴﺫﻫﺎ ﻭﻟﻭ ﻋﺎﺩ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺇﻟـﻰ‬
‫ﻼ ﺍﻟﺘﻌﻠﻴﻤـﺔ '‪ Form1.Caption := 'Done‬ﺍﻟﺘـﻲ ﻟـﻡ ﻴـﺘﻡ ﺘﻨﻔﻴـﺫﻫﺎ ﻓـﻲ ﺤـﺎل ﺤـﺩﺙ‬
‫ﺍﻟﻌﻤـل‪ ،‬ﻻ ﺤـﻅ ﻤـﺜ ﹰ‬
‫ﺍﻻﻋﺘﺭﺍﺽ(‬
‫ﻋﺩل ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﺴﺎﺒﻕ ﺒﺤﻴﺙ ﻴﺼﺒﺢ ﺒﺎﻟﺸﻜل ‪:‬‬

‫; ‪Var a:tstrings‬‬
‫;‪i:integer‬‬
‫‪begin‬‬
‫‪Try‬‬
‫ﺇﻨﺸﺎﺀ ﺍﻟﻤﺘﺤﻭل ﻭﺤﺠﺯ ﻤﻜﺎﻥ ﻟﻪ ﻓﻲ ﺍﻟﺫﺍﻜﺭﺓ ‪a:= Tstringlist.Create ; //‬‬
‫ﻭﻀﻊ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﻋﻨﺼﺭ ﺍﻟﺘﺤﺭﻴﺭ ﺩﺍﺨل ﻋﻨﺼﺭ ﺍﻟﺘﺤﺭﻴﺭ ‪i:= strtoint(edit1.text);//‬‬
‫;‪i:= i * 5‬‬

‫;))‪a.Add(inttostr(i‬‬
‫‪Finally‬‬
‫; '‪Form1.Caption := 'Done‬‬
‫; ‪a.Free‬‬
‫;‪end‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪ ،‬ﻭﻻﺤﻅ ﺤﺩﻭﺙ ﺍﻻﻋﺘﺭﺍﺽ ‪ ،‬ﺃﻋﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Run‬ﻭﺴﺘﺠﺩ ﺃﻥ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Finally‬ﺘﻡ‬
‫ﺘﻨﻔﻴﺫﻫﺎ ) ﻻ ﺤﻅ ﺘﻐﻴﺭ ﻋﻨﻭﺍﻥ ﺍﻟﻨﺎﻓﺫﺓ ( ‪.‬‬
‫ﺃﻜﺜﺭ ﻤﺎ ﺘﺘﻤﻴﺯ ﺒﻪ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ Try Finally‬ﺒﺄﻨﻬﺎ ﺴﺘﻘﻭﻡ ﺒﺘﻨﻔﻴﺫ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺒﻌﺩ ‪ Finally‬ﺴﻭﺍﺀ ﺤﺩﺙ ﺍﻻﻋﺘـﺭﺍﺽ ﺃﻡ ﻟـﻡ‬
‫ﻴﺤﺩﺙ ) ﻨﻔﺫ ﺍﻹﺠﺭﺍﺀ ﻭﺃﺩﺨل ﻋﺩﺩ ﺼﺤﻴﺢ ﻓﻲ ﺍﻟﻌﻨﺼﺭ ‪ Edit‬ﻭﻻﺤﻅ ﺃﻥ ﺍﻟﻘﺴﻡ ‪ Finally‬ﻗﺩ ﺘﻡ ﺘﻨﻔﻴﺫﻩ ( ‪.‬‬
‫ﺘﺴﻤﻰ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺘﻌﻠﻴﻤﺔ ﺘﺤﺭﻴﺭ ﺍﻟﻤﻭﺍﺭﺩ ﻷﻥ ﺃﻜﺜﺭ ﺍﺴﺘﺨﺩﺍﻤﺎﺘﻬﺎ ﺘﻜﻭﻥ ﻋﻨﺩ ﺍﻟﺤﺎﺠﺔ ﻹﻨﺸﺎﺀ ﻤﺘﺤﻭﻻﺕ ﻭﺘﺤﺭﻴﺭﻫﺎ ﺒﻌﺩ‬
‫ﺍﻨﺘﻬﺎﺀ ﻋﻤﻠﻬﺎ ‪.‬‬
‫ﺘﺩﺍﺨل ﺘﻌﻠﻴﻤﺎﺕ ‪: Try‬‬
‫ﻴﻤﻜﻥ ﺃﻥ ﺘﺘﺩﺍﺨل ﺘﻌﻠﻴﻤﺎﺕ ‪ Try‬ﻤﻊ ﺒﻌﻀﻬﺎ ﺍﻟﺒﻌﺽ ﺇﺫﺍ ﻜﺎﻨﺕ ﻤﻥ ﻨﻔﺱ ﺍﻟﻨﻭﻉ ﻜﻤﺎ ﻴﻠﻲ ‪:‬‬

‫‪63‬‬
http://www.alshater.net ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
Try
…….
Try
…..
Finally
……….
End;
……..
Finally
………
End;
Try
…….
Try
…..
Except
……….
End;
……..
Except
………
End;

64
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻜﻤﺎ ﺃﻨﻬﺎ ﻴﻤﻜﻥ ﺃﻥ ﺩﻤﺞ ﻨﻭﻋﻲ ﻋﺒﺎﺭﺓ ‪ Try‬ﺍﻷﻭﻟﻰ ﻟﻤﻌﺎﻟﺠﺔ ﺍﻻﻋﺘﺭﺍﺽ ) ﺍﻟﻘﺴﻡ ‪ ( Except‬ﻭﺍﻟﺜﺎﻨﻴﺔ ﻟﺤﻤﺎﻴﺔ ﺍﻟﻤـﻭﺍﺭﺩ )‬
‫ﺍﻟﻘﺴﻡ ‪ ( Finally‬ﻭﺫﻟﻙ ﻟﺘﺯﻭﻴﺩ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒﺤﻤﺎﻴﺔ ﺃﻜﺒﺭ ‪ ،‬ﻭﻟﻜﻥ ﻴﺠﺏ ﺍﻟﺤﺫﺭ ﻋﻨﺩ ﺍﺴﺘﺨﺩﺍﻡ ﻫﺫﺍ ﺍﻟﺘﺩﺍﺨل ﻟﻤﻌﺭﻓﺔ ﺃﻱ ﻤﻨﻬﻤﺎ‬
‫ﻻ‪.‬‬
‫ﻴﺤﺩﺙ ﺃﻭ ﹰ‬
‫ﺘﻨﻘﻴﺢ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪:‬‬
‫ﺒﻌﺩ ﺍﻻﻨﺘﻬﺎﺀ ﻤﻥ ﻜﺘﺎﺒﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻻ ﺒﺩ ﻤﻥ ﻓﺤﺹ ﺍﻷﺨﻁﺎﺀ ﺍﻟﺘﻲ ﻗﺩ ﺘﺤﺩﺙ ﻭﺍﻟﺘﻲ ﻻ ﻴﻤﻜﻥ ﺍﻟﺘﻨﺒﻪ ﻟﻬﺎ ﻋﻨﺩ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨـﺎﻤﺞ‬
‫ﻷﻭل ﻤﺭﺓ ﻭﺘﺩﻋﻰ ﻫﺫﻩ ﺍﻷﺨﻁﺎﺀ ﺒـ ) ‪ ( Bugs‬ﻭﻴﻭﺠﺩ ﻤﻊ ﺩﻟﻔﻲ ﺍﻟﻌﺩﻴﺩ ﻤﻥ ﺍﻷﺩﻭﺍﺕ ﺍﻟﺘﻲ ﺘﻤﻜﻥ ﺍﻟﻤﺒﺭﻤﺞ ﻤﻥ ﻓﺤـﺹ‬
‫ﺒﺭﺍﻤﺠﻪ ﻭﺍﻟﺘﺄﻜﺩ ﻤﻥ ﺨﻠﻭﻫﺎ ﻤﻥ ﺍﻷﺨﻁﺎﺀ ﻗﺒل ﺍﻟﻨﺸﺭ ‪ ،‬ﺘﺴﻤﻰ ﻋﻤﻠﻴﺎﺕ ﻓﺤﺹ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﻟﺘﺨﻠﺹ ﻤﻥ ﺃﺨﻁﺎﺌـﻪ ﺒــ )‬
‫‪( Debug‬‬

‫‪ 1‬ـ ﺍﻟﺘﺤﻜﻡ ﺒﺘﻨﻔﻴﺫ ﺒﺭﻨﺎﻤﺞ ‪:‬‬

‫ﻤﻥ ﺍﻟﻤﻔﻴﺩ ﻤﻌﺭﻓﺔ ﻗﻴﻡ ﻤﺘﺤﻭﻻﺕ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ﻭﻤﻌﺭﻓﺔ ﻜﻴﻔﻴﺔ ﺘﻐﻴﺭ ﻗﻴﻡ ﻫﺫﻩ ﺍﻟﻤﺘﺤﻭﻻﺕ ‪ ،‬ﻭﻟﻬﺫﺍ ﺃﻭﺠـﺩﺕ ﺩﻟﻔـﻲ‬
‫ﻁﺭﻗﹰﺎ ﻟﺘﻨﻔﻴﺫ ﺠﺯﺀ ﻤﻥ ﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺜﻡ ﺍﻟﺘﻭﻗﻑ ﺃﻭ ﺘﻨﻔﻴﺫ ﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺨﻁﻭﺓ ﺨﻁﻭﺓ ﻭﻓﺤﺹ ﻗﻴﻡ ﺍﻟﻤﺘﺤـﻭﻻﺕ‬
‫ﻋﻨﺩ ﻨﻘﻁﺔ ﻤﻌﻴﻨﺔ ﺜﻡ ﺍﻟﻌﻭﺩﺓ ﻟﻠﺘﻨﻔﻴﺫ ‪.‬‬
‫ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺨﻁﻭﺓ ﺨﻁﻭﺓ ‪:‬‬
‫ﻴﻭﺠﺩ ﺃﻤﺭﻴﻥ ﻟﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺨﻁﻭﺓ ﺨﻁﻭﺓ ﺃﻭﻻﻫﻤﺎ ﺍﻷﻤﺭ ‪ Trace into‬ﻭﺍﻟﺫﻱ ﻴﻤﻜﻥ ﺍﺨﺘﻴﺎﺭﻩ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪ Run‬ﺃﻭ ﻋﺒﺭ‬

‫ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ‬

‫ﻤﻥ ﺃﺯﺭﺍﺭ ﺍﻟﺴﺭﻋﺔ ﺃﻭ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ‪ F7‬ﻤﻥ ﻟﻭﺤﺔ ﺍﻟﻤﻔﺎﺘﻴﺢ ﻭﺍﻟﺜﺎﻨﻲ ‪ Step Over‬ﺍﻟﺫﻱ ﻴﻤﻜﻥ ﺘﻨﻔﻴﺫﻩ ﻤﻥ ﺍﻟﻘﺎﺌﻤـﺔ ‪Run‬‬
‫ﺃﻭ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ‪. F8‬‬ ‫ﺃﻭ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ‬
‫ﻋﻨﺩ ﺍﺨﺘﻴﺎﺭ ﺍﻷﻤﺭ ‪ Trace Into‬ﻴﻘﻭﻡ ﺒﺘﻨﻔﻴﺫ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻷﻭﻟﻰ ﻤﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺜﻡ ﻨﻀﻐﻁ ﻋﻠﻴﻪ ﻤﺭﺓ ﺜﺎﻨﻴﺔ ﻟﺘﻨﻔﻴـﺫ ﺍﻟﺘﻌﻠﻴﻤـﺔ‬
‫ﺍﻟﺜﺎﻨﻴﺔ ﻭﻫﻜﺫﺍ ﻭﺇﺫﺍ ﺼﺎﺩﻑ ﻫﺫﺍ ﺍﻷﻤﺭ ﺇﺠﺭﺍﺀ ﺃﻭ ﺘﺎﺒﻌﹰﺎ ﻴﻨﺘﻘل ﺇﻟﻴﻪ ﻟﻴﻨﻔﺫ ﺘﻌﻠﻴﻤﺎﺘﻪ ﻜﺫﻟﻙ ‪.‬‬
‫ﻭﺍﻷﻤﺭ ‪ Step Over‬ﻴﺸﺎﺒﻪ ﺍﻷﻤﺭ ‪ Trace Into‬ﻭﻟﻜﻨﻪ ﺇﺫﺍ ﺼﺎﺩﻑ ﺇﺠﺭﺍﺀ ﺃﻭ ﺘﺎﺒﻌﹰﺎ ﻓﺈﻨﻪ ﻴﻨﻔﺫﻩ ﺒﺎﻟﻜﺎﻤل ﻭﻴﻌـﻭﺩ ﺇﻟـﻰ‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﻲ ﺘﻠﻲ ﻁﻠﺏ ﻫﺫﺍ ﺍﻹﺠﺭﺍﺀ ‪.‬‬
‫ﻤﺜﺎل ‪:‬‬
‫ﺃﻀﻑ ﺯﺭ ﻭﻋﻨﺼﺭ ﻻﺌﺤﺔ ‪ ListBox‬ﺇﻟﻰ ﺒﺭﻨﺎﻤﺞ ﺠﺩﻴﺩ ﻭﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; ‪Var s:string‬‬
‫;‪i , j ,z :integer‬‬
‫‪begin‬‬
‫‪for i := 0 to 500 do‬‬
‫‪begin‬‬
‫;‪j:= i * 5‬‬
‫; ‪z:= j * 2‬‬
‫;)‪s:= inttostr ( j ) + ' ' + inttostr(z‬‬
‫;‪Form1.Caption := s‬‬
‫)‪listbox1.Items.Add(s‬‬

‫‪65‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫;‪end‬‬
‫ﺃﻀﻐﻁ ﻋﻠﻰ ‪ F7‬ﻋﺩﺓ ﻤﺭﺍﺕ ﺤﺘﻰ ﻴﻨﻬﻲ ﺍﻷﻤﺭ ‪ Trace Into‬ﺘﻌﻠﻴﻤﺎﺕ ﺘﻬﻴﺌﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻴﺩﺨل ﻓـﻲ ﺠﻤﻠـﺔ ﺍﻟﺘﻌﻠﻴﻤـﺎﺕ‬
‫ﺍﻟﻤﻜﺘﻭﺒﺔ ﻓﻲ ﺍﻷﻋﻠﻰ ‪ ،‬ﺃﻀﻐﻁ ﺍﻵﻥ ﻋﻠﻰ ‪ F7‬ﻤﺭﺓ ﺃﺨﺭﻯ ﻭﻻﺤﻅ ﺍﻨﺘﻘﺎل ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺇﻟﻰ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﺤﻴﺙ ﻴﻅﻬﺭ‬
‫ﺴﻬﻡ ﺃﺨﻀﺭ ﻋﻠﻰ ﻴﺴﺎﺭ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﻲ ﺴﺘﻨﻔﺫ ﻋﻥ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ‪ F7‬ﻓﻲ ﺍﻟﻤﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ ‪.‬‬
‫ﻜﺭﺭ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ‪ F7‬ﺤﺘﻰ ﻴﺼل ﺍﻟﺴﻬﻡ ﺍﻷﺨﻀﺭ ﺇﻟﻰ ﺍﻟﺘﻌﻠﻴﻤﺔ )‪ ، listbox1.Items.Add(s‬ﺤـﺭﻙ ﺍﻵﻥ ﻤﺅﺸـﺭ‬
‫ﻼ ﺃﻭﻗﻑ ﺍﻟﻤﺅﺸﺭ ﻓﻭﻕ ﺍﻟﻤﺘﺤﻭل ‪ I‬ﺴﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﺨﺯﻨﺔ ﻓﻲ ‪I‬‬
‫ﺍﻟﻔﺄﺭﺓ ﻟﻴﻘﻑ ﻓﻭﻕ ﺍﻟﻤﺘﺤﻭﻻﺕ ﻓﻲ ﺠﺴﻡ ﺍﻟﺤﻠﻘﺔ ﻤﺜ ﹰ‬
‫ﻭﻜﺫﻟﻙ ﻓﻲ ‪ Z‬ﻭ ‪....S‬‬
‫ﺃﻀﻐﻁ ﻋﻠﻰ ‪ F7‬ﻤﺭﺘﻴﻥ ﺤﺘﻰ ﻴﻘﻑ ﺍﻟﺴﻬﻡ ﺍﻷﺨﻀﺭ ﺒﺠﺎﻨﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ j:= i * 5‬ﻭﻻﺤﻅ ﺃﻨﻪ ﻴﻤﻜﻨﻙ ﺍﻟﺤﺼﻭل ﻋﻠﻰ ﻗﻴﻤﺔ‬
‫‪ I‬ﺍﻟﺠﺩﻴﺩﺓ ﻭﻻ ﻴﻤﻜﻨﻙ ﺍﻟﺤﺼﻭل ﻋﻠﻰ ﻜل ﻤﻥ ﻗﻴﻤﺔ ‪ j‬ﻭ ‪ Z‬ﻭ ‪ s‬ﻭﻴﻌﻭﺩ ﺍﻟﺴﺒﺏ ﻷﻥ ‪ I‬ﻗﺩ ﺃﺨﺫﺕ ﻗﻴﻤﺘﻬﺎ ﺍﻟﺠﺩﻴﺩﺓ ﺒﻴﻨﻤﺎ ﺒﺎﻗﻲ‬
‫ﺍﻟﻘﻴﻡ ﻟﻡ ﻴﺘﻡ ﺇﻋﻁﺎﺌﻬﺎ ﻗﻴﻡ ﺠﺩﻴﺩﺓ ﺒﻌﺩ ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪:‬‬
‫ﻴﺴﺘﺨﺩﻡ ﺍﻷﻤﺭ ‪ Step Over‬ﺒﻨﻔﺱ ﺍﻟﻁﺭﻴﻘﺔ ﻭﻟﻜﻥ ﻋﻠﻴﻙ ﺒﺩﺃ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒـ ‪ Trace Into‬ﺤﺘﻰ ﻴﺘﻡ ﺘﻨﻔﻴـﺫ ﺍﻟﺘﻌﻠﻴﻤـﺔ‬
‫‪ Application.Run‬ﻷﻥ ﺍﻹﺠﺭﺍﺀ ‪ Step Over‬ﻴﻌﺘﺒﺭﻫﺎ ﺘﻌﻠﻴﻤﺔ ﻭﺍﺤﺩﺓ ﻭﻴﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒﻌﺩﻫﺎ ﺒﺎﻟﻜﺎﻤل ‪.‬‬

‫ﺍﻷﻤﺭ ‪: Run To Cursor‬‬

‫ﻗﺩ ﻴﻜﻭﻥ ﺃﺤﻴﺎﻨﹰﺎ ﻤﻥ ﺍﻟﺼﻌﺏ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺨﻁﻭﺓ ﺨﻁﻭﺓ ﻟﻠﻭﺼﻭل ﺇﻟﻰ ﻤﺠﻤﻭﻋﺔ ﺘﻌﻠﻴﻤﺎﺕ ﻨﺭﻴﺩ ﻓﺤﺼﻬﺎ ﻟﺫﻟﻙ ﻭﺠﺩ ﻫﺫﺍ‬
‫ﺍﻷﻤﺭ ﺤﻴﺙ ﻴﻜﻔﻲ ﺃﻥ ﺘﻀﻊ ﻤﺅﺸﺭ ﺍﻟﻜﺘﺎﺒﺔ ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺒﺭﻤﺠﻲ ﺍﻟﺫﻱ ﺘﺭﻴﺩ ﺜﻡ ﺘﺨﺘﺎﺭ ﺍﻷﻤـﺭ ‪ Run To Cursor‬ﻤـﻥ‬
‫ﺍﻟﻘﺎﺌﻤﺔ ‪ Run‬ﺃﻭ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ‪ F4‬ﻋﻨﺩﻫﺎ ﺴﻴﺘﻡ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺤﺘﻰ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﻲ ﻭﻗﻔﺕ ﻋﻨﺩﻫﺎ ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻻ ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﻁﺭﻕ ﺍﻟﺜﻼﺙ ﻟﻤﻌﺭﻓﺔ ﻗﻴﻡ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻓﺤﺴﺏ ‪ ،‬ﻓﻬﻲ ﺘﺴﺘﺨﺩﻡ ﻓﻲ ﺍﻟﺒﺭﺍﻤﺞ ﺍﻟﻜﺒﻴﺭﺓ ﻭﺨﺎﺼـﺔ‬
‫ﻋﻨﺩﻤﺎ ﻴﻌﻁﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻓﻲ ﺃﻤﺎﻜﻥ ﻤﻌﻴﻨﺔ ﻨﺘﺎﺌﺞ ﻏﻴﺭ ﻤﺘﻭﻗﻌﺔ ﺃﻭ ﻨﺘﺎﺌﺞ ﻏﻴﺭ ﺍﻟﻤﻁﻠﻭﺒﺔ ‪ ،‬ﺤﻴﺙ ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻷﻭﺍﻤﺭ ﺒﺈﻋﻁﺎﺌﻙ‬
‫ﻤﻌﻠﻭﻤﺎﺕ ﻋﻥ ﺴﻴﺭ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻤﻌﺭﻓﺔ ﺍﻟﻨﻘﻁﺔ ﺍﻟﺘﻲ ﻴﺤﺩﺙ ﻓﻴﻬﺎ ﺍﻟﺨﻠل‪ ،‬ﻜﻤﺎ ﺃﻥ ﺩﻟﻔﻲ ﻗﺩ ﺘﻌﻁﻴﻙ ﺒﻌﺽ ﺭﺴﺎﺌل ﺍﻷﺨﻁـﺎﺀ‬
‫ﺍﻟﺘﻲ ﻻ ﻴﻤﻜﻥ ﺘﺤﺩﻴﺩ ﻤﻜﺎﻨﻬﺎ ﺒﺴﻬﻭﻟﺔ ‪.‬‬
‫ﻨﻘﺎﻁ ﺍﻟﺘﻭﻗﻑ ‪:‬‬
‫ﺘﺴﺘﺨﺩﻡ ﻨﻘﺎﻁ ﺍﻟﺘﻭﻗﻑ ﻹﻴﻘﺎﻑ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻓﻲ ﻨﻘﺎﻁ ﻤﺤﺩﺩﺓ ﺤﻴﺙ ﻴﺴﺘﻤﺭ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺤﺘﻰ ﻭﺼﻭل ﺍﻟﺒﺭﻨﺎﻤﺞ ﺇﻟﻰ ﺍﻟـﺴﻁﺭ‬
‫ﺍﻟﻤﺤﺩﺩ ﻭﺘﺨﺘﻠﻑ ﻨﻘﺎﻁ ﺍﻟﺘﻭﻗﻑ ﻋﻥ ﺍﻷﻤﺭ ‪ Run To Cursor‬ﺒﺄﻨﻨﺎ ﻨﺴﺘﻁﻴﻊ ﺇﻀﺎﻓﺔ ﻋﺩﺩ ﻜﺒﻴﺭ ﻤﻥ ﻨﻘﺎﻁ ﺍﻟﺘﻭﻗـﻑ ﻓـﻲ‬
‫ﺍﻟﺒﺭﻨﺎﻤﺞ ‪.‬‬
‫ﻭﻹﻀﺎﻓﺔ ﻨﻘﻁﺔ ﺘﻭﻗﻑ ﻓﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻨﻀﻊ ﺍﻟﻤﺅﺸﺭ ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﻤﺭﺍﺩ ﺍﻟﺘﻭﻗﻑ ﻋﻨﺩﻩ ﻭﻨﺨﺘﺎﺭ ﺍﻷﻤﺭ ‪Add Breakpoint‬‬
‫ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪ Run‬ﺜﻡ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ‪ Ok‬ﻓﻲ ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ﺃﻭ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ‪ F5‬ﺃﻭ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﻴـﺴﺎﺭ ﺍﻟـﺴﻁﺭ‬
‫ﺒﺎﻟﻔﺄﺭﺓ ﻭﺘﺘﻤﻴﺯ ﺍﻟﺴﻁﻭﺭ ﺍﻟﻤﻌﻠﻤﺔ ﺒﻨﻘﺎﻁ ﺘﻭﻗﻑ ﺒﻠﻭﻨﻬﺎ ﺍﻷﺤﻤﺭ ‪.‬‬
‫ﺴﻨﺘﻌﻠﻡ ﺍﻵﻥ ﻜﻴﻔﻴﺔ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻨﻘﺎﻁ ﺍﻟﺘﻭﻗﻑ ﻭﺴﻨﺘﻌﻠﻡ ﻻﺤﻘﹰﺎ ﻜﻴﻔﻴﺔ ﺍﻻﺴﺘﻔﺎﺩﺓ ﻤﻨﻬﺎ ‪.‬‬

‫‪66‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻨﻘﺎﻁ ﺍﻟﺘﻭﻗﻑ ‪:‬‬
‫‪ 1‬ـ ﻋﺭﺽ ﺠﻤﻴﻊ ﻨﻘﺎﻁ ﺍﻟﺘﻭﻗﻑ ‪:‬‬
‫ﻴﻤﻜﻥ ﺘﻭﺯﻴﻊ ﻨﻘﺎﻁ ﺍﻟﺘﻭﻗﻑ ﻓﻲ ﻜل ﻭﺤﺩﺍﺕ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒﻨﻔﺱ ﺍﻟﻭﻗﺕ ﻭﻟﻌﺭﺽ ﻗﺎﺌﻤﺔ ﺒﺠﻤﻴﻊ ﺃﻭﺍﻤﺭ ﺍﻟﺘﻭﻗـﻑ ﻨﺨﺘـﺎﺭ ﻤـﻥ‬
‫ﺍﻟﻘﺎﺌﻤﺔ ‪View‬‬
‫‪View Æ Debug Window Æ Breakpoints‬‬
‫ﺤﻴﺙ ﺘﻅﻬﺭ ﻨﺎﻓﺫﺓ ﺘﻅﻬﺭ ﻨﺎﻓﺫﺓ ﺘﺨﺒﺭﻙ ﺒﺎﺴﻡ ﺍﻟﻭﺤﺩﺓ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻴﻬﺎ ﻨﻘﻁﺔ ﺍﻟﺘﻭﻗﻑ ﻭﻓﻲ ﺃﻱ ﺴﻁﺭ ﻤﻥ ﺍﻟﺸﻴﻔﺭﺓ ‪.‬‬
‫‪ 2‬ـ ﺘﻌﻁﻴل ﻨﻘﺎﻁ ﺍﻟﺘﻭﻗﻑ ‪:‬‬
‫ﻴﻤﻜﻥ ﺘﻌﻁﻴل ﻨﻘﺎﻁ ﺍﻟﺘﻭﻗﻑ ﻤﺅﻗﺘﹰﺎ ﺒﺎﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺩﺍﺌﺭﺓ ﺍﻟﺤﻤﺭﺍﺀ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﻤﻴﻨﻲ ﻭﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺨﻴـﺎﺭ ‪Enable‬‬
‫ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﻤﻨﺒﺜﻘﺔ ﺤﻴﺙ ﻴﺘﺤﻭل ﻟﻭﻥ ﻨﻘﻁﺔ ﺍﻟﺘﻭﻗﻑ ﺇﻟﻰ ﺍﻟﻠﻭﻥ ﺍﻷﺨﻀﺭ ﻭﻴﻤﻜﻥ ﺇﻋﺎﺩﺓ ﺍﻟﻨﻘﻁﺔ ﺇﻟﻰ ﺍﻟﻌﻤل ﺒﺘﻜﺭﺍﺭ ﺍﻟﻌﻤﻠﻴﺔ‬
‫‪ 3‬ـ ﺤﺫﻑ ﻨﻘﻁﺔ ﺘﻭﻗﻑ ‪:‬‬
‫ﻴﺘﻡ ﺤﺫﻑ ﻨﻘﻁﺔ ﺍﻟﺘﻭﻗﻑ ﺒﺎﻟﻁﺭﻴﻘﺔ ﺍﻟﺘﻲ ﺘﻡ ﺇﻨﺸﺎﺀﻫﺎ ﺒﻬﺎ ) ﺃﻱ ﺒﺈﻤﻜﺎﻨﻙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺩﺍﺌﺭﺓ ﺍﻟﺤﻤﺭﺍﺀ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﺴﺎﺭﻱ‬
‫ﺃﻭ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ‪( .... F5‬‬
‫ﻴﻤﻜﻥ ﺤﺫﻑ ﺠﻤﻴﻊ ﻨﻘﺎﻁ ﺍﻟﺘﻭﻗﻑ ﻋﻥ ﻁﺭﻴﻕ ﻋﺭﺽ ﺍﻻﺌﺤﺔ ‪ View Æ Debug Window Æ Breakpoints‬ﻭﻤﻥ‬
‫ﺜﻡ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺇﺤﺩﻯ ﺍﻟﻨﻘﺎﻁ ﻓﻲ ﺍﻟﻼﺌﺤﺔ ﺒﺯﺭ ﺍﻟﻴﻤﻴﻥ ﻟﻠﻔﺄﺭﺓ ﻭﺍﺨﺘﻴﺎﺭ ﺍﻷﻤﺭ ‪.... Breakpoint Æ Delete All‬‬
‫‪ 4‬ـ ﺍﺴﺘﺨﺩﺍﻡ ﻨﻘﺎﻁ ﺘﻭﻗﻑ ﺸﺭﻁﻴﺔ ‪:‬‬
‫ﻼ ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﻭﺼﻭل‬
‫ﻴﻤﻜﻨﻙ ﺘﺤﺩﻴﺩ ﺸﺭﻁ ﻟﻨﻘﻁﺔ ﺍﻟﺘﻭﻗﻑ ﺤﻴﺙ ﻻ ﻴﺘﻭﻗﻑ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺇﻻ ﺇﺫﺍ ﺤﺼل ﻫﺫﺍ ﺍﻟﺸﺭﻁ ) ﻤﺜ ﹰ‬
‫ﺍﻟﻤﺘﺤﻭل ‪ j‬ﺇﻟﻰ ﺍﻟﻘﻴﻤﺔ ‪ ( 500‬ﻭﻴﺘﻡ ﺫﻟﻙ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﻤﻴﻨﻲ ﻋﻠﻰ ﺍﻟﻨﻘﻁﺔ ﺍﻟﺤﻤﺭﺍﺀ ﻭﻤﻥ ﺜﻡ ﺍﺨﺘﻴـﺎﺭ‬
‫‪ Breakpoint Properties‬ﻭﻤﻥ ﺜﻡ ﻜﺘﺎﺒﺔ ﺍﻟﺸﺭﻁ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Condition‬ﻓﻲ ﺍﻟﻨﺎﻓﺫﺓ ﻤﺜ ﹰ‬
‫ﻼ ﺃﻜﺘـﺏ ﺍﻟـﺸﺭﻁ ) = ‪j‬‬
‫‪( 500‬‬
‫‪ 5‬ـ ﺍﺴﺘﺨﺩﺍﻡ ﻋﺩﺩ ﻤﺭﺍﺕ ﺍﻟﻌﺒﻭﺭ ‪:‬‬
‫ﻴﻤﻜﻥ ﺃﻥ ﻨﻁﻠﺏ ﻤﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺃﻥ ﻴﻘﻑ ﻋﻥ ﻨﻘﻁﺔ ﺍﻟﺘﻭﻗﻑ ﻋﻨﺩ ﺘﻨﻔﻴﺫﻫﺎ ﻟﻌﺩﺩ ﻤﻌﻴﻥ ﻤﻥ ﺍﻟﻤﺭﺍﺕ‪ ،‬ﻭﻴﺘﻡ ﺫﻟﻙ ﻋـﻥ ﻁﺭﻴـﻕ‬
‫ﺍﻟﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﻤﻴﻨﻲ ﻋﻠﻰ ﺍﻟﻨﻘﻁﺔ ﺍﻟﺤﻤﺭﺍﺀ ﻭﻤﻥ ﺜﻡ ﺍﺨﺘﻴﺎﺭ ‪ Breakpoint Properties‬ﻭﻤﻥ ﺜﻡ ﻜﺘﺎﺒـﺔ ﻋـﺩﺩ‬
‫ﺍﻟﻤﺭﺍﺕ ﺍﻟﻤﻁﻠﻭﺒﺔ ﻓﻲ ﺍﻟﻘﺴﻡ ‪Pass count‬‬
‫ﻼ ﺃﻀﻑ ﻨﻘﻁﺔ ﺘﻭﻗﻑ ﻋﻥ ﺍﻟﺴﻁﺭ )‪ listbox1.Items.Add(s‬ﺜﻡ ﺤﺩﺩ ‪ Pass Count‬ﺒـ ‪ 100‬ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻵﻥ‬
‫ﻤﺜ ﹰ‬
‫ﻭﺴﺘﻼﺤﻅ ﺘﻭﻗﻑ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻋﻥ ﺍﻟﻌﻤل ﻋﻨﺩﻤﺎ ﺘﻨﻔﺫ ﺍﻟﺤﻠﻘﺔ ‪ 100‬ﻤﺭﺓ ‪.‬‬
‫ﻤﺭﺍﻗﺒﺔ ﺍﻟﺘﻌﺎﺒﻴﺭ ﻭﺍﻟﻤﺘﺤﻭﻻﺕ ‪:‬‬
‫ﺘﺴﺘﺨﺩﻡ ﺍﻟﻤﺭﺍﻗﺒﺔ ﻟﻤﻌﺭﻓﺔ ﻗﻴﻡ ﺘﻌﺎﺒﻴﺭ ﻭﻤﺘﺤﻭﻻﺕ ﻤﺤﺩﺩﺓ ﺃﺜﻨﺎﺀ ﺴﻴﺭ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪،‬ﻭﻹﻀﺎﻓﺔ ﻨﻘﻁﺔ ﻤﺭﺍﻗﺒﺔ ﺍﺘﺒﻊ ﺇﺤﺩﻯ ﺍﻟﻁﺭﻕ‬
‫ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ 1‬ـ ﺤﺩﺩ ﺍﻟﻤﺘﺤﻭل ﺍﻟﺫﻱ ﺘﺭﻴﺩ ﺇﻀﺎﻓﺔ ﻨﻘﻁﺔ ﻤﺭﺍﻗﺒﺔ ﻟﻪ ﻭﺍﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﻤﻴﻨﻲ ﻭﺃﺨﺘﺭ ﺍﻷﻤـﺭ ‪Debug Æ Add‬‬
‫‪Watch at Cursor‬‬
‫‪ 2‬ـ ﺍﺨﺘﺭ ‪ Add Watch‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪ Run‬ﺃﻭ ﺍﻀﻐﻁ ‪. Ctrl F5‬‬
‫‪ 3‬ـ ﺇﻅﻬﺎﺭ ﺍﻟﻨﺎﻓﺫﺓ ‪ Watch List‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪View Æ Debug Windows Æ watches View‬‬

‫‪67‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻋﻨﺩﺌ ٍﺫ ﺴﻴﻅﻬﺭ ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ﺍﻟﺘﺎﻟﻲ ﺤﻴﺙ ﻴﻤﻜﻨﻙ ﻜﺘﺎﺒﺔ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﺭﺍﺩ ﻤﺭﺍﻗﺒﺘﻬﺎ ﻓﻲ ﺍﻟﻘﺴﻡ ‪. Expression‬‬
‫ﺒﻌﺩ ﺇﻀﺎﻓﺔ ﺍﻟﻤﺘﺤﻭﻻﺕ ﺍﻟﻤﻁﻠﻭﺏ ﻤﺭﺍﻗﺒﺘﻬﺎ ﻋﻠﻴﻙ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺨﻁﻭﺓ ﺨﻁﻭﺓ ﺃﻭ ﺍﺴﺘﺨﺩﺍﻡ ﻨﻘﺎﻁ ﺍﻟﺘﻭﻗﻑ‪ ،‬ﺤﻴﺙ ﺴـﺘﺒﻘﻰ‬
‫ﻨﺎﻓﺫﺓ ﺍﻟﻤﺭﺍﻗﺒﺔ ﻤﻔﺘﻭﺤﺔ ﻭﺘﻌﻁﻴﻙ ﻗﻴﻤﺔ ﺍﻟﻤﺘﺤﻭﻻﺕ ﻓﻲ ﻜل ﻟﺤﻅﺔ ﻴﺘﻭﻗﻑ ﻓﻴﻬﺎ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪.‬‬
‫ﻻ ﻻﺌﺤﺔ ﻋﻨﺎﺼﺭ ﺍﻟﻤﺭﺍﻗﺒﺔ ﻋﻥ ﻁﺭﻴﻕ ‪View Æ Debug Windows Æ :‬‬ ‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻋﻨﺎﺼﺭ ﺍﻟﻤﺭﺍﻗﺒﺔ ‪:‬ﺃﻓﺘﺢ ﺃﻭ ﹰ‬
‫‪watches‬‬
‫ﻴﻤﻜﻨﻙ ﺘﻌﻁﻴل ﻋﻨﺼﺭ ﻤﺭﺍﻗﺒﺔ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﻀﻐﻁ ﻋﻠﻴﻪ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﻤﻴﻨﻲ ﻭﺍﺨﺘﻴﺎﺭ ﺍﻷﻤﺭ ‪ ، Disable‬ﻭﻟﺤﺫﻑ ﻋﻨﺼﺭ‬
‫ﻤﺭﺍﻗﺒﺔ ﻨﻬﺎﺌﻴﹰﺎ ﻨﺨﺘﺎﺭ ‪. Delete‬‬
‫ﻟﻠﺘﻐﻴﺭ ﻓﻲ ﻋﻨﺼﺭ ﺍﻟﻤﺭﺍﻗﺒﺔ ﻨﺨﺘﺎﺭ ﺍﻷﻤﺭ ‪ Edit Watch‬ﻓﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ‪:‬‬
‫ﺤﻴﺙ ‪ Expression‬ﻫﻭ ﺍﻟﺘﻌﺒﻴﺭ ﺍﻟﻤﺭﺍﺩ ﻤﺭﺍﻗﺒﺘﻪ‬
‫ﻭﻨﺴﺘﻁﻴﻊ ﻫﻨﺎ ﺃﻥ ﻨﻜﺘﺏ ﺘﻌﺒﺭﹰﺍ ﻤﺎ ﻓﺭﻀﹰﺎ ﻴﻤﻜـﻥ‬
‫ﻤﺭﺍﻗﺒﺔ ﻗﻴﻤﺔ ‪ i+j‬ﺭﻏﻡ ﺃﻥ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﻏﻴـﺭ‬
‫ﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺴﻁﻭﺭ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪.‬‬
‫ـﺴﺎﻕ‬
‫ـﻊ ﺍﻷﻨـ‬
‫ـﺴﺘﺨﺩﻡ ﻤـ‬
‫‪ : Repeat Count‬ﺘـ‬
‫ﻭﺍﻟﺴﺠﻼﺕ ﻓﺒﻔﺭﺽ ﻟﺩﻴﻨﺎ ﻤﺼﻔﻭﻓﺔ ﻤـﻥ ﺃﺭﺒـﻊ‬
‫ﻋﻨﺎﺼﺭ ﻓﻨﻜﺘﺏ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Expression‬ﺃﺴـﻡ‬
‫ﺍﻟﻤـــــﺼﻔﻭﻓﺔ ﻭﻓـــــﻲ ﺍﻟﺤﻘـــــل‬
‫‪ Repeat Count‬ﺍﻟﻘﻴﻤﺔ ‪ /4 /‬ﻋﻨﺩﻫﺎ ﺴﺘﻅﻬﺭ ﺠﻤﻴﻊ ﻋﻨﺎﺼﺭ ﺍﻟﻤﺼﻔﻭﻓﺔ ﺃﺜﻨﺎﺀ ﺍﻟﻤﺭﺍﻗﺒﺔ ‪.‬‬
‫ﻜﻤﺎ ﻴﻤﻜﻥ ﺘﺤﺩﻴﺩ ﻜﻴﻔﻴﺔ ﻅﻬﻭﺭ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻤﻥ ﺠﺯﺀ ﺍﻟﻨﺎﻓﺫﺓ ﻓﻲ ﺍﻷﺴﻔل ﻓﺎﺨﺘﻴﺎﺭ ‪ Hexadecimal‬ﺴﻴﻅﻬﺭ ﻗﻴﻤﺔ ﺍﻟﻤﺘﺤﻭل‬
‫ﻓﻲ ﺍﻟﻨﻅﺎﻡ ﺍﻟﺴﺕ ﻋﺸﺭﻱ ﻭﻴﺤﺩﺩ ﺍﻟﺤﻘل ‪ Digits‬ﻋﺩﺩ ﺍﻷﺭﻗﺎﻡ ﺒﻌﺩ ﺍﻟﻔﺎﺼﻠﺔ ﻋﻨـﺩ ﺇﻅﻬـﺎﺭ ﺍﻟـﺭﻗﻡ ﺒﺎﻟﻔﺎﺼـﻠﺔ ﺍﻟﻌﺎﺌﻤـﺔ‬
‫‪. Floating Point‬‬
‫ﺭﺅﻴﺔ ﺍﺴﺘﺩﻋﺎﺀ ﺍﻟﺭﻭﺘﻴﻨﺎﺕ ‪:‬‬
‫ﻴﻤﻜﻨﻨﺎ ﻤﺸﺎﻫﺩﺓ ﺍﻟﻤﻜﺩﺱ ﺍﻟﺫﻱ ﻴﺤﻭﻱ ﻋﻠﻰ ﺍﺴﺘﺩﻋﺎﺀ ﺍﻻﺠﺭﺍﺀﺍﺕ ﻋﻥ ﻁﺭﻴﻕ ‪View Æ Debug Windows Æ call‬‬
‫‪Stack‬‬
‫ﺤﻴﺙ ﻴﺘﻭﻀﻊ ﻓﻲ ﺃﻋﻠﻰ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﺎﺒﻊ ﺍﻟﻤﺴﺘﺩﻋﻰ ﺤﺎﻟﻴﹰﺎ ﻭﺍﻟﺴﻁﺭ ﺍﻟﺫﻱ ﻴﻠﻴﻪ ﺍﻟﺘﺎﺒﻊ ﺍﻟﺫﻱ ﻗﺎﻡ ﺒﺎﺴﺘﺩﻋﺎﺌﻪ ‪.‬‬
‫; ) ‪Add ( 10‬‬ ‫ﻤﺜﺎل ‪ :‬ﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫; ) ‪Procedure Add ( x‬‬ ‫ﻭﻋﺭﻑ ﺍﻹﺠﺭﺍﺀ ‪ Add‬ﺒﺎﻟﺸﻜل ﺍﻟﺘﺎﻟﻲ ‪:‬‬

‫‪Begin‬‬
‫;‪X := x +1‬‬
‫ﺴﻴﻌﻴﺩ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﺘﻨﻔﻴﺫ ﻨﻔﺴﻪ ﺤﺘﻰ ﻭﺼﻭل ﺍﻟﻤﺘﺤﻭل ﺇﻟﻰ ﺍﻟﻘﻴﻤﺔ ‪If X < 50 then Add ( x ) ; // 50‬‬
‫;‪End‬‬ ‫ﻨﻔﺫ ﺍﻵﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺨﻁﻭﺓ ﺨﻁﻭﺓ ﻭﻻﺤﻅ ﺘﻐﻴﺭ‬
‫ﺍﻟﻨﺘﺎﺌﺞ ‪.‬‬

‫‪68‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ﺍﻟﺜﺎﺜﺜﺔ ﻋﺸﺭ‬
‫ﻤﺎ ﻫﻲ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ؟‪:‬‬
‫ﺏ ﺘﺴﺘﻁﻴﻊ ﻤﻥ ﺨﻼﻟﻪ ﺘﺨﺯﻴﻥ ﻜﻤ ‪‬ﻴ ﹰﺔ ﻀﺨﻤ ﹰﺔ ﻤﻥ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻟﺘﻲ ﺘﺭﺒﻁﻬﺎ ﻋﻼﻗﺎﺕ‬
‫ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ ‪ Database‬ﻫﻲ ﺘﺭﻜﻴ ‪‬‬
‫ﻑ ‪ File‬ﺃﻭ ﻤﺠﻤﻭﻋﺔ ﻤﻠﻔﹼﺎﺕ ﺘﹸﺨﺯ‪‬ﻥ ﻋﻠﻰ ﺍﻟﻘـﺭﺹ ﺍﻟـﺼﻠﺏ‬
‫ﻥ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻤﺎ ﻫﻲ ﺇﻻ ﻤﻠ ﹼ‬
‫ﻤﻌﻴ‪‬ﻨﺔ‪ ،‬ﻭﺤﻘﻴﻘ ﹸﺔ ﺍﻷﻤﺭ‪ ،‬ﻓﺈ ‪‬‬
‫ﻥ ﻤﺎ ﻴﻤﻴ‪‬ﺯﻫﺎ ﻋﻥ ﺒﺎﻗﻲ ﺍﻟﻤﻠﻔﹼﺎﺕ‪ ،‬ﻫﻭ ﻗﺩﺭﺘﻙ ﻋﻠـﻰ ﻜﺘﺎﺒـﺔ ﺍﻟﻤﻌﻁﻴـﺎﺕ ﻓﻴﻬـﺎ‬
‫ل ﺍﻟﻤﻠﻔﹼﺎﺕ ﺍﻟﻌﺎﺩﻴ‪‬ﺔ‪ ،‬ﻭﻟﻜ ‪‬‬
‫‪ Hard Disk‬ﻜﻜ ّ‬
‫ﻑ‬
‫ﻭﻗﺭﺍﺀﺘﻬﺎ ﻤﻨﻬﺎ‪ ،‬ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻭﺴﺎﺌل ﺍﻟﺘﻲ ﺘﻤﻨﺤﻬﺎ ﻟﻙ ﺒﺭﺍﻤﺞ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ‪ ،‬ﺩﻭﻥ ﺍﻟﺤﺎﺠﺔ ﺇﻟﻰ ﺍﻟﺘﻌﺎﻤـل ﻤـﻊ ﺍﻟﻤﻠـ ﹼ‬
‫ﻤﺒﺎﺸﺭﺓﹰ‪ ،‬ﻭﻫﻭ ﻤﺎ ﻴﺠﻌل ﺍﻷﻤﺭ ﺃﻜﺜﺭ ﺴﻬﻭﻟ ﹰﺔ ﻭﺘﻨﻅﻴﻤ‪‬ﺎ ﺒﺎﻟﻨﺴﺒﺔ ﻟﻙ‪.‬‬
‫ﻥ ﺍﺴﺘﺨﺩﺍﻡ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴـﺎﺕ ﻴـﻭﻓﹼﺭ ﻟـﻙ‬
‫ﺹ ﺒﻙ ﺒﺎﻟﻁﺭﻴﻘﺔ ﺍﻟﺘﻲ ﺘﺭﻴﺤﻙ‪ ،‬ﻭﻟﻜ ‪‬‬
‫ﻑ ﺨﺎ ‪‬‬
‫ﻥ ﺒﻴﺎﻨﺎﺘﻙ ﻓﻲ ﻤﻠ ﹼ‬
‫ﻭﻻ ﻤﺎﻨ ‪‬ﻊ ﺃﻥ ﺘﺨ ‪‬ﺯ ‪‬‬
‫ﺕ ﻭﺍﻟﺠﻬﺩ‪.‬‬
‫ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﻟﻭﻗ ِ‬
‫) ﻓﻲ ﺒﺩﺍﻴﺎﺕ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻜﺎﻥ ﻜل ﻤﺒﺭﻤﺞ ﻴﻨﺸﺊ ﻤﻠﻑ ﻤﻌﻁﻴﺎﺕ ﺨﺎﺹ ﺒﻪ ﻭﻴﻘﻭﻡ ﺒﺎﻟﺘﻌﺎﻤل ﻤﻊ ﻫﺫﺍ ﺍﻟﻤﻠﻑ ﺒﺎﻟﻁﺭﻕ‬
‫ﺍﻟﺘﻲ ﺘﺘﻴﺤﻬﺎ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﻟﻠﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻤﻠﻔﺎﺕ ) ﺴﻨﺘﻌﺭﻑ ﻋﻠﻴﻬﺎ ﻻﺤﻘﹰﺎ ( ﻭﻟﻜﻥ ﻤﻊ ﺍﻟﻭﻗﺕ ﺘﻁﻭﺭﺕ ﻗﻭﺍﻋـﺩ ﺍﻟﺒﻴﺎﻨـﺎﺕ‬
‫ﻭﺃﺼﺒﺢ ﺍﻟﻤﺴﺘﺨﺩﻤﻭﻥ ﺒﺤﺎﺠﺔ ﺇﻟﻰ ﻗﻭﺍﻋﺩ ﺒﻴﺎﻨﺎﺕ ﺫﺍﺕ ﺤﺠﻡ ﻜﺒﻴﺭ ﻭ ﺇﻟﻰ ﺍﻟﻘﺩﺭﺓ ﺇﻟﻰ ﺍﻟﺤﺼﻭل ﻋﻠﻰ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﺍﻟﻤﻁﻠﻭﺒـﺔ‬
‫ﺒﺸﻜل ﺴﺭﻴﻊ ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺇﻤﻜﺎﻨﻴﺔ ﺍﻟﺘﺸﺎﺭﻙ ﻋﻠﻰ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﺃﻱ ﺇﻤﻜﺎﻨﻴﺔ ﺇﺩﺨﺎل ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﻭﺍﻟﺤﺼﻭل ﻋﻠﻴﻬﺎ ﻤﻥ ﻤﻠﻑ‬
‫) ﻤﻠﻔﺎﺕ ( ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻤﻥ ﻗﺒل ﻋﺩﺓ ﻤﺴﺘﺨﺩﻤﻴﻥ ﺒﻨﻔﺱ ﺍﻟﻭﻗﺕ‪ ،‬ﺍﻷﻤﺭ ﺍﻟﺫﻱ ﺠﻌل ﻤﻥ ﺍﻟﻤﺴﺘﺤﻴل ﺃﻥ ﻴﻘـﻭﻡ ﻤﺒـﺭﻤﺞ‬
‫ﻋﺎﺩﻱ ﺒﺘﺤﻘﻴﻕ ﻫﺫﻩ ﺍﻟﺸﺭﻭﻁ (‬
‫ﻭﻫﻨﺎﻙ ﺃﻨﻭﺍﻉ ﻜﺜﻴﺭﺓ ﻤﻥ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ‪ ،‬ﺘﺒﻌﺎ ﻟﻠﺸﺭﻜﺔ ﺍﻟﺘﻲ ﺘﻨﺘﺠﻬﺎ ﻭﺍﻟﺒﺭﺍﻤﺞ ﺍﻟﺘﻲ ﺘﻨﺸﺌﻬﺎ‪ ،‬ﻓﻬﻨـﺎﻙ ﻗﻭﺍﻋـﺩ ﺒﻴﺎﻨـﺎﺕ‬
‫ﺒﺭﻨﺎﻤﺞ ‪ Access‬ﻭﺒﺭﻨﺎﻤﺞ ‪ SQL Server‬ﻭﻫﻤﺎ ﻤﻥ ﺇﻨﺘﺎﺝ ﻤﻴﻜﺭﻭﺴﻭﻓﺕ‪ ،‬ﻭﻫﻨﺎﻙ ﻋﺸﺭﺍﺕ ﺍﻟﺒﺭﺍﻤﺞ ﻏﻴﺭﻫﻤﺎ ﻤﻥ ﺇﻨﺘﺎﺝ‬
‫ﺸﺭﻜﺎﺕ ﺃﺨﺭﻯ‪.‬‬
‫ﻭﺘﺴﻤ‪‬ﻰ ﻫﺫﻩ ﺍﻟﺒﺭﺍﻤﺞ "ﺃﻨﻅﻤﺔ ﺇﺩﺍﺭﺓ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ" )‪ ،Database Management Systems (DBMS‬ﻭﻤﻬﻤ‪‬ﺘﻬـﺎ‬
‫ل‬
‫ل ﻁﺭﻴﻘـ ٍﺔ ﻭﺃﻓـﻀ ِ‬
‫ل ﻤﻌﻬﺎ‪ ،‬ﺒﺄﺴـﻬ ِ‬
‫ﺕ ﺍﻟﻼﺯﻤﺔ ﻹﻨﺸﺎ ِﺀ ﻗﻭﺍﻋ ِﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻭﺍﻟﺘﻌﺎﻤ ِ‬
‫ﺍﻷﺴﺎﺴﻴ‪‬ﺔ ﺃﻥ ﺘﻤﻨﺤﻙ ﺍﻟﻭﺴﺎﺌل ﻭﺍﻷﺩﻭﺍ ِ‬
‫ﻑ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ‪.‬‬
‫ﻥ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻟﻤﺨﺯ‪‬ﻨﺔ ﻓﻲ ﻤﻠ ﹼ‬
‫ﺙ ﺘﻘﻭﻡ ﺒﺩﻭﺭ ﺍﻟﻭﺴﻴﻁ ﺒﻴﻨﻙ ﻭﺒﻴ ‪‬‬
‫ﺇﻤﻜﺎﻨﻴ‪‬ﺎﺕ‪ ،‬ﺒﺤﻴ ﹸ‬
‫ل ﻗﻭﺍﻋـﺩ‬
‫ﻥ ﻜـ ّ‬
‫ﻥ ﻨﻭﻉ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻟﺘﻲ ﺘﺘﻌﺎﻤل ﻤﻌﻬﺎ‪ ،‬ﻭﻤﻬﻤﺎ ﻜﺎﻨﺕ ﻁﺭﻴﻘﺔ ﺘﺨﺯﻴﻨﻬﺎ ﻓﻲ ﺍﻟﻤﻠـﻑﹼ‪ ،‬ﻓـﺈ ‪‬‬
‫ﻭﻤﻬﻤﺎ ﻜﺎ ‪‬‬
‫ﺍﻟﻤﻌﻁﻴﺎﺕ ﺘﺘﺒﻊ ﻗﻭﺍﻋ ‪‬ﺩ ﺃﺴﺎﺴﻴ‪‬ﺔ ﻭﺘﺤﻘﹼﻕ ﺸﺭﻭﻁﺎ ﻤﻌﻴ‪‬ﻨﺔ ﻤﺘﻌﺎﺭﻓﺎ ﻋﻠﻴﻬﺎ ﺩﻭﻟﻴ‪‬ﺎ‪ ،‬ﻜﻤﺎ ﺃﻨﹼﻬﺎ ﻜﻠﹼﻬﺎ ﺒﻼ ﺍﺴـﺘﺜﻨﺎﺀ ﺘـﺴﺘﺨﺩﻡ "ﻟﻐـﺔ‬
‫ﺍﻻﺴﺘﻌﻼﻡ ﺍﻟﻤﺭﻜﹼﺒﺔ" )‪ ،Structured Query Language (SQL‬ﻭﻫﻲ ﻟﻐﺔ ﺨﺎﺼ‪‬ـﺔ ﻟﺤﻔـﻅ ﻭﺍﺴـﺘﺭﺠﺎﻉ ﻭﺘﺤـﺩﻴﺙ‬
‫ﺍﻟﻤﻌﻁﻴﺎﺕ ﻓﻲ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ‪.‬‬

‫ﻤﻤﺎ ﺘﺘﺄﻟﻑ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ‪:‬‬

‫ﺍﻟﻌﻨﺼﺭ ﺍﻷﺴﺎﺴﻲ ﻓﻲ ﺃﻱ ﻗﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﻫﻭ ﺍﻟﺠﺩﻭل ﻭﻴﺘﺄﻟﻑ ﺍﻟﺠﺩﻭل ﻤﻥ ﺃﻋﻤﺩﺓ ﻭﺃﺴﻁﺭ ﻴﺩﻋﻰ ﻜل ﺴﻁﺭ ﺴـﺠل ﻭﻜـل‬
‫ﻋﻤﻭﺩ ﺒﺤﻘل ﻭﺒﺎﻟﺘﺎﻟﻲ ﻓﺈﻥ ﺍﻟﺴﺠل ﻤﻜﻭﻥ ﻤﻥ ﻋﺩﺓ ﺤﻘﻭل‪ ،‬ﻟﻨﻔﺭﺽ ﺃﻨﻪ ﻟﺩﻴﻙ ﻗﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﻟﻤﻜﺘﺒﺔ ﻓﺴﻴﻜﻭﻥ ﻟﺩﻴﻙ ﺍﻟﺠـﺩﻭل‬
‫ﺍﻟﺘﺎﻟﻲ ‪:‬‬

‫‪69‬‬
 ‫ﺃﲰﺎﺀ ﺍﻷﻋﻤﺪﺓ ) ﺃﲰﺎﺀ ﺍﳊﻘﻮﻝ (‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬

‫ﺩﺍﺭ ﺍﻟﻨﺸﺭ‬ ‫ﺘﺎﺭﻴﺦ‬ ‫ﺍﺴﻡ ﺍﻟﻤﺅﻟﻑ‬ ‫ﺍﺴﻡ ﺍﻟﻜﺘﺎﺏ‬ ‫ﺭﻗﻡ ﺍﻟﻜﺘﺎﺏ‬

‫ﺍﳊﻘﻞ ﺍﳊﺎﱄ‬ ‫ﺍﻟﺴﺠﻞ ﺍﳊﺎﱄ‬
‫ﺍﻹﺼﺩﺍﺭ‬
‫ﺩﺍﺭ ﺸﻌﺎﻉ‬ ‫‪1997/1/2‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠـﺔ ﻴﺎﺴﺭ ﻋﻘﺎﺩ‬ ‫‪1255‬‬
‫ﺩﻟﻔﻲ‬
‫ﻜﺘـــــﺎﺏ‬ ‫ﻤﺤﻤﺩ ﺤﻤﺩﻱ ‪2002/2/9‬‬ ‫‪VB.Net‬‬ ‫‪1256‬‬
‫ﺳﺠﻼﺕ‬
‫ﺇﻟﻜﺘﺭﻭﻨﻲ‬ ‫ﻏﺎﻨﻡ‬
‫ﻤﺼﺭ‬ ‫‪1944/3/3‬‬ ‫ﺘﻭﻓﻴﻕ ﺍﻟﺤﻜﻴﻡ‬ ‫ﺸﺠﺭﺓ ﺍﻟﺤﻜﻡ‬ ‫‪1257‬‬
‫ﻤﺼﺭ‬ ‫‪2000/4/2‬‬ ‫ﺍﻷﻴـــــﺩﻱ ﺘﻭﻓﻴﻕ ﺍﻟﺤﻜﻴﻡ‬ ‫‪1258‬‬
‫ﺍﻟﻨﺎﻋﻤﺔ‬
‫ﻤﺼﺭ‬ ‫‪1990/3/12‬‬ ‫ﺘﻭﻓﻴﻕ ﺍﻟﺤﻜﻴﻡ‬ ‫ﺸﻬﺭﺯﺍﺩ‬
‫ﻤﻼﺤﻅﺔ ‪ ) :‬ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﻓﻲ ﻫﺫﺍ ﺍﻟﺠﺩﻭل ﻏﻴﺭ ﺩﻗﻴﻘﺔ (‪.‬‬

‫ﺍﻟﺴﺠل ﺍﻟﺤﺎﻟﻲ ‪ :‬ﻫﻭ ﺍﻟﺴﺠل ﺍﻟﺫﻱ ﻴﻘﻑ ﻤﺅﺸﺭ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻋﻨﺩﻩ ﻭﺍﻟﺤﻘل ﺍﻟﺤﺎﻟﻲ ﻫﻭ ﺘﻘﺎﻁﻊ ﺍﻟـﺴﺠل ﺍﻟﺤـﺎﻟﻲ ﻤـﻊ‬
‫ﺍﻟﻌﺎﻤﻭﺩ ﺍﻟﺤﺎﻟﻲ ﺤﻴﺙ ﻴﻤﻜﻨﻙ ﺩﺍﺌﻤﹰﺎ ﺘﺤﺭﻴﺭ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻋﻨﺩ ﺍﻟﺴﺠل ﺍﻟﺤﺎﻟﻲ ﻭﻓﻲ ﺍﻟﺤﻘل ﺍﻟﺤﺎﻟﻲ ) ﺴﻨﺘﺂﻟﻑ ﻤـﻊ ﻫـﺫﻩ‬
‫ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﻻﺤﻘﹰﺎ (‪.‬‬
‫ﻴﻤﻜﻥ ﺃﻥ ﺘﺘﻜﻭﻥ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻤﻥ ﻋﺩﺓ ﺠﺩﺍﻭل ﻭﻫﺫﻩ ﺍﻟﺠﺩﺍﻭل ﻗﺩ ﺘﻜﻭﻥ ﻤﺨﺯﻨﺔ ﻓﻲ ﻤﻠﻑ ﻭﺍﺤـﺩ ) ﻗﺎﻋـﺩﺓ ﺒﻴﺎﻨـﺎﺕ‬
‫ﻼ ( ﺃﻭ ﺃﻥ ﻴﻜﻭﻥ ﻜل ﺠﺩﻭل ﻓﻲ ﻤﻠﻑ ﻋﻠﻰ ﺤﺩﺓ ﻜﻤﺎ ﻓﻲ ﻗﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﺒﺎﺭﺍﺩﻭﻜﺱ ‪.‬‬
‫ﺃﻜﺴﻴﺱ ﻤﺜ ﹰ‬
‫ﻼ ﺍﻟﺤﻘل ﺭﻗﻡ ﺍﻟﻜﺘﺎﺏ ﻤـﻥ ﺍﻟﻨـﻭﻉ‬
‫ﻴﻌﺭﻑ ﻜل ﺤﻘل ) ﻋﻤﻭﺩ ( ﻓﻲ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻨﻭﻉ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻟﺘﻲ ﺴﻴﺤﻭﻴﻬﺎ ﻓﻤﺜ ﹰ‬
‫‪ Integer‬ﺃﻭ ‪ LongInt‬ﺤﺴﺏ ﺤﺠﻡ ﺍﻟﻤﻜﺘﺒﺔ ﺒﻴﻨﻤﺎ ﺃﺴﻡ ﺍﻟﻜﺘﺎﺏ ﻭ ﺍﺴﻡ ﺍﻟﻤﺅﻟﻑ ﻭﺩﺍﺭ ﺍﻟﻨﺸﺭ ﺘﻜﻭﻥ ﻤـﻥ ﺍﻟﻨـﻭﻉ ﻨـﺹ‬
‫ﻭﺘﺎﺭﻴﺦ ﺍﻹﺼﺩﺍﺭ ﻤﻥ ﺍﻟﻨﻭﻉ ‪. Date‬‬
‫ﻼ ﺃﺴـﻡ‬
‫ﻭﺃﻜﺜﺭ ﻤﻥ ﺫﻟﻙ ﻋﻨﺩﻤﺎ ﻨﻌﺭﻑ ﺍﻟﺤﻘل ﻤﻥ ﻨﻭﻉ ﻨﺹ ﻋﻠﻴﻨﺎ ﺘﺤﺩﻴﺩ ﻋﺩﺩ ﺍﻷﺤﺭﻑ ﺍﻟﺘﻲ ﺴﻴﺤﻭﻴﻬﺎ ﻫﺫﺍ ﺍﻟـﻨﺹ ﻤـﺜ ﹰ‬
‫ﺍﻟﻜﺘﺎﺏ ﻋﺸﺭﻴﻥ ﺤﺭﻑ ﻋﻠﻤﹰﺎ ﺃﻨﻪ ﻻ ﻴﺴﻤﺢ ﺒﻜﺘﺎﺒﺔ ﺃﻜﺜﺭ ﻤﻥ ﺍﻟﺤﺩ ﺍﻟﻤﻌﻁﻰ ‪ ،‬ﻜﻤﺎ ﺃﻥ ﺤﺠﻡ ﺍﻟﺤﻘل ﺴﻴﻜﻭﻥ ﺒﺤﺠﻡ ﺍﻟـﻨﺹ )‬
‫ﻋﺸﺭﻴﻥ ﺒﺎﻴﺕ ( ﺴﻭﺍﺀ ﺃﻜﺎﻥ ﺃﺴﻡ ﺍﻟﻜﺘﺎﺏ ﻤﻥ ﻋﺸﺭﻴﻥ ﺤﺭﻑ ﺃﻭ ﺃﻗل ‪ ) ،‬ﺴﻨﺘﻌﺭﻑ ﻻﺤﻘﹰﺎ ﻋﻠﻰ ﺃﻨﻭﺍﻉ ﺍﻟﺤﻘﻭل ﻓﻲ ﻗﻭﺍﻋـﺩ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ ،‬ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﻲ ﺘﺄﺨﺫ ﺤﻘﻭل ﻤﺘﻐﻴﺭﺓ ( ‪.‬‬
‫ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻟﻌﻼﺌﻘﻴﺔ ‪:‬‬
‫ﺏ ﻟـﻨﻔﺱ‬
‫ﻥ ﺃﻥ ﻴﺤﺘﻭﻯ ﺍﻟﺠﺩﻭل ﻋﻠﻰ ﺃﻜﺜﺭ ﻤﻥ ﻜﺘﺎ ٍ‬
‫ﻓﻲ ﺍﻟﺠﺩﻭل ﺍﻟﺴﺎﺒﻕ ﻭﻀﻌﻨﺎ ﺃﺴﻡ ﺍﻟﻤﺅﻟﻑ ﻀﻤﻥ ﺍﻟﺠﺩﻭل ‪ ،‬ﻭﻤﻥ ﺍﻟﻤﻤﻜ ِ‬
‫ﺍﻟﻤﺅﻟﹼﻑ‪ ..‬ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ ﺴﻴﺘ ‪‬ﻡ ﺘﻜﺭﺍﺭ ﺍﺴﻡ ﺍﻟﻤﺅﻟﹼﻑ ﺃﻜﺜﺭ ﻤﻥ ﻤﺭ‪‬ﺓ‪ ،‬ﻤﻤ‪‬ﺎ ﺴﻴﻌﻤل ﻋﻠﻰ ﺯﻴﺎﺩﺓ ﺤﺠـﻡ ﻗﺎﻋـﺩﺓ ﺍﻟﻤﻌﻁﻴـﺎﺕ‪،‬‬
‫ﻭﺇﺒﻁﺎﺀ ﻋﻤﻠﻴ‪‬ﺎﺕ ﺍﻟﺒﺤﺙ‪ ..‬ﺇﺫﻥ ﻤﺎ ﺍﻟﺤلّ؟‬
‫ل ﻟﻠﻤﺅﻟﹼﻔﻴﻥ‪ ،‬ﻫﺫﺍ ﺍﻟﺠﺩﻭل ﻴﺤﺘﻭﻱ ﻋﻠﻰ ﺭﻗﻡ ﻤﺴﻠﺴل ‪ ID‬ﻟﻜ ّ‬
‫ل ﻤﺅﻟﹼﻑ‪ ..‬ﻭﻓﻲ ﺠﺩﻭل ﺍﻟﻜﺘﺏ ﻨﻨﺸﺊ‬ ‫ل ﻫﻭ ﺘﺨﺼﻴﺹ ﺠﺩﻭ ٍ‬
‫ﺍﻟﺤ ّ‬
‫ﻥ ﺨﺎﻨﺔ ﺭﻗﻡ‬
‫ﻋﻤﻭﺩﺍ ﻨﻀﻊ ﻓﻴﻪ ﺭﻗﻡ ﻤﺅﻟﹼﻑ ﺍﻟﻜﺘﺎﺏ‪ ..‬ﻓﻤﺜﻼ ﻟﻭ ﻜﺎﻥ ﺭﻗﻡ )ﺘﻭﻓﻴﻕ ﺍﻟﺤﻜﻴﻡ( ﻓﻲ ﺠﺩﻭل ﺍﻟﻤﺅﻟﹼﻔﻴﻥ ﻫﻭ ‪ ،100‬ﻓﺈ ‪‬‬

‫‪70‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ل ﻤﻥ ﺍﻟﻜﺘﺏ ﺍﻟﺘﺎﻟﻴﺔ "ﺸﻬﺭﺯﺍﺩ" ﻭ"ﺍﻷﻴـﺩﻱ ﺍﻟﻨﺎﻋﻤـﺔ" ﻭ"ﺃﺭﻨـﻲ ﺍﷲ"‬
‫ﺍﻟﻤﺅﻟﹼﻑ ﻓﻲ ﺠﺩﻭل ﺍﻟﻌﻨﺎﻭﻴﻥ ﻻ ﺒ ‪‬ﺩ ﺃﻥ ﺘﻜﻭﻥ ‪ 100‬ﻟﻜ ّ‬
‫ﻭ"ﺸﺠﺭﺓ ﺍﻟﺤﻜﻡ" ﻭﺴﻴﺼﺒﺢ ﻟﻴﻨﺎ ﺠﺩﻭﻟﻴﻥ ﺒﺎﻟﺸﻜل ‪:‬‬
‫ﺩﺍﺭ ﺍﻟﻨﺸﺭ‬ ‫ﺘﺎﺭﻴﺦ‬ ‫ﺍﺴﻡ ﺍﻟﻤﺅﻟﻑ‬ ‫ﺍﺴﻡ ﺍﻟﻜﺘﺎﺏ‬ ‫ﺭﻗﻡ ﺍﻟﻜﺘﺎﺏ‬
‫ﺍﻹﺼﺩﺍﺭ‬
‫ﺩﺍﺭ ﺸﻌﺎﻉ‬ ‫‪1997/1/2‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠـﺔ ‪50‬‬ ‫‪1255‬‬
‫ﺩﻟﻔﻲ‬
‫ﻜﺘـــــﺎﺏ‬ ‫‪2002/2/9‬‬ ‫‪56‬‬ ‫‪VB.Net‬‬ ‫‪1256‬‬
‫ﺇﻟﻜﺘﺭﻭﻨﻲ‬
‫ﻤﺼﺭ‬ ‫‪1944/3/3‬‬ ‫‪100‬‬ ‫ﺸﺠﺭﺓ ﺍﻟﺤﻜﻡ‬ ‫‪1257‬‬
‫ﻤﺼﺭ‬ ‫‪2000/4/2‬‬ ‫ﺍﻷﻴﺩﻱ ﺍﻟﻨﺎﻋﻤﺔ ‪100‬‬ ‫‪1258‬‬
‫ﻤﺼﺭ‬ ‫‪1990/3/12‬‬ ‫‪100‬‬ ‫ﺸﻬﺭﺯﺍﺩ‬
‫ﺠﺩﻭل ﺍﻟﻜﺘﺏ‬
‫ﺃﺴﻡ ﺍﻟﻤﺅﻟﻑ‬ ‫ﺭﻗﻡ ﺍﻟﻤﺅﻟﻑ‬
‫ﻴﺎﺴﺭ ﻋﻘﺎﺩ‬ ‫‪50‬‬
‫ﻤﺤﻤﺩ ﺤﻤﺩﻱ ﻏﺎﻨﻡ‬ ‫‪56‬‬
‫ﺘﻭﻓﻴﻕ ﺍﻟﺤﻜﻴﻡ‬ ‫‪100‬‬
‫ﺴﻌﻴﺩ ﺍﻟﺼﺎﻓﻲ‬ ‫‪114‬‬

‫ﺹ ﻴﺨﺯ‪‬ﻥ ﻓﻲ ﺒﺎﻴﺕ ‪ ،Byte‬ﻤﻤ‪‬ﺎ ﻴﻌﻨﻲ‬

‫ل ﺤﺭﻑ ﻓﻲ ﺍﻟﻨ ‪‬‬
‫ﻥﻜّ‬
‫ﻭﻟﻜﻲ ﺘﺴﺘﻭﻋﺏ ﻤﻘﺩﺍﺭ ﺍﻟﺘﻭﻓﻴﺭ ﻓﻲ ﺍﻟﺤﺠﻡ‪ ،‬ﻴﺠﺏ ﺃﻥ ﺘﻌﺭﻑ ﺃ ‪‬‬
‫ﺝ ﺇﻟﻰ ‪ 12‬ﺒﺎﻴﺕ ‪ ،‬ﻭﺘﻜﺭﺍﺭﻩ ﺃﺭﺒﻊ ﻤﺭ‪‬ﺍﺕ ﻴﻌﻨﻲ ﺃﻨﹼﻪ ﻴﺤﺘﺎﺝ ﺇﻟﻰ ‪ 48‬ﺒﺎﻴﺕ !‪ ..‬ﺒﻴﻨﻤﺎ ﺘﺨﺯﻴﻥ‬
‫ﺹ "ﺘﻭﻓﻴﻕ ﺍﻟﺤﻜﻴﻡ" ﻴﺤﺘﺎ ‪‬‬
‫ﺃﻥ ﺍﻟﻨ ‪‬‬
‫ﻥ ﺘﺨﺯﻴﻥ ﺭﻗﻡ ‪ 100‬ﺃﺭﺒﻊ ﻤﺭ‪‬ﺍﺕ ﻴﺤﺘﺎﺝ ﺇﻟﻰ ‪ 8‬ﺒﻴﺘﺎﺕ‬
‫ﺭﻗﻡ ﻴﺼل ﺇﻟﻰ ‪ 32000‬ﻟﻥ ﻴﺤﺘﺎﺝ ﺇﻻ ﺇﻟﻰ ﺒﺎﻴﺘﻴﻥ ﻓﻘﻁ‪ ،‬ﻤﻤ‪‬ﺎ ﻴﻌﻨﻲ ﺃ ‪‬‬
‫ﻓﻘﻁ‪ ..‬ﻁﺒﻌﺎ ﺍﻟﻔﺭﻕ ﻭﺍﻀﺢ‪.‬‬
‫ﻥ ﺇﻨﺸﺎﺀ ﻋﻤﻭﺩ ﻴﺤﺘﻭﻱ ﻋﻠﻰ ﺃﺴﻤﺎﺀ ﺍﻟﻤﺅﻟﹼﻔﻴﻥ ﻴﻘﺘﻀﻲ ﺘﺼﻤﻴﻤﻪ ﻟﻴﺴﺘﻭﻋﺏ ﺃﻁﻭل ﺍﺴـﻡ‬
‫ﺕ ﺍﻷﻤﺭ ﻴﻘﺘﺼﺭ ﻋﻠﻰ ﻫﺫﺍ‪ ..‬ﺇ ‪‬‬
‫ﻭﻟﻴ ﹶ‬
‫ﻥ ﺃﻁﻭل ﺍﺴﻡ ﻟﻤﺅﻟﹼﻑ ﻫﻭ ‪ 20‬ﺤﺭﻓﺎ‪ ،‬ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ ﻟﻭ ﻜﺎﻥ ﺠﺩﻭل ﺍﻟﻜﺘﺏ ﻴﺤﺘﻭﻱ ﻋﻠﻰ ‪30‬‬
‫ﻤﻥ ﻫﺫﻩ ﺍﻷﺴﻤﺎﺀ‪ ..‬ﺍﻓﺘﺭﺽ ﺃ ‪‬‬
‫ﻥ ﻴﺤﺘﺎﺝ ﺇﻟﻰ ‪ 600 = 20 × 30000‬ﺃﻟﻑ ﺒﺎﻴﺕ ‪ ،‬ﺃﻱ ‪ 600‬ﻜﻴﻠـﻭ‬
‫ﻥ ﻫﺫﺍ ﻤﻌﻨﺎﻩ ﺃﻥ ﻋﻤﻭﺩ ﺃﺴﻤﺎﺀ ﺍﻟﻤﺅّﻟﻔﻴ ‪‬‬
‫ﺃﻟﻑ ﻜﺘﺎﺏ‪ ،‬ﻓﺈ ‪‬‬
‫ﺒﺎﻴﺕ!‬
‫ﺒﻴﻨﻤﺎ ﻟﻭ ﺍﺴﺘﻌﻀﻨﺎ ﻋﻥ ﺫﻟﻙ ﺒﻌﻤﻭﺩ ﺃﺭﻗﺎﻡ ﺍﻟﻤﺅﻟﹼﻔﻴﻥ‪ ،‬ﻓﺈﻨﹼﻪ ﺴﻴﺤﺘﺎﺝ ﺇﻟﻰ ‪ 60‬ﺃﻟﻑ ﻭﺤﺩﺓ‪ ،‬ﺃﻱ ‪ 60‬ﻜﻴﻠﻭ ﺒﺎﻴﺕ ﻓﻘﻁ‪.‬‬
‫ل ﺍﻷﺤﻭﺍل ﺴﻨﻨﺸﺊ ﻋﻤﻭﺩﺍ ﻷﺴﻤﺎﺀ ﺍﻟﻤﺅﻟﹼﻔﻴﻥ ﺒﺎﻹﻀﺎﻓﺔ ﻟﻌﻤﻭﺩ ﺭﻗﻡ ﺍﻟﻤﺅﻟﹼـﻑ ﻓـﻲ ﺠـﺩﻭل‬
‫ﻁﺒﻌﺎ ﺴﺘﺘﺴﺎﺀل‪ :‬ﻭﻟﻜﻨﹼﻨﺎ ﻓﻲ ﻜ ّ‬
‫ل ﻤﺅﻟﹼﻑ ﻟﻪ ﻋﺸﺭ ﻜﺘﺏ(‪ ،‬ﻭﻫﻭ ﻤـﺎ‬
‫ﻥﻜّ‬
‫ﻥ ﻋﺩﺩ ﺍﻟﻤﺅّﻟﻔﻴﻥ ﻗﺩ ﻻ ﻴﺯﻴﺩ ﻋﻥ ‪ 3‬ﺁﻻﻑ ﻤﺅﻟﹼﻑ )ﺒﺎﻋﺘﺒﺎﺭ ﺃ ‪‬‬
‫ﺍﻟﻤﺅﻟﹼﻔﻴﻥ‪ ..‬ﻨﻌﻡ‪ ،‬ﻭﻟﻜ ‪‬‬
‫ﺴﻴﺤﺘﺎﺝ ﺇﻟﻰ ‪ 66 = (2 + 20) × 3000‬ﻜﻴﻠﻭ ﺒﺎﻴﺕ‪.‬‬
‫ﻲ ﻟﻤﺴﺎﺤﺔ ﺍﻟﺘﺨﺯﻴﻥ ﻓﻲ ﺤﺎﻟﺔ ﺘﻘﺴﻴﻡ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﻋﻠﻰ ﺠﺩﻭﻟﻴﻥ = ‪ 126 = 66 + 60‬ﻜﻴﻠﻭ ﺒﺎﻴﺕ‪،‬‬
‫ﻥ ﺍﻟﻤﺠﻤﻭﻉ ﺍﻟﻜﹼﻠ ‪‬‬
‫ﺇﺫﻥ ﻓﺈ ‪‬‬
‫ﺃﻱ ﺤﻭﺍﻟﻲ ﺨﻤﺱ ﺍﻟﻤﺴﺎﺤﺔ ﺍﻟﻤﺴﺘﻬﻠﻜﺔ ﻋﻨﺩ ﻭﻀﻊ ﺃﺴﻤﺎﺀ ﺍﻟﻤﺅﻟﹼﻔﻴﻥ ﻓﻲ ﻨﻔﺱ ﺠﺩﻭل ﺍﻟﻜﺘﺏ!‬
‫‪71‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻥ ﺃﺴﺭﻉ ﺒﻜﺜﻴﺭ ﻋﻨﺩ ﺍﻟﺒﺤﺙ ﻋﻥ ﺭﻗﻡ ‪ 100‬ﻋﻨﻪ ﻋﻨﺩ ﺍﻟﺒﺤﺙ ﻋﻥ‬
‫ﻫﺫﺍ ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺴﺭﻋﺔ ﻋﻤﻠﻴ‪‬ﺔ ﺍﻟﺒﺤﺙ‪ ،‬ﻓﺎﻟﻜﻤﺒﻴﻭﺘﺭ ﻴﻜﻭ ‪‬‬
‫ﺹ "ﺘﻭﻓﻴﻕ ﺍﻟﺤﻜﻴﻡ"‪.‬‬
‫ﺍﻟﻨ ‪‬‬
‫ﻥ ﺍﻟﺫﻱ ﻴﺩﺨل ﺃﺴﻤﺎﺀ ﺍﻟﻤﺅﻟﹼﻔﻴﻥ ﺃﺨﻁﺄ ﻭﻜﺘﺏ ﺍﺴﻡ )ﺘﻭﻓﻴﻕ ﺍﻟﺤﻜﻴﻡ( ﻜﺎﻟﺘﺎﻟﻲ‪" :‬ﺘﻔﻴﻕ ﺍﻟﺤﻜـﻴﻡ"‪..‬‬
‫ﻟﻴﺱ ﻫﺫﺍ ﻓﺤﺴﺏ‪ ..‬ﺍﻓﺘﺭﺽ ﺃ ‪‬‬
‫ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ ﻤﺎ ﻋﻠﻴﻪ ﺇﻻ ﺃﻥ ﻴﻌﺩ‪‬ل ﺍﻟﺨﻁﺄ ﻤﺭ‪‬ﺓ ﻭﺍﺤﺩﺓ ﻓﻲ ﺠﺩﻭل ﺍﻟﻤﺅﻟﹼﻔﻴﻥ‪ ..‬ﺃﻤ‪‬ﺎ ﻟﻭ ﻜﺎﻨﺕ ﺃﺴﻤﺎﺀ ﺍﻟﻤﺅﻟﹼﻔﻴﻥ ﻓـﻲ ﻨﻔـﺱ‬
‫ﻥ ﺘﻜﺭﺍﺭ ﻜﺘﺎﺒﺔ ﺍﺴﻡ ﺍﻟﻤﺅﻟﹼﻑ ﻴﺠﻌل ﺍﺤﺘﻤﺎﻻﺕ ﺍﻟﺨﻁﺈ ﺃﻜﺒﺭ‪ ،‬ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺘﻀﻴﻴﻊ ﺍﻟﻭﻗﺕ ﻭﺍﻟﺠﻬـﺩ ﻓـﻲ‬
‫ﺠﺩﻭل ﺍﻟﻜﺘﺏ‪ ،‬ﻓﺈ ‪‬‬
‫ﻜﺘﺎﺒﺘﻬﺎ‪ ،‬ﻭﺼﻌﻭﺒﺔ ﺘﻌﺩﻴﻠﻬﺎ ﻜﻠﹼﻬﺎ!‬
‫ﻁﺒﻌﺎ ﻨﻔﺱ ﻫﺫﺍ ﺍﻟﻜﻼﻡ ﻴﻨﻁﺒﻕ ﻋﻠﻰ ﺠﺩﻭل ﺩﺍﺭ ﺍﻟﻨﺸﺭ‪.‬‬
‫ﻗﺎﻋﺩﺓ ﻫﺎﻤّﺔ‪:‬‬
‫ﺼ ﹰﺔ ﺇﺫﺍ ﻜﺎﻨﺕ ﻫﺫﻩ ﺍﻟﻤﻌﻁﻴﺎﺕ‬
‫ﻜﻠﹼﻤﺎ ﻜﺎﻥ ﻤﻤﻜﻨﺎ‪ ،‬ﻗﻡ ﺒﺘﻘﺴﻴﻡ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻟﺘﻲ ﺘﺘﻜﺭ‪‬ﺭ ﺃﻜﺜﺭ ﻤﻥ ﻤﺭ‪‬ﺓ ﻋﻠﻰ ﺃﻜﺜﺭ ﻤﻥ ﺠﺩﻭل‪ ،‬ﺨﺎ ‪‬‬
‫ﻥ ﻫﺫﻩ ﺍﻟﻌﻤﻠﻴ‪‬ﺔ ﺘﺴﻤ‪‬ﻰ ﺍﻟﺘﻁﺒﻴﻊ ‪ ،Normalization‬ﻭﻟﻬﺎ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﻟﻘﻭﺍﻋﺩ‪ ،‬ﻭﺇﻥ ﻜﺎﻥ‬
‫ﺘﺴﺘﻬﻠﻙ ﻤﺴﺎﺤﺔ ﺘﺨﺯﻴﻥ ﻜﺒﻴﺭﺓ‪ ..‬ﺇ ‪‬‬
‫ﻤﻥ ﺍﻟﻤﻤﻜﻥ ﺍﺴﺘﻨﺘﺎﺠﻬﺎ ﻤﻨﻁﻘﻴ‪‬ﺎ ) ﺘﺩﺭﺱ ﻓﻲ ﻗﺴﻡ ﺍﻟﻤﺎﺩﺓ ﺍﻟﻨﻅﺭﻱ ( ‪.‬‬
‫ﺘﺴﻤﻰ ﻫﺫﻩ ﺍﻟﻘﻭﺍﻋﺩ ﺍﻟﺘﻲ ﺘﻌﺘﻤﺩ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﺴﺎﺒﻘﺔ ﺒﻘﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴـﺎﺕ ﺍﻟﻌﻼﺌﻘﻴـﺔ ﺃﻭ ﺒﻘﻭﺍﻋـﺩ ﺍﻟﻤﻌﻁﻴـﺎﺕ ﺍﻟﻤﺘﺭﺍﺒﻁـﺔ‬
‫‪:Relational Databases‬‬
‫ﺤﻴﺙ ﻗﺎﻤﺕ ﻫﻨﺎ ﻋﻼﻗﺔ ﺒﻴﻥ ﺠﺩﻭﻟﻴﻥ ﻭﺴﻴﻌﺘﻤﺩ ﺍﺤﺩﻫﻤﺎ ﻋﻠﻰ ﺍﻵﺨﺭ ﻓﻲ ﺍﻟﺤﺼﻭل ﻋﻠﻰ ﻤﻌﻠﻭﻤﺎﺘﻪ ‪.‬‬
‫ﻥ ﺍﻟﺭﺍﺒﻁ ﺒﻴﻨﻬﻤـﺎ ﻫـﻭ‬
‫ﻥ ﻫﻨﺎﻙ ﻋﻼﻗ ﹰﺔ ‪ Relationship‬ﺒﻴﻥ ﺠﺩﻭﻟﻲ ﺍﻟﻜﺘﺏ ﻭﺍﻟﻤﺅﻟﹼﻔﻴﻥ‪ ،‬ﺤﻴﺙ ﺇ ‪‬‬
‫ﺭﺃﻴﻨﺎ ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﺃ ‪‬‬
‫ﺤﻘل ﺭﻗﻡ ﺍﻟﻤﺅﻟﹼﻑ‪ ..‬ﻭﻫﻨﺎ ﻴﺠﺏ ﺃﻥ ﺘﻌﺭﻑ ﻫﺫﻩ ﺍﻟﻤﺼﻁﻠﺤﺎﺕ‪:‬‬
‫‪ -‬ﻴﺴﻤ‪‬ﻰ ﺍﻟﺤﻘل ﺍﻟﻤﺸﺘﺭﻙ ﻓﻲ ﻜﻼ ﺍﻟﺠﺩﻭﻟﻴﻥ "ﺤﻘل ﻤﻔﺘﺎﺤﻲ" ‪.Key field‬‬
‫ﻲ" ‪ ،Primary Key‬ﻭﺫﻟـﻙ ﻷﻨﹼـﻪ ﻤﺘﻔـﺭ‪‬ﺩ‬
‫‪ -‬ﻴﺴﻤ‪‬ﻰ ﺤﻘل ﺭﻗﻡ ﺍﻟﻤﺅﻟﹼﻑ ﻓﻲ ﺠﺩﻭل ﺍﻟﻤﺅﻟﹼﻔﻴﻥ ﺒﺎﺴﻡ "ﺍﻟﻤﻔﺘﺎﺡ ﺍﻷﺴﺎﺴ ‪‬‬
‫ﻲ ﻭﺍﺤﺩ‪.‬‬
‫‪ Unique‬ﻏﻴﺭ ﻗﺎﺒل ﻟﻠﺘﻜﺭﺍﺭ‪ ..‬ﻭﻻ ﻴﺤﺘﻭﻱ ﺍﻟﺠﺩﻭل ﻋﻠﻰ ﺃﻜﺜﺭ ﻤﻥ ﻤﻔﺘﺎﺡ ﺃﺴﺎﺴ ‪‬‬
‫‪ -‬ﻴﺴﻤ‪‬ﻰ ﺤﻘل ﺭﻗﻡ ﺍﻟﻤﺅﻟﹼﻑ ﻓﻲ ﺠﺩﻭل ﺍﻟﻜﺘﺏ ﺒﺎﺴﻡ "ﺍﻟﻤﻔﺘﺎﺡ ﺍﻟﻔﺭﻋ ‪‬‬
‫ﻲ" ‪ ،Foreign Key‬ﻷﻨﹼﻪ ﻤﻭﻀﻭﻉ ﻓـﻲ ﻫـﺫﺍ‬
‫ﺍﻟﺠﺩﻭل ﻟﻴﺭﺒﻁﻪ ﺒﺠﺩﻭل ﺁﺨﺭ‪ ..‬ﻭﻁﺒﻌﺎ ﻴﻤﻜﻥ ﺃﻥ ﺘﺘﻜﺭ‪‬ﺭ ﻗﻴﻤﺔ ﻫﺫﺍ ﺍﻟﻌﻤﻭﺩ ﺒﺩﻭﻥ ﺃﺩﻨﻰ ﻤﺸﻜﻠﺔ‪ ..‬ﻭﻴﻤﻜﻥ ﺃﻥ ﻴﺤﺘﻭﻯ‬
‫ﺍﻟﺠﺩﻭل ﻋﻠﻰ ﺃﻜﺜﺭ ﻤﻥ ﻤﻔﺘﺎﺡ ﻓﺭﻋﻲ ﻴﺭﺒﻁﻪ ﺒﻌﺩﺩ ﻤﻥ ﺍﻟﺠﺩﺍﻭل ﺍﻷﺨﺭﻯ‪.‬‬
‫ﻲ" ‪ ،Master‬ﻭﺠﺩﻭل ﺃﺴﻤﺎﺀ ﺍﻟﻜﺘﺏ ﺒﺎﺴـﻡ "ﺠـﺩﻭل ﺍﻟﺘﻔﺎﺼـﻴل"‬
‫‪ -‬ﻴﺴﻤ‪‬ﻰ ﺠﺩﻭل ﺍﻟﻤﺅّﻟﻔﻴﻥ ﺒﺎﺴﻡ "ﺍﻟﺠﺩﻭل ﺍﻟﺭﺌﻴﺴ ‪‬‬
‫ل ﻤﺅﻟﹼﻑ‪.‬‬
‫‪ ،Detail‬ﺤﻴﺙ ﻴﻤﻜﻨﻙ ﺃﻥ ﺘﺤﺼل ﻤﻨﻪ ﻋﻠﻰ ﻤﻌﻠﻭﻤﺎﺕ ﻋﻥ ﺍﻟﻜﺘﺏ ﺍﻟﻤﺘﻭﺍﻓﺭﺓ ﻟﻜ ّ‬
‫‪ -‬ﺘﺴﻤ‪‬ﻰ ﻋﻤﻠﻴ‪‬ﺔ ﻤﻁﺎﺒﻘﺔ ﺍﻟﺼﻔﻭﻑ ﺒﻴﻥ ﺍﻟﺠﺩﻭﻟﻴﻥ ﺍﻟﻤﺘﺭﺍﺒﻁﻴﻥ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﺤﻘل ﺍﻟﻤﻔﺘﺎﺤﻲ‪ ،‬ﻋﻤﻠﻴﺔ "ﺭﺒـﻁ" ‪..Join‬‬
‫ل ﺍﻟﻜﺘﺏ ﺍﻟﺘﻲ ﻜﺘﺒﻬﺎ ﻨﻔﺱ ﺍﻟﻤﺅﻟﹼﻑ‪.‬‬
‫ﻤﺜل ﺃﻥ ﺘﺤﺎﻭل ﻤﻌﺭﻓﺔ ﺍﺴﻡ ﻤﺅﻟﹼﻑ ﻜﺘﺎﺏ ﻤﻌﻴ‪‬ﻥ‪ ،‬ﺃﻭ ﺃﻥ ﺘﺤﺎﻭل ﺃﻥ ﺘﻌﺭﻑ ﻜ ّ‬
‫ﻥ ﻤﺅﹼﻟﻔﹰﺎ ﻭﺍﺤﺩﺍ‬
‫‪ -‬ﺘﺴﻤ‪‬ﻰ ﺍﻟﻌ‪‬ﻼﻗﺔ ﺒﻴﻥ ﺍﻟﺠﺩﻭﻟﻴﻥ ﻋﻼﻗﺔ "ﻭﺍﺤﺩ ﺒﻤﺘﻌﺩ‪‬ﺩ" ‪ ،One-to-many Relationship‬ﻭﺫﻟﻙ ﻷ ‪‬‬
‫ﻴﻤﻜﻥ ﺃﻥ ﻴﻜﻭﻥ ﻟﻪ ﺃﻜﺜﺭ ﻤﻥ ﻜﺘﺎﺏ‪.‬‬
‫‪ -‬ﻴﻤﻜﻥ ﺃﻥ ﺘﻭﺠﺩ ﻋﻼﻗﺔ "ﻤﺘﻌﺩ‪‬ﺩ ﺒﻤﺘﻌﺩ‪‬ﺩ" ‪ ،Many-to-many Relationship‬ﻭﺫﻟﻙ ﻟﻭ ﻜﺎﻥ ﻟﺩﻴﻨﺎ ﻜﺘﺏ ﺍﺸـﺘﺭﻙ‬
‫ﻓﻲ ﺘﺄﻟﻴﻔﻬﺎ ﺃﻜﺜﺭ ﻤﻥ ﻤﺅﻟﹼﻑ‪ ..‬ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ ﺴﻴﻜﻭﻥ ﻟﺩﻴﻨﺎ ﺠﺩﻭل ﺜﺎﻟﺙ ﻫﻭ ﺠﺩﻭل "ﻤﺅﻟﹼﻔﻭ ﺍﻟﻜﺘﺏ"‪ ،‬ﻴﺤﺘﻭﻯ ﻋﻠﻰ‬
‫ﻋﻤﻭﺩ ﻴﻤﺜﹼل ﺭﻗﻡ ﺍﻟﻜﺘﺎﺏ ﻓﻲ ﺠﺩﻭل ﻋﻨﺎﻭﻴﻥ ﺍﻟﻜﺘﺏ‪ ،‬ﻭﻋﻤﻭﺩ ﺁﺨﺭ ﻴﻤﺜﹼل ﺭﻗﻡ ﺍﻟﻤﺅﻟﹼـﻑ ﻓـﻲ ﺠـﺩﻭل ﺍﻟﻤـﺅﻟﹼﻔﻴﻥ‪،‬‬
‫ﻜﺎﻟﺘﺎﻟﻲ‪:‬‬
‫‪72‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬

‫‪AuthorID‬‬ ‫‪BookID‬‬
‫‪23‬‬ ‫‪1‬‬
‫‪106‬‬ ‫‪1‬‬
‫‪8‬‬ ‫‪2‬‬
‫‪8‬‬ ‫‪3‬‬

‫ﺤﻴﺙ ﺍﺸﺘﺭﻙ ﺍﻟﻤﺅّﻟﻔﺎﻥ ﺭﻗﻤﺎ ‪ 23‬ﻭ ‪ 106‬ﻓﻲ ﺘﺄﻟﻴﻑ ﺍﻟﻜﺘﺎﺏ ﺭﻗﻡ ‪ ،2‬ﺒﻴﻨﻤﺎ ﻗﺎﻡ ﺍﻟﻤﺅﻟﹼﻑ ﺭﻗﻡ ‪ 8‬ﺒﺘﺄﻟﻴﻑ ﺍﻟﻜﺘـﺎﺒﻴﻥ‬
‫ﺭﻗﻤﻲ ‪ 2‬ﻭ ‪ ..3‬ﻫﺫﻩ ﻫﻲ ﻋﻼﻗﺔ ﻤﺘﻌﺩ‪‬ﺩ ﺒﻤﺘﻌﺩ‪‬ﺩ‪.‬‬

‫ﺼﺤّﺔ ﺍﻟﻤﺭﺠﻊ ‪:Referential Integrity‬‬

‫ل ﻫﻨﺎﻙ ﺭﻭﺍﻴﺎﺕ ﻓﻲ ﺠﺩﻭل ﺍﻟﻜﺘـﺏ ﺘـﺸﻴﺭ‬
‫ل ﺘﻭﻓﻴﻕ ﺍﻟﺤﻜﻴﻡ ﻤﻥ ﺠﺩﻭل ﺍﻟﻤﺅﻟﹼﻔﻴﻥ؟‪ ..‬ﺴﺘﻅ ّ‬
‫ﻤﺎﺫﺍ ﺴﻴﺤﺩﺙ ﻟﻭ ﺘ ‪‬ﻡ ﺤﺫﻑ ﺴﺠ ّ‬
‫ﻲ ﻟﺤﺩﻭﺙ ﺃﺨﻁﺎ ٍﺀ ﻤﺯﻋﺠﺔ ﻓﻲ ﺘﻁﺒﻴﻘﻙ!‬
‫ﻥ ﻫﺫﺍ ﻭﻀﻊ ﻤﺜﺎﻟ ‪‬‬
‫ل ﺘﻭﻓﻴﻕ ﺍﻟﺤﻜﻴﻡ‪ ،‬ﺒﻴﻨﻤﺎ ﻫﻭ ﻤﺤﺫﻭﻑ‪ ..‬ﺇ ‪‬‬
‫ﻟﺴﺠ ّ‬
‫ﻭﺍﻟﺤلّ؟‬
‫ل‬
‫ﺏ ﺃﻥ ﺘﺭﺍﻋﻲ ﻤﻨﻁﻘﻴ‪‬ﺔ ﻭﺼﺤ‪‬ﺔ ﺍﻟﻌﻼﻗﺎﺕ ﺍﻟﻤﺭﺠﻌﻴ‪‬ﺔ ‪ Referential Integrity‬ﺒﻴﻥ ﺍﻟﺠﺩﺍﻭل‪ ،‬ﻓﻠﻭ ﻗﻤﺕ ﺒﺤﺫﻑ ﺴﺠ ّ‬
‫ﻴﺠ ‪‬‬
‫ﺘﻭﻓﻴﻕ ﺍﻟﺤﻜﻴﻡ ﻤﻥ ﺠﺩﻭل ﺍﻟﻜﺘﺏ‪ ،‬ﻓﻴﺠﺏ ﺃﻴﻀﺎ ﺃﻥ ﻴﺘ ‪‬ﻡ ﺤﺫﻑ ﻜ ّ‬
‫ل ﺍﻟﺭﻭﺍﻴﺎﺕ ﻭﺍﻟﻜﺘﺏ ﺍﻟﺘﻲ ﺃﻟﹼﻔﻬﺎ ﻤﻥ ﺠﺩﻭل ﺍﻟﻜﺘﺏ‪.‬‬
‫ﻥ ﺒﺭﺍﻤﺞ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻤﺼﻤ‪‬ﻤﺔ ﻟﺘﺭﻴﺤﻙ ﻤﻥ ﻤﻌﻅﻡ ﺍﻟﻌﻤل ﺍﻟﻴﺩﻭﻱ‪ ،‬ﻟﻬﺫﺍ ﻓﻬﻲ‬
‫ﻋﺎ ‪‬ﻤ ﹰﺔ ﺍﻁﻤﺌﻥ‪ ،‬ﻓﻜﻤﺎ ﺫﻜﺭﻨﺎ ﻤﻥ ﻗﺒل‪ ،‬ﻓﺈ ‪‬‬
‫ﺴﺘﻌﻴﻨﻙ ﻋﻠﻰ ﺍﻟﺘﺤﻘﹼﻕ ﻤﻥ ﺼﺤ‪‬ﺔ ﺍﻟﻌﻼﻗﺎﺕ ﺍﻟﻤﺭﺠﻌﻴ‪‬ﺔ ﺒﻴﻥ ﺍﻟﺠﺩﺍﻭل‪ ،‬ﻜﻤﺎ ﺴﻨﺭﻯ ﺒﻌﺩ ﻗﻠﻴل‪.‬‬
‫ﺍﻟﻌﻤﻠﻴﺎﺕ ﻋﻠﻰ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ‪:‬‬
‫ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻋﺒﺎﺭﺓ ﻋﻥ ﻤﺨﺯﻥ ﻴﺘﻡ ﻓﻴﻪ ﺘﺨﺯﻴﻥ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻭﻴﺠﺏ ﺃﻥ ﻴﺘﻤﺘﻊ ﻫﺫﺍ ﺍﻟﻤﺨﺯﻥ ﺒﺎﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ 1‬ـ ﺍﻹﻀﺎﻓﺔ ‪ :‬ﺃﻱ ﺇﻤﻜﺎﻨﻴﺔ ﺇﻀﺎﻓﺔ ﺴﺠﻼﺕ ﺠﺩﻴﺩﺓ ﺇﻟﻰ ﺍﻟﺠﺩﺍﻭل ‪.‬‬
‫‪ 2‬ـ ﺍﻟﺤﺫﻑ ‪ :‬ﺃﻤﻜﺎﻨﻴﺔ ﺤﺫﻑ ﻗﻴﻡ ﻤﻥ ﺍﻟﺠﺩﺍﻭل ﺩﻭﻥ ﺃﻥ ﻴﺅﺜﺭ ﺫﻟﻙ ﻋﻠﻰ ﺍﻟﻘﺎﻋﺩﺓ ‪.‬‬
‫‪ 3‬ـ ﺍﻟﺘﻌﺩﻴل ‪ :‬ﻴﺠﺏ ﺃﻥ ﻨﻜﻭﻥ ﻗﺎﺩﺭﻴﻥ ﻋﻠﻰ ﺘﻌﺩﻴل ﺤﻘﻭل ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ ،‬ﺃﻓﺭﺽ ﻤﺜ ﹰ‬
‫ﻼ ﺃﻥ ﻫﻨﺎﻙ ﺤﻘل ﻓﻲ ﺠﺩﻭل‬
‫ﻴﺤﻭﻱ ﻋﻠﻰ ﻋﺩﺩ ﺍﻟﻨﺴﺦ ﻤﻥ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻤﻥ ﺍﻟﻜﺘﺏ ‪ ،‬ﻋﻠﻴﻨﺎ ﺃﻥ ﻨﻌﺩل ﻫﺫﺍ ﺍﻟﺤﻘل ﻜﻠﻤﺎ ﺇﺸﺘﺭﻯ ﺃﺤﺩ ﺍﻟﺯﺒﺎﺌﻥ ﻜﺘﺎﺒﹰﺎ ﻤﺎ ‪.‬‬
‫‪ 4‬ـ ﺍﻟﺒﺤﺙ ‪ :‬ﻴﺠﺏ ﺍﻟﺤﺼﻭل ﻋﻠﻰ ﺍﻟﻤﻌﻠﻭﻤﺔ ﺍﻟﻤﻁﻠﻭﺒﺔ ﺒﺄﺴﺭﻉ ﻭﻗﺕ ﻤﻤﻜﻥ ‪.‬‬
‫‪ 5‬ـ ﺍﻟﺘﺭﺘﻴﺏ ﻭﺍﻟﻔﺭﺯ ‪ :‬ﺍﻟﻘﺩﺭﺓ ﻋﻠﻰ ﺇﻅﻬﺎﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﻠﻤﺴﺘﺨﺩﻡ ﺒﺎﻟﺸﻜل ﺍﻟﺫﻱ ﻴﺭﻴﺩ ) ﻓﻲ ﺠﺩﻭل ﻴﻤﻜﻥ ﺘﺭﺘﻴﺏ ﺍﻟﻜﺘﺏ‬
‫ﺤﺴﺏ ﺃﺴﻡ ﺍﻟﻜﺘﺎﺏ ﺃﻭ ﺤﺴﺏ ﺃﺴﻡ ﺍﻟﻤﺅﻟﻑ ‪.‬‬
‫ﻋﻠﻴﻙ ﺃﻥ ﺘﻌﺭﻑ ﺃﻴﻀﹰﺎ ﺍﻟﻔﺭﻕ ﺒﻴﻥ ﺘﺨﺯﻴﻥ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻭﺍﻟﻔﺎﺌﺩﺓ ﺍﻟﺘﻲ ﻴﻤﻜﻥ ﺃﻥ ﺘﺠﻨﻴﻬﺎ ﻤﻥ ﻫﺫﻩ ﺍﻟﻤﻌﻁﻴﺎﺕ ‪ ،‬ﻓﺎﻟﻌﻤﻠﻴﺎﺕ ﻋﻠﻰ‬
‫ﺍﻟﻤﻌﻁﻴﺎﺕ ﻫﻲ ﺍﻟﺘﻲ ﺘﻌﻁﻲ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﻭﺍﻟﺘﻲ ﻴﺤﺘﺎﺠﻬﺎ ﻤﺴﺘﺜﻤﺭ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﻴﺘﺨﺫ ﻗﺭﺍﺭﻩ‪ ،‬ﺘﺴﺘﺨﺩﻡ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ‬
‫ﺒﻼﺩﻨﺎ ﻓﻲ ﻤﺠﺎل ﺍﻟﻤﺤﺎﺴﺒﺔ ﻭﺇﺼﺩﺍﺭ ﺍﻟﻔﻭﺍﺘﻴﺭ ﻭﻓﻲ ﻤﺠﺎﻻﺕ ﺍﻹﺤﺼﺎﺀ ﻋﻠﻰ ﺃﻜﺜﺭ ﺘﻘﺩﻴﺭ ) ﻗﻠﻴل ﻤﻥ ﺍﻟﺸﺭﻜﺎﺕ ﺘﻌﺭﻑ‬
‫ﻼ‬
‫ﺍﻻﺴﺘﻔﺎﺩﺓ ﻤﻥ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﺍﻹﺤﺼﺎﺌﻴﺔ ( ﺒﻴﻨﻤﺎ ﺘﺴﺘﺨﺩﻡ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻓﻲ ﺍﻟﺨﺎﺭﺝ ﻜﺎﻟﻭﻻﻴﺎﺕ ﺍﻟﻤﺘﺤﺩﺓ ﺍﻷﻤﺭﻴﻜﻴﺔ ﻤﺜ ﹰ‬
‫ﻟﻠﺤﺼﻭل ﻋﻠﻰ ﻜﻡ ﻫﺎﺌل ﻤﻥ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﻻ ﻴﻤﻜﻥ ﻹﻨﺴﺎﻥ ﻋﺎﺩﻱ ﺃﻥ ﻴﺘﺼﻭﺭﻩ ‪ ،‬ﺍﻓﺭﺽ ﺃﻥ ﺍﻟﺯﺒﻭﻥ ﺴﻌﻴﺩ ﻗﺩ ﺍﺸﺘﺭﻯ ﻤﻥ‬
‫ﺍﻟﻤﻜﺘﺒﺔ ﻋﺩﺓ ﻜﺘﺏ ﺘﺘﻌﻠﻕ ﺒﻠﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺨﻼل ﺴﻨﺔ ‪ ،‬ﻴﺘﻜﻭﻥ ﻤﻥ ﻫﺫﻩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺃﻥ ﺴﻌﻴﺩ ﻴﺤﺏ ﻗﺭﺍﺀﺓ ﻜﺘﺏ ﺍﻟﺒﺭﻤﺠﺔ‬

‫‪73‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻭﻴﻘﻭﻡ ﺼﺎﺤﺏ ﺍﻟﻤﻜﺘﺒﺔ ﺒﺈﺭﺴﺎل ﺇﻋﻼﻨﺎﺕ ﺇﻟﻰ ﺴﻌﻴﺩ ﻜﻠﻤﺎ ﺼﺩﺭ ﻤﺅﻟﻑ ﺠﺩﻴﺩ ﻓﻲ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ‪ ،‬ﻟﻨﻔﺭﺽ ﺃﻴﻀﹰﺎ ﺃﻨﻪ ﻓﻲ‬
‫ﺃﺴﺒﻭﻉ ﻤﺎ ﻜﺜﺭ ﺍﻟﻁﻠﺏ ﻋﻠﻰ ﻜﺘﺎﺏ ﻤﺎ ‪ ) Harry potter‬ﺍﻟﻜﺘﺎﺏ ﺍﻟﺫﻱ ﺤﺼﺩ ﺃﻜﺒﺭ ﻤﺒﻴﻌﺎﺕ ﻓﻲ ﺍﻟﻌﺎﻟﻡ ﻓﻲ ﺍﻟﺸﻬﺭ ﺍﻟﺴﺎﺩﺱ‬
‫‪ ، ( 2003‬ﻋﻨﺩﻫﺎ ﻴﻘﻭﻡ ﺼﺎﺤﺏ ﺍﻟﻤﻜﺘﺒﺔ ﺒﺘﻌﺩﻴل ﺘﺭﺘﻴﺏ ﺍﻟﻜﺘﺏ ﺍﻟﻤﻭﻀﻭﻋﺔ ﻋﻠﻰ ﺍﻟﺭﻓﻭﻑ ﻟﻴﻜﻭﻥ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻋﻠﻰ‬
‫ﺍﻟﺭﻓﻭﻑ ﻓﻲ ﻭﺍﺠﻪ ﺍﻟﻤﻜﺘﺒﺔ ‪ ).‬ﻁﺒﻌﹰﺎ ﻻ ﻴﻤﻜﻥ ﺘﻁﺒﻴﻕ ﻫﺫﻩ ﺍﻷﻤﺜﻠﺔ ﻋﻨﺩﻨﺎ ﻫﻜﺫﺍ ‪ ،‬ﻷﻥ ﺃﻱ ﻤﻜﺘﺒﺔ ﻓﻲ ﺍﻟﻭﻻﻴﺎﺕ ﺍﻟﻤﺘﺤﺩﺓ ﻴﻜﻭﻥ‬
‫ﻟﻬﺎ ﻓﺭﻭﻉ ﻓﻲ ﺃﻜﺜﺭ ﻤﻥ ﻭﻻﻴﺔ ﻭﻤﺩﻴﻨﺔ ﻤﻤﺎ ﻴﻌﻨﻲ ﻋﺩﺩ ﺯﺒﺎﺌﻥ ﻴﻔﻭﻕ ﺍﻟﻤﻠﻴﻭﻥ ﺯﺒﻭﻥ‪ ،‬ﻤﻤﺎ ﻴﻌﻁﻲ ﺇﺤﺼﺎﺌﻴﺎﺕ ﻭﺍﺴﻌﺔ ﻋﻥ‬
‫ﺤﺭﻜﺔ ﺍﻟﺒﻴﻊ ﻭﺍﻟﺸﺭﺍﺀ (‬
‫ﺨﻁﻭﺍﺕ ﺘﺼﻤﻴﻡ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ‪:‬‬
‫‪ 1‬ـ ﺘﺤﺩﻴﺩ ﺍﻟﻐﺭﺽ ﻤﻥ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ ‪.‬‬
‫‪ 2‬ـ ﺘﺤﺩﻴﺩ ﺍﻟﺠﺩﺍﻭل ﺍﻟﺘﻲ ﻨﺤﺘﺎﺝ ﺇﻟﻴﻬﺎ ﻓﻲ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ ‪.‬‬
‫‪ 3‬ـ ﺘﺤﺩﻴﺩ ﺤﻘﻭل ﺍﻟﺠﺩﺍﻭل ﺍﻟﺘﻲ ﻨﺤﺘﺎﺝ ﺇﻟﻴﻬﺎ ‪.‬‬
‫‪ 4‬ـ ﺘﻌﻴﻴﻥ ﺍﻟﺤﻘﻭل ﺍﻟﻤﻔﺘﺎﺤﻴﺔ ‪.‬‬
‫‪ 5‬ـ ﺘﺤﺩﻴﺩ ﺍﻟﻌﻼﻗﺎﺕ ﺒﻴﻥ ﺍﻟﺠﺩﺍﻭل‬
‫‪ 6‬ـ ﺇﺩﺨﺎل ﺍﻟﻤﻌﻁﻴﺎﺕ ‪.‬‬
‫‪ 1‬ـ ﺘﺤﺩﻴﺩ ﺍﻟﻐﺭﺽ ﻤﻥ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ ‪:‬‬
‫ﻻ ﻤﺎﺫﺍ ﻴﺭﻴﺩ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻤﻥ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻭﺜﻡ ﻤﻌﺭﻓﺔ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻟﺘﻲ ﻴﺠﺏ ﺘﺨﺯﻴﻨﻬﺎ ﻓﻲ ﺍﻟﻘﺎﻋﺩﺓ ﻷﻥ‬
‫ﻴﺠﺏ ﺍﻟﻤﻌﺭﻓﺔ ﺃﻭ ﹰ‬
‫ﺃﻱ ﺯﻴﺎﺩﺓ ﻓﻲ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺴﻴﻨﺘﺞ ﻋﻨﻪ ﺯﻴﺎﺩﺓ ﻓﻲ ﺤﺠﻡ ﺍﻟﻘﺎﻋﺩﺓ ﺒﺩﻭﻥ ﺴﺒﺏ ‪ ،‬ﻭﺃﻱ ﻨﻘﺹ ﻓﻲ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺴﻴﺘﻁﻠﺏ ﻤﻨﺎ ﺘﻌﺩﻴل‬
‫ﺍﻟﺠﺩﻭل ﻓﻴﻤﺎ ﺒﻌﺩ ﻭﺍﻟﺫﻱ ﻗﺩ ﻴﺅﺩﻱ ﺒﺩﻭﺭﻩ ﺇﻟﻰ ﺘﻌﺩﻴل ﻓﻲ ﺍﻟﺠﺩﺍﻭل ﺍﻟﻤﺭﺘﺒﺔ ﻭﺒﺎﻟﺘﺎﻟﻲ ﺘﻌﺩﻴل ﺍﻟﻘﺎﻋﺩﺓ ﺒﺎﻟﻜﺎﻤل ‪.‬‬
‫‪ 2‬ـ ﺘﺤﺩﻴﺩ ﺍﻟﺠﺩﺍﻭل ﺍﻟﺘﻲ ﻨﺤﺘﺎﺝ ﺇﻟﻴﻬﺎ ﻓﻲ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ ‪:‬‬
‫ﺒﻌﺩ ﺘﺤﺩﻴﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻟﻤﻁﻠﻭﺏ ﺘﺨﺯﻴﻨﻬﺎ ﻴﺠﺏ ﻋﻠﻴﻨﺎ ﺍﻟﻌﻤل ﻋﻠﻰ ﺘﺨﻁﻴﻁ ﺍﻟﺠﺩﺍﻭل ﺍﻟﺘﻲ ﺴﺘﺨﺯﻥ ﻫﺫﻩ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ‪.‬‬
‫‪ 3‬ـ ﺘﺤﺩﻴﺩ ﺤﻘﻭل ﺍﻟﺠﺩﺍﻭل ﺍﻟﺘﻲ ﻨﺤﺘﺎﺝ ﺇﻟﻴﻬﺎ ‪:‬‬
‫ﻴﺠﺏ ﺃﻥ ﻻ ﻴﺘﻀﻤﻥ ﺍﻟﺠﺩﻭل ﻤﻌﻠﻭﻤﺎﺕ ﻤﺘﻜﺭﺭﺓ ‪،‬ﻜﻤﺎ ﺃﻨﻪ ﻻ ﻴﺠﺏ ﺘﻜﺭﺍﺭ ﺍﻟﻤﻌﻠﻭﻤﺔ ﺍﻟﻭﺍﺤﺩﺓ ﺒﻴﻥ ﺍﻟﺠﺩﺍﻭل ‪ ،‬ﻫﺫﺍ ﻴﻀﻤﻥ‬
‫ﺘﺤﺩﻴﺙ ﺍﻟﻤﻌﻠﻭﻤﺔ ﻓﻲ ﻤﻜﺎﻨﻬﺎ ﻭﻴﻘﻀﻲ ﻋﻠﻰ ﺍﺤﺘﻤﺎل ﺇﺩﺨﺎل ﻤﻌﻠﻭﻤﺎﺕ ﻤﺘﺒﺎﻴﻨﺔ ﻟﺘﻠﻙ ﺍﻟﻤﻌﻠﻭﻤﺔ ﻓﻴﻤﺎ ﻟﻭ ﻭﺠﺩﺕ ﻓﻲ ﻤﻜﺎﻨﻴﻥ‬
‫ﻤﺨﺘﻠﻔﻴﻥ ‪.‬‬
‫‪........‬‬
‫ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻓﻲ ﺩﻟﻔﻲ ‪..... :‬‬
‫‪ 1‬ـ ﺒﺭﺍﻤﺞ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ‪ :‬ﻫﻲ ﺍﻟﺒﺭﺍﻤﺞ ﺍﻟﺘﻲ ﺘﺴﻤﺢ ﻟﻠﻤﺴﺘﺨﺩﻡ ﺒﺎﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻟﻤﺨﺯﻨﺔ ﻀﻤﻥ ﻗﺎﻋﺩﺓ‬
‫ﺍﻟﻤﻌﻁﻴﺎﺕ‪ ،‬ﻭﻋﻨﺩ ﻜﺘﺎﺒﺔ ﺒﺭﻨﺎﻤﺞ ﻟﻘﺎﻋﺩ ﻤﻌﻁﻴﺎﺕ ﻴﺠﺏ ﺃﻥ ﺘﻜﻭﻥ ﻋﻠﻰ ﻋﻠﻡ ﻜﺎﻑ ﺒﺒﻨﻴﺔ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻟﺘﻲ ﺘﺘﻌﺎﻤل ﻤﻌﻬﺎ‬
‫) ﺍﻟﺠﺩﺍﻭل ﻭﺍﻟﺤﻘﻭل ( ﺤﻴﺙ ﻴﻤﻜﻨﻙ ﺫﻟﻙ ﻤﻥ ﺘﺼﻤﻴﻡ ﺍﻟﻭﺍﺠﻬﺎﺕ ﺍﻟﺘﻲ ﺘﺴﻤﺢ ﻟﻠﻤﺴﺘﺨﺩﻡ ﺒﺘﻌﺎﻤل ﻤﻊ ﻫﺫﻩ ﺍﻟﻤﻌﻁﻴﺎﺕ )‬
‫ﺍﺴﺘﻌﺭﺍﺽ ‪ ،‬ﺇﻀﺎﻓﺔ ‪ ،‬ﺤﺫﻑ ‪ ،‬ﺒﺤﺙ ‪. ( .......‬‬

‫‪ 2‬ـ ﺃﻨﻭﺍﻉ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ‪:‬‬

‫‪74‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﺨﺘﻴﺎﺭ ﻨﻭﻉ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻟﺘﻲ ﺴﺘﺨﺩﻡ ﻴﻌﺘﻤﺩ ﻋﻠﻰ ﺜﻼﺙ ﻨﻘﺎﻁ ﺭﺌﻴﺴﻴﺔ ‪:‬‬
‫‪ 1‬ـ ﺤﺠﻡ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻟﺘﻲ ﺴﻴﺤﻭﻴﻪ ﻜل ﺠﺩﻭل ‪.‬‬
‫‪ 2‬ـ ﻜﻡ ﻫﻭ ﻋﺩﺩ ﺍﻟﻤﺴﺘﺨﺩﻤﻴﻥ ﺍﻟﺫﻴﻥ ﺴﻴﺘﺸﺎﺭﻜﻭﻥ ﺍﻟﻌﻤل ﻋﻠﻰ ﻫﺫﻩ ﺍﻟﻘﺎﻋﺩﺓ ‪.‬‬
‫‪ 3‬ـ ﺴﺭﻋﺔ ﺍﻷﺩﺍﺀ ﺍﻟﻤﻁﻠﻭﺒﺔ ﻤﻥ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ ‪.‬‬
‫ﻭﻋﻠﻰ ﻫﺫﺍ ﺍﻟﻤﺒﺩﺃ ﺘﻘﺴﻡ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺇﻟﻰ ﻗﺴﻤﻴﻥ ‪:‬‬
‫ﺃ ـ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻟﻤﺤﻠﻴﺔ ‪:‬‬
‫ﺘﻌﻤل ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻟﻤﺤﻠﻴﺔ ﻋﻠﻰ ﺠﻬﺎﺯ ﻭﺍﺤﺩ ﺃﻭ ﻋﻠﻰ ﺸﺒﻜﺔ ﻤﺤﻠﻴﺔ ﺼﻐﻴﺭﺓ ‪ ،‬ﻭﻫﻲ ﺴﺭﻴﻌﺔ ﻋﻤﻠﻴﹰﺎ ﻭﻟﻜﻨﻬﺎ ﺃﺒﻁﺊ ﻓﻲ‬
‫ﺤﺎﻻﺕ ﺍﻟﺘﺸﺎﺭﻙ ﻋﻠﻰ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ) ﺘﺼﻭﺭ ﻋﺩﺩ ﻤﻥ ﺍﻟﻤﻭﻅﻔﻴﻥ ﻴﻘﻭﻤﻭﻥ ﺒﺈﺩﺨﺎل ﺍﻟﻜﺘﺏ ﺍﻟﺠﺩﻴﺩﺓ ﺍﻟﻭﺍﺼﻠﺔ ﺇﻟﻰ‬
‫ﺍﻟﻤﻜﺘﺒﺔ ﺒﻨﻔﺱ ﺍﻟﻭﻗﺕ ‪ ،‬ﻋﻨﺩﻫﺎ ﻋﻠﻰ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻟﻌﻤل ﻋﻠﻰ ﺠﻌل ﺫﻟﻙ ﻤﺘﺎﺤﹰﺎ ﻟﻠﻤﻭﻅﻔﻴﻥ ( ﺘﻘﻭﻡ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ‬
‫ﺍﻟﻤﺤﻠﻴﺔ ﻋﻠﻰ ﻗﻔل ﺍﻟﻤﻠﻑ ) ﺍﻟﺠﺩﻭل ( ﻟﻠﻤﺴﺘﺨﺩﻡ ﺍﻟﺤﺎﻟﻲ ﻭﻤﻨﻊ ﺍﻟﺘﻌﺩﻴل ﻓﻲ ﻫﺫﺍ ﺍﻟﺠﺩﻭل ﻤﻥ ﻗﺒل ﻤﺴﺘﺨﺩﻡ ﺁﺨﺭ ﺤﺘﻰ ﻴﻨﻬﻲ‬
‫ﺍﻟﻤﺴﺘﺨﺩﻡ ﺍﻟﺤﺎﻟﻲ ﺘﻌﺩﻴﻠﻪ ) ﻴﻭﺠﺩ ﺨﻭﺍﺭﺯﻤﻴﺎﺕ ﻜﺜﻴﺭﺓ ﻟﺘﻁﺒﻴﻕ ﻫﺫﺍ ﺍﻟﻌﻤل ( ﻭﺍﻋﺘﻤﺎﺩ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻋﻠﻰ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ‬
‫ﺍﻟﻘﻔل ﺠﻌﻠﻬﺎ ﻤﺤﺩﻭﺩﺓ ﺍﻟﺤﺠﻡ ﻨﻭﻋﹰﺎ ﻤﺎ ) ﻫﻨﺎﻙ ﻋﺩﺩ ﺃﻋﻅﻤﻲ ﻟﻠﺴﺠﻼﺕ ﺍﻟﺘﻲ ﻴﻤﻜﻥ ﻟﻘﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻟﺘﻌﺎﻤل ﻤﻌﻬﺎ ( ‪.‬‬
‫ﺴﺭﻴﺔ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﻓﻲ ﻫﺫﻩ ﺍﻟﻘﻭﺍﻋﺩ ﻀﻌﻴﻔﺔ ﺠﺩﹰﺍ ﻭﻴﻤﻜﻥ ﻜﺴﺭﻫﺎ ﺒﺴﻬﻭﻟﺔ‪.‬‬
‫ﻜﻤﺜﺎل ﻋﻠﻰ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻟﻤﺤﻠﻴﺔ ﻟﺩﻴﻨﺎ ‪. Paradox, dBASE, FoxPro, and Access. :‬‬
‫ﺏ ـ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻟﻤﻭﺯﻋﺔ ‪:‬‬
‫ﺘﺴﻤﺢ ﻫﺫﻩ ﺍﻟﻘﻭﺍﻋﺩ ﻟﻌﺩﺓ ﻤﺴﺘﺨﺩﻤﻴﻥ ) ﺁﻻﻑ ﺍﻟﻤﺴﺘﺨﺩﻤﻴﻥ ( ﺒﺎﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺠﺩﺍﻭل ﻭﺘﺴﺘﺨﺩﻡ ﺨﻭﺍﺭﺯﻤﻴﺎﺕ ﻤﻌﻘﺩﺓ ﻟﺘﺤﻘﻴﻕ‬
‫ﺫﻟﻙ ) ﺠﻤﻴﻊ ﺸﺭﻜﺎﺕ ﺍﻟﻁﻴﺭﺍﻥ ﻓﻲ ﺍﻟﻌﺎﻟﻡ ﻤﻭﺼﻭﻟﺔ ﺇﻟﻰ ﻗﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﻭﺍﺤﺩﺓ( ‪ ،‬ﻗﺎﻋﺩﺓ ﻤﻌﻁﻴﺎﺕ ‪Microsoft SQL‬‬
‫‪ Server‬ﺘﺴﺘﺨﺩﻡ ﺍﻟﻘﻔل ﻋﻠﻰ ﻤﺴﺘﻭﻯ ﺍﻟﺴﺠل ﺃﻱ ﺘﺴﻤﺢ ﻟﻌﺩﺓ ﻤﺴﺘﺨﺩﻤﻴﻥ ﺒﺘﻌﺩﻴل ﻨﻔﺱ ﺍﻟﺠﺩﻭل ﺒﻨﻔﺱ ﺍﻟﻭﻗﺕ ﻭﻟﻜﻨﻬﺎ ﻻ‬
‫ﺘﺴﻤﺢ ﻟﻬﻡ ﺒﺘﻌﺩﻴل ﻨﻔﺱ ﺍﻟﺴﺠل ‪.‬‬
‫ﻴﻤﻜﻥ ﺃﻥ ﻴﺼل ﺤﺠﻡ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻫﺫﻩ ﺇﻟﻰ ﻜﻤﻴﺎﺕ ﻫﺎﺌﻠﺔ ) ﺒﻠﻎ ﺤﺠﻡ ﻤﻌﻁﻴﺎﺕ ﺇﺤﺩﻯ ﺸﺭﻜﺎﺕ ﺍﻟﺘﺴﻭﻴﻕ ﻓﻲ ﺃﻤﺭﻴﻜﺎ‬
‫‪ ( 3.6 TB‬ﻜﻤﺎ ﺃﻨﻪ ﻴﻤﻜﻥ ﻟﻘﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻫﺫﻩ ﺃﻥ ﺘﻭﺠﺩ ﻋﻠﻰ ﺃﺠﻬﺯﺓ ﻤﺨﺘﻠﻔﺔ ‪.‬‬
‫ﺴﺭﻴﺔ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﻓﻲ ﻫﺫﻩ ﺍﻟﻘﻭﺍﻋﺩ ﻗﻭﻴﺔ ﺠﺩﹰﺍ ‪ ،‬ﻜﻤﺎ ﺃﻨﻬﺎ ﺘﻌﻁﻲ ﺴﻤﺎﺤﻴﺎﺕ ﻟﻠﻤﺴﺘﺨﺩﻤﻴﻥ ‪ ،‬ﻓﻤﻭﻅﻑ ﺍﻟﻤﻜﺘﺒﺔ ﺍﻟﻤﺴﺌﻭل ﻋﻥ‬
‫ﺇﺩﺨﺎل ﺃﺴﻤﺎﺀ ﺍﻟﻜﺘﺏ ﻻ ﻴﺤﻕ ﻟﻪ ﺍﻹﻁﻼﻉ ﻋﻠﻰ ﻜﻤﻴﺔ ﺍﻟﻤﺒﻴﻌﺎﺕ ‪...‬‬
‫ﺘﺸﺘﺭﻙ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻫﺫﻩ ﺒﺎﺴﺘﺨﺩﺍﻤﻬﺎ ﻟﻠﻐﺔ ﺍﻻﺴﺘﻔﺴﺎﺭﺍﺕ ﺍﻟﺒﻨﻴﻭﻴﺔ )‪Structured Query Language (SQL‬‬
‫ﻜﻤﺜﺎل ﻋﻠﻰ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻟﻤﻭﺯﻋﺔ ﻟﺩﻴﻨﺎ ‪InterBase, Oracle, Sybase, Informix, Microsoft SQLserver, :‬‬
‫‪and DB2.‬‬
‫‪ 3‬ـ ﺒﻨﻴﺔ ﺒﺭﻨﺎﻤﺞ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ‪:‬‬
‫ﻴﺒﻥ ﺍﻟﺸﻜل ﺍﻟﻤﺠﺎﻭﺭ ﺒﻨﻴﺔ ﺘﻁﺒﻴﻕ ﻗﻭﺍﻋﺩ‬
‫ﺍﻟﻤﻌﻁﻴﺎﺕ ﻭﺍﻟﺫﻱ ﻴﺘﺄﻟﻑ ﻤﻥ‬
‫ﺃ ـ ﻭﺍﺠﻬﺔ ﺍﻟﻤﺴﺘﺨﺩﻡ ‪ :‬ﻭﻫﻲ ﺍﻟﻨﻭﺍﻓـﺫ‬
‫ـﺴﻤﺢ‬
‫ـﺭﻤﺞ ﻟﻴـ‬
‫ـﺼﻤﻤﻬﺎ ﺍﻟﻤﺒـ‬
‫ـﻲ ﻴـ‬
‫ﺍﻟﺘـ‬
‫ﻟﻠﻤﺴﺘﺨﺩﻡ ﺒﺎﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻤﻌﻁﻴﺎﺕ ‪.‬‬
‫‪75‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺏ ـ ﻋﻨﺎﺼﺭ ﺍﻟﻭﺼﻭل ‪ : Data Access ) :‬ﺘﺴﺘﺨﺩﻡ ﻟﻠﻭﺼﻭل ﺇﻟﻰ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻭﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻥ ﺭﺒـﻁ ﺒـﻴﻥ‬
‫ﻋﻨﺎﺼﺭ ﺍﻟﺘﺤﻜﻡ ﺒﺎﻟﻤﻌﻁﻴﺎﺕ ﻤﻊ ﻭﺍﺠﻬﺔ ﺍﻟﻤﺴﺘﺨﺩﻡ ‪.‬‬
‫ﺝ ـ ﻋﻨﺎﺼﺭ ﺍﻟﺘﺤﻜﻡ ﺒﺎﻟﻤﻌﻁﻴﺎﺕ ‪ :‬ﺘﺯﻭﺩ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺒﻭﺍﺠﻬﺔ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺠﺩﺍﻭل ﺍﻟﻤﻌﻁﻴﺎﺕ ‪.‬‬
‫ﻤﻥ ﺍﻟﻤﻬﻡ ﺃﻥ ﺘﻼﺤﻅ ﺃﻥ ﺍﻟﺘﻁﺒﻴﻕ ) ﺍﻟﺒﺭﻨﺎﻤﺞ ( ﻤﺴﺘﻘل ﻋﻥ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ‪ ،‬ﺤﻴﺙ ﺘﻭﻓﺭ ﺩﻟﻔﻲ ﺃﺩﻭﺍﺕ ﻟﻠﻭﺼـﻭل ﺇﻟـﻰ‬
‫ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻭﻻﻟﻜﻨﻬﺎ ﻻ ﺘﺘﺩﺨل ﺒﻜﻴﻔﻴﺔ ﺘﻌﺎﻤل ﺍﻟﻘﺎﻋﺩﺓ ﻤﻊ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﺍﻟﻤﺩﺨﻠﺔ ) ﻋﻨﺩ ﺇﺩﺨﺎل ﺴـﺠل ﺇﻟـﻰ ﺠـﺩﻭل‬
‫ﻤﻌﻁﻴﺎﺕ ‪ Oracle‬ﻻ ﺘﻬﺘﻡ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ﻭﻻ ﺤﺘﻰ ﺍﻟﻤﺒﺭﻤﺞ ﺒﻜﻴﻔﻴﺔ ﺘﺨﺯﻴﻥ ﻫﺫﺍ ﺍﻟﺴﺠل ﻭﺍﻟﻁﺭﻕ ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺔ ﺍﻟﻤﺘﺒﻌﺔ ﻓﻲ‬
‫ﺫﻟﻙ ﻭ ﻻ ﺤﺘﻰ ﻁﺭﻕ ﺍﻟﺒﺤﺙ ‪ ،‬ﻓﻌﻤل ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ﻫﻨﺎ ﻴﻘﺘﺼﺭ ﻋﻠﻰ ﻁﻠﺏ ﺃﻭﺍﻤﺭ ﻤﺤﺩﺩﺓ ﻤﻥ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴـﺎﺕ ﻭﺍﻟﺘـﻲ‬
‫ﺘﻘﻭﻡ ﺒﺩﻭﺭﻫﺎ ﺒﺘﻨﻔﻴﺫﻫﺎ ﻭﺇﻋﺎﺩﺘﻬﺎ ﺇﻟﻰ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺘﺩﻋﻰ ﻋﻨﺎﺼﺭ ﺩﻟﻔﻲ ﺍﻟﻤﺴﺌﻭﻟﺔ ﻋﻥ ﺫﻟـﻙ ﺒﻌﻨﺎﺼـﺭ ﺍﻟﻭﺼـﻭل ‪Data‬‬
‫‪.Access‬‬

‫‪76‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ﺍﻟﺭﺍﺒﻌﺔ ﻋﺸﺭ‬
‫ﺒﻨﺎﺀ ﺘﻁﺒﻴﻘﺎﺕ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ‪:‬‬
‫ﻴﺄﺘﻲ ﻤﻊ ﺩﻟﻔﻲ ﻗﻭﺍﻋﺩ ﻤﻌﻁﻴﺎﺕ ﺠﺎﻫﺯﺓ ﺘﺴﺘﺨﺩﻡ ﻜﺄﻤﺜﻠﺔ ﻋﻠﻰ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻭﻁﺭﻕ ﺍﻟﺘﻌﺎﻤل ﻤﻌﻬﺎ‪ ،‬ﻟﺫﻟﻙ ﺴﻨﺘﻌﺎﻤل ﻤﻊ‬
‫ﻫﺫﻩ ﺍﻟﻘﻭﺍﻋﺩ ﺤﺘﻰ ﻴﺼﺒﺢ ﺍﻟﻭﻗﺕ ﺠﺎﻫﺯﹰﺍ ﻹﻨﺸﺎﺀ ﻗﻭﺍﻋﺩﻨﺎ ﺍﻟﺨﺎﺼﺔ ‪.‬‬
‫ﻤﺜﺎل ‪ : 1‬ﺒﻨﺎﺀ ﻨﻤﻭﺫﺝ ﻓﻴﻪ ﺠﺩﻭل ﻭﺤﻴﺩ ‪:‬‬
‫ﺃﺴﻬل ﻁﺭﻴﻘﺔ ﻟﻜﺘﺎﺒﺔ ﺒﺭﻨﺎﻤﺞ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻫﻲ ﺍﺴﺘﺨﺩﺍﻡ ﻤﻌﺎﻟﺞ ﺍﻟﻨﻤﺎﺫﺝ ) ‪ ( Form Wizard‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ‬
‫‪. Database‬‬
‫ﻟﻠﺒﺩﺀ ﺒﺎﻟﻌﻤل ﺃﻨﺸﺊ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﺜﻡ ﺃﻏﻠﻕ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻷﻭل ) ﺍﻻﻓﺘﺭﺍﻀﻲ ( ﻋﻥ ﻁﺭﻴﻕ ﺍﻷﻤﺭ ‪ File Æ Close‬ﺃﻭ‬
‫ﺍﻟﺘﺤﻭﻴل ﺇﻟﻰ ﻤﺤﺭﺭ ﺍﻟﺸﻴﻔﺭﺓ ﻭﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﻤﻔﺘﺎﺤﻴﻥ ‪ Ctrl+F4‬ﺴﺘﻅﻬﺭ ﻟﻙ ﻨﺎﻓﺫﺓ ﺘﺴﺄﻟﻙ ﺇﻥ ﻜﻨﺕ ﺘﺭﻴﺩ ﺤﻔﻅ ﺍﻟﻭﺤﺩﺓ‬
‫ﺃﺠﺏ ﺒﻼ ‪.‬‬
‫ﺒﻬﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﻨﻜﻭﻥ ﻗﺩ ﺤﺼﻠﻨﺎ ﻋﻠﻰ ﻤﺸﺭﻭﻉ ﺒﺩﻭﻥ ﻨﻤﻭﺫﺝ ﺃﻭﻟﻲ ﻷﻨﻨﺎ ﺴﻨﻨﺸﺊ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﻤﻥ ﺨﻼل ﻤﻌﺎﻟﺞ ﺍﻟﻨﻤﺎﺫﺝ‬
‫ﺍﺨﺘﺭ ﺍﻷﻤﺭ ‪ Database Æ Form Wizard‬ﻤﻥ ﻗﻭﺍﺌﻡ ﺍﻟﺩﻟﻔﻲ ‪:‬‬
‫ﺴﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﺎﻟﻴﺔ ‪ :‬ﺍﺘﺭﻙ ﺍﻟﺨﻴﺎﺭﺍﺕ‬
‫ﺍﻻﻓﺘﺭﺍﻀﻴﺔ ﻭﺴﺘﺘﻌﺭﻑ ﻋﻠﻰ ﺨﻴﺎﺭﺘﻬﺎ ﻻﺤﻘﹰﺎ ‪.‬‬
‫ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪Next‬‬

‫ﺴﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻤﺠﺎﻭﺭﺓ ﻭﺍﻟﺘﻲ ﺘﻁﺎﻟﺒﻙ‬

‫ﺒﺘﺤﺩﻴﺩ ﺍﻟﺠﺩﻭل ﺍﻟﺫﻱ ﺴﻴﺘﻌﺎﻤل ﻤﻌﻪ ﺍﻟﻨﻤﻭﺫﺝ ‪،‬‬
‫ﻟﺘﺤﺩﻴﺩ ﺍﻟﺠﺩﻭل ﺃﺨﺘﺭ ‪ DBDEMOS‬ﻤﻥ ﺍﻟﻘﺴﻡ‬
‫‪) Drive or Alias Name‬ﺴﻴﺸﺭﺡ ﻤﻌﻨﻰ ﺫﻟﻙ‬
‫ﻻﺤﻘ ﹰﺎ(‬
‫ﺴﺘﻅﻬﺭ ﺠﻤﻴﻊ ﺍﻟﺠﺩﺍﻭل ﻓﻲ ﺍﻟﻘﺎﻋﺩﺓ ‪DBDEMOS‬‬
‫ﺍﺨﺘﺭ ﻤﻨﻬﺎ ﺍﻟﺠﺩﻭل ‪Country.db‬‬

‫‪77‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻀﻐﻁ ﻋﻠﻰ ‪. Next‬‬
‫ﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻤﺠﺎﻭﺭﺓ ﻭﺍﻟﺘﻲ ﺘﻁﺎﻟﺒﻙ ﺒﺘﺤﺩﻴﺩ‬
‫ﺍﻟﺤﻘﻭل ﺍﻟﺘﻲ ﺘﺭﻴﺩ ﺇﻅﻬﺎﺭﻫﺎ ﻓﻲ ﺍﻟﺠﺩﻭل ‪.‬‬
‫ﻹﻅﻬﺎﺭ ﺤﻘل ﻤﺎ ﺃﺨﺘﺭ ﻫﺫﺍ ﺍﻟﺤﻘل ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ‬
‫>‬
‫ﻭﻹﻅﻬﺎﺭ ﺠﻤﻴﻊ ﺍﻟﺤﻘﻭل ﺍﺨﺘﺭ ﺍﻟﺯﺭ >>‬
‫ﻟﺘﺭﺍﺠﻊ ﻋﻥ ﺍﺨﻴﺎﺭ ﺤﻘل ﺍﺨﺘﺭ ﻫﺫﺍ ﺍﻟﺤﻘل ﻭﺃﻀﻐﻁ ﻋﻠﻰ‬
‫ﺍﻟﺯﺭ <‬
‫ﻟﻠﺘﺭﺍﺠﻊ ﻋﻥ ﺍﺨﺘﻴﺎﺭ ﺠﻤﻴﻊ ﺍﻟﺤﻘﻭل ﺍﺨﺘﺭ ﺍﻟﺯﺭ <<‬
‫ﺃﻀﻑ ﺍﻵﻥ ﺠﻤﻴﻊ ﺍﻟﺤﻘﻭل ) >> ( ‪.‬‬
‫ﻭﺍﻀﻐﻁ ﻋﻠﻰ ‪ Next‬ﻟﻠﻤﺘﺎﺒﻌﺔ‬

‫ﺴﺘﻅﻬﺭ ﻨﺎﻓﺫﺓ ﺘﻁﺎﻟﺒﻙ ﺒﻁﺭﻴﻘﺔ ﻋﺭﺽ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪:‬‬

‫ﺃﻓﻘﻲ ﺃﻭ ﻋﺎﻤﻭﺩﻱ ﺃﻭ ﻓﻲ ﺠﺩﻭل‬
‫ﺤﺩﺩ ﺍﻟﺨﻴﺎﺭ ﻓﻲ ﺠﺩﻭل ) ‪( In grid‬‬
‫ﻭﺍﻀﻐﻁ ﻋﻠﻰ ‪Next‬‬

‫ﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻷﺨﻴﺭﺓ ) ﺨﻴﺎﺭﺍﺕ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﺴﻴﺘﻡ‬

‫ﺘﻭﻀﻴﺤﻬﺎ ﻻﺤﻘﹰﺎ (‬
‫ﻓﻌل ﺍﻟﺨﻴﺎﺭ ‪Generate a main form‬‬
‫ﺇﺫﺍ ﻜﺎﻥ ﺍﻟﻨﻤﻭﺫﺝ ﻫﻭ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺭﺌﻴﺴﻲ ﻓﻲ ﺒﺭﻨﺎﻤﺠﻙ‬
‫ﺍﻀﻐﻁ ﻋﻠﻰ ‪ Finish‬ﻹﻅﻬﺎﺭ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺘﺎﻟﻲ ‪.‬‬

‫‪78‬‬
 ‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬

‫ﻋﻨﺩ ﺍﻻﻨﺘﻬﺎﺀ ﻴﻅﻬﺭ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺘﺎﻟﻲ ‪:‬‬

‫ﻋﻨﺼﺮ اﻟﻮﺻﻮل‬
‫ﻋﻨﺼﺮ ﺍﻟﺘﺤﻜﻢ‬ ‫‪TDataSouce‬‬
‫‪TDBnaviagtor‬‬

‫ﻋﻨﺼﺮ اﻟﻮﺻﻮل‬
‫‪TTable‬‬
‫ﻋﻨﺼﺮ اﻟﺘﺤﻜﻢ‬
‫‪DBGrid‬‬

‫ﻟﻘﺩ ﻗﺎﻡ ﻤﻌﺎﻟﺞ ﺍﻟﻨﻤﺎﺫﺝ ﺒﺈﻨﺸﺎﺀ ﻨﻤﻭﺫﺝ ﻭﻀﻊ ﻋﻠﻴﻪ ﻋﺩﺩ ﻤﻥ ﻋﻨﺎﺼﺭ ﺍﻟﺘﺤﻜﻡ ﺒﺎﻟﻤﻌﻁﻴﺎﺕ ﻭﻋﻨﺎﺼﺭ ﺃﺨﺭﻯ ﻟﻠﻭﺼﻭل ﺇﻟﻰ‬
‫ﺍﻟﻤﻌﻁﻴﺎﺕ ‪.‬‬
‫ﻨﻔﺫ ﺍﻟﺘﻁﺒﻴﻕ ﺍﻵﻥ ﻭﻻﺤﻅ ﻤﺎ ﻴﻠﻲ ‪:‬‬
‫‪ 1‬ـ ﻋﻨﺎﺼﺭ ﺍﻟﻭﺼﻭل ﻋﻠﻰ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻻ ﺘﻅﻬﺭ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ‪.‬‬
‫‪ 2‬ـ ﻴﻅﻬﺭ ﻋﻨﺼﺭ ﺍﻟﺸﺒﻜﺔ ‪ DBGrid‬ﺒﻴﺎﻨﺎﺕ ﺍﻟﺠﺩﻭل ﺍﻟﻤﺭﺘﺒﻁ ﻤﻌﻪ ﺤﻴﺙ ﺃﻋﻤﺩﺓ ﻫﺫﺍ ﺍﻟﺠﺩﻭل ﻫﻲ ﺃﺴﻤﺎﺀ ﺍﻟﺤﻘﻭل‬
‫ﻭﺘﻜﻭﻥ ﻅﺎﻫﺭﺓ ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻷﻭل ﻭ ﺴﻁﻭﺭ ﻫﺫﻩ ﺍﻟﺠﺩﻭل ﻫﻲ ﺍﻟﺴﺠﻼﺕ ﻭﻴﻭﺠﺩ ﺴﻬﻡ ﺼﻐﻴﺭ ﻴﺩل ﻋﻠﻰ ﺍﻟﺴﺠل‬
‫ﺍﻷﺯﺭﻕ ‪.‬‬
‫ﺒﺎﻟﻠﻭﻥ ﺍﳊﻘﻮﻝ‬
‫ﻼ ﺃﲰﺎﺀ‬ ‫ﺍﻟﺤﺎﻟﻲ‪،‬ﻜﻤﺎ ﺃﻥ ﺍﻟﺤﻘل ﺍﻟﺤﺎﻟﻲ ﻴﻜﻭﻥ ﻤﻔﻌ ﹰ‬

‫ﻣﺆﺷﺮ إﻟﻰ اﻟﺴﺠﻞ اﻟﺤﺎﻟﻲ‬

‫اﻟﺴﺠﻞ اﻟﺤﺎﻟﻲ‬

‫‪79‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬

‫ﻴﻤﻜﻥ ﺃﻥ ﻨﻘﻭﻡ ﻨﺤﻥ ﺒﻭﻀﻊ ﺍﻟﻌﻨﺎﺼﺭ ﻋﻠﻰ ﻨﻤﻭﺫﺝ ﻓﺎﺭﻍ ﻟﻠﺤﺼﻭل ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺴﺎﺒﻕ ﺒﺩﻭﻥ ﺍﺴﺘﺨﺩﺍﻡ ﻤﻌﺎﻟﺞ ﺍﻷﺸﻜﺎل‪.‬‬
‫ﺴﻨﺸﺭﺡ ﺍﻵﻥ ﻜل ﻋﻨﺼﺭ ﻤﻥ ﻫﺫﻩ ﺍﻟﻌﻨﺎﺼﺭ ﻋﻠﻰ ﺤﺩﻯ ‪:‬‬
‫ﺍﻟﻌﻨﺼﺭ ‪: Table‬‬
‫ﻴﺴﺘﺨﺩﻡ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻟﻠﺭﺒﻁ ﺒﻴﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻭﻫﻭ ﻋﻨﺼﺭ ﻤﻥ ﻤﺠﻤﻭﻋﺔ ﻋﻨﺎﺼﺭ ﺘﺩﻋﻰ ‪ DataSet‬ﻭﻫﻲ‬
‫ﻋﺒﺎﺭﺓ ﻋﻥ ﻋﻨﺎﺼﺭ ﻟﻬﺎ ﺍﻟﻘﺩﺭﺓ ﻋﻠﻰ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻤﺤﺭﻙ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻟﻠﻭﺼﻭل ﻟﻠﺠﺩﺍﻭل ﻭﻤﻥ ﻫﺫﻩ ﺍﻟﻌﻨﺎﺼﺭ ‪.‬‬
‫‪Table, Query, AdoTable, AdoQuery,‬‬
‫ﻓﻲ ﻤﺜﺎﻟﻨﺎ ﻴﺤﺘﻭﻱ ﺍﻟﻨﻤﻭﺫﺝ ﻋﻠﻰ ﻋﻨﺼﺭ ﻭﺍﺤﺩ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Table‬ﻭﻗﺩ ﺭﺒﻁﻪ ﻤﻌﺎﻟﺞ ﺍﻟﻨﻤﺎﺫﺝ ﻤﻊ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻋﺘﻤﺎﺩﹰﺍ‬
‫ﻋﻠﻰ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻤﻼﺤﻅﺎﺕ‬ ‫ﺍﻟﻘﻴﻤﺔ‬ ‫ﺍﻟﺨﺎﺼﺔ‬
‫ﺍﻟﻘﻴﻤﺔ ‪ DBDEMOS‬ﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻥ ﺍﺴﻡ ﻤﻌﺭﻑ ﻤﺴﺒﻘﹰﺎ ﻴﺸﻴﺭ ﺇﻟﻰ ﻤﻜﺎﻥ‬ ‫‪DBDEMOS DataBaseName‬‬
‫ﺘﻭﺍﺠﺩ‬
‫) ﻤﺴﺎﺭ ( ﺍﻟﺠﺩﺍﻭل ) ﻨﺴﺘﻁﻴﻊ ﺃﻥ ﻨﻜﺘﺏ ﻤﺴﺎﺭ ﻓﻬﺭﺱ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ‬
‫ﻻ ﻤﻨﻬﺎ‬
‫ﺒﺩ ﹰ‬
‫ﺍﺴﻡ ﺍﻟﺠﺩﻭل ﺍﻟﺫﻱ ﺴﻴﺭﺘﺒﻁ ﻤﻊ ﺍﻟﻌﻨﺼﺭ‬ ‫‪country.db‬‬ ‫‪TableName‬‬
‫ﺍﺴﻡ ﺍﻟﻌﻨﺼﺭ ) ﻴﻤﻜﻥ ﺇﻋﻁﺎﺀ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﺍﺴﻡ ﻜﺄﻱ ﻋﻨﺼﺭ ﺁﺨﺭ ﻓﻲ ﺩﻟﻔﻲ‬ ‫‪Table1‬‬ ‫‪Name‬‬
‫(‬
‫ﺃﻋﻁ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻟﻬﺫﻩ ﺍﻟﺨﺎﺼﺔ ﻟﺘﺴﺘﻁﻴﻊ ﻤﺸﺎﻫﺩﺓ ﺍﻟﺠﺩﻭل ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ‬ ‫‪False‬‬ ‫‪Active‬‬

‫ﺍﻟﻌﻨﺼﺭ ‪: DataSource‬‬
‫ﻴﺭﺘﺒﻁ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻤﻊ ﺍﻟﻌﻨﺼﺭ ‪ Table‬ﻭﻴﺴﺘﺨﺩﻡ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻟﻠﺭﺒﻁ ﺒﻴﻥ ﻋﻨﺎﺼﺭ ﺍﻟﻭﺼﻭل ‪ DataSet‬ﻭﻋﻨﺎﺼﺭ‬
‫ﺍﻟﺘﺤﻜﻡ ﺒﺎﻟﻤﻌﻁﻴﺎﺕ ﻭﻟﻪ ﺍﻟﺨﺼﺎﺌﺽ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻤﻼﺤﻅﺎﺕ‬ ‫ﺍﻟﻘﻴﻤﺔ‬ ‫ﺍﻟﺨﺎﺼﺔ‬
‫ﺘﺠﻌل ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻓﻲ ﻭﻀﻊ ﺍﻟﺘﺤﺭﻴﺭ ) ﺃﻤﻜﺎﻨﻴﺔ ﺍﻟﺘﻌﺩﻴل ( ﺃﻤﺎ‬ ‫‪True‬‬ ‫‪AutoEdit‬‬
‫ﺇﺫﺍ ﺃﺭﺩﻨﺎ ﺍﺴﺘﻌﺭﺍﺽ ) ﻗﺭﺍﺀﺓ ﺩﻭﻥ ﺘﻐﻴﻴﺭ ( ﺍﻟﻤﻌﻁﻴﺎﺕ ﻓﻘﻁ ﻓﻨﻌﻁﻲ ﻫﺫﻩ‬
‫ﺍﻟﺨﺎﺼﺔ ﺍﻟﻘﻴﻤﺔ ‪False‬‬
‫ﺘﺤﺩﺩ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﺴﻡ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺫﻱ ﺴﻴﺭﺘﺒﻁ ﻤﻌﻪ ﺍﻟـ ‪Datasource‬‬ ‫‪Table1‬‬ ‫‪Dataset‬‬
‫ﻟﻠﺤﺼﻭل ﻋﻠﻰ ﺍﻟﻤﻌﻁﻴﺎﺕ ‪.‬‬
‫ﺍﺴﻡ ﺍﻟﻌﻨﺼﺭ ) ﻴﻤﻜﻥ ﺇﻋﻁﺎﺀ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﺍﺴﻡ ﻜﺄﻱ ﻋﻨﺼﺭ ﺁﺨﺭ ﻓﻲ ﺩﻟﻔﻲ‬ ‫‪Datasource1‬‬ ‫‪Name‬‬
‫‪80‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫(‬

‫ﻋﻨﺼﺭ ﺍﻟﺘﺤﻜﻡ ﺒﺎﻟﻤﻌﻁﻴﺎﺕ ) ‪: ( DBGrid‬‬

‫ﻴﺴﺘﺨﺩﻡ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻟﻌﺭﺽ ﻭﺘﺤﺭﻴﺭ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻭﻴﺭﺘﺒﻁ ﻤﻊ ﺍﻟﻌﻨﺼﺭ ‪ Datasource‬ﻟﻴﺤﺼل ﻤﻨﻪ ﻋﻠﻰ ﺃﺴﻤﺎﺀ ﺍﻟﺤﻘﻭل‬
‫ﻭﻗﻴﻡ ﺍﻟﺠﺩﻭل ﻭﺃﻋﻁﺎﻩ ﻤﻌﺎﻟﺞ ﺍﻟﻨﻤﺎﺫﺝ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻤﻼﺤﻅﺎﺕ‬ ‫ﺍﻟﻘﻴﻤﺔ‬ ‫ﺍﻟﺨﺎﺼﺔ‬
‫ﺘﺤﺩﺩ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺫﻱ ﺴﻴﺯﻭﺩ ‪ DBGrid‬ﺒﺎﻟﻤﻌﻁﻴﺎﺕ‬ ‫‪Datasource1‬‬ ‫‪Datasource‬‬
‫ﺍﺴﻡ ﺍﻟﻌﻨﺼﺭ‬ ‫‪Dbgrid1‬‬ ‫‪Name‬‬
‫ﻋﻨﺼﺭ ﺍﻟﺘﺤﻜﻡ ‪: DBNavigator‬‬
‫ﻴﺤﻭﻱ ﻫﺫﻩ ﺍﻟﻌﻨﺼﺭ ﺍﻟﻌﺩﻴﺩ ﻤﻥ ﺍﻷﺯﺭﺍﺭ ﻤﻬﻤﺘﻬﺎ ﺘﺤﺭﻴﻙ ﻤﺅﺸﺭ ﺍﻟﺴﺠل ﻭﺍﻟﻘﻴﺎﻡ ﺒﺄﻋﻤﺎل ﺍﻹﻀﺎﻓﺔ ﻭﺍﻟﺤﺫﻑ ﻭﺍﻟﺘﺭﺍﺠﻊ ﻋﻥ‬
‫ﺍﻟﺘﻌﺩﻴل ﻭﻴﺭﺘﺒﻁ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻤﻊ ﺍﻟـ ‪ Datasource‬ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﺨﺎﺼﺔ ‪ ، DataSource‬ﺍﻋﻁ ﺍﻟﻘﻴﻤﺔ ‪True‬ﻟﻠﺨﺎﺼﺔ‬
‫‪ ShowHint‬ﺍﻟﺘﺎﺒﻌﺔ ﻟﻬﺫﺍ ﺍﻟﻌﻨﺼﺭ ‪.‬‬
‫ﻴﻀﻴﻑ ﻤﻌﺎﻟﺞ ﺍﻟﻨﻤﺎﺫﺝ ﺃﻴﻀ ﹰﺎ ﺴﻁﺭ ﺒﺭﻤﺠﻲ ﻭﺍﺤﺩ ﻓﻲ ﺤﺩﺙ ﺇﻨﺸﺎﺀ ﺍﻟﻨﻤﻭﺫﺝ ﻫﻭ ‪ Table1.Open‬ﻟﻔﺘﺢ ﺍﻟﺠﺩﻭل ﻭﺇﻅﻬﺎﺭ‬
‫ﺴﺠﻼﺘﻪ ﻭﻴﻤﻜﻥ ﺍﻻﺴﺘﻌﺎﻀﺔ ﻋﻥ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺈﻋﻁﺎﺀ ﺍﻟﺨﺎﺼﺔ ‪ Active‬ﻟﻠﻌﻨﺼﺭ ‪ Table‬ﺍﻟﻘﻴﻤﺔ ‪. True‬‬
‫ﻤﺤﺭﻙ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ) ‪: ( Database Engine‬‬
‫ﻤﺤﺭﻙ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻴﺤﺩﺩ ﺃﺴﻠﻭﺏ ﺘﻌﺎﻤل ﺍﻟﺒﺭﻨﺎﻤﺞ ﻤﻊ ﺍﻟﻘﺎﻋﺩﺓ ﻭﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻥ ﻤﺠﻤﻭﻋﺔ ﻤﻜﺘﺒﺎﺕ ﺠﺎﻫﺯﺓ ﺘﺭﺒﻁ ﺒﻴﻥ‬
‫ﻋﻨﺎﺼﺭ ﺍﻟﺩﻟﻔﻲ ﻭﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻭﻤﻥ ﺃﻫﻡ ﺍﻟﻤﺤﺭﻜﺎﺕ ﻓﻲ ﺩﻟﻔﻲ ‪:‬‬
‫‪ 1‬ـ ‪: Borland Database Engine : BDE‬‬
‫ﻴﺘﻌﺎﻤل ﻫﺫﺍ ﺍﻟﻤﺤﺭﻙ ﻤﻊ ﻋﻨﺎﺼﺭ ﺍﻟﻭﺼﻭل ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﺼﻔﺤﺔ ‪ Bde‬ﻭﻴﺘﻌﺎﻤل ﻤﻊ ﻗﻭﺍﻋﺩ ﻤﻌﻁﻴﺎﺕ ﻤﻥ ﺍﻟﻨﻭﻉ‬
‫‪ Pardox‬ﺃﻭ ‪ Dbase‬ﻭﻏﻴﺭﻫﺎ ﻜﺜﻴﺭ ‪.‬‬
‫‪ 2‬ـ ‪: Microsoft ActiveX Data Objects : ADO‬‬
‫ﻴﺘﻌﺎﻤل ﻫﺫﺍ ﺍﻟﻤﺤﺭﻙ ﻋﻠﻰ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﺼﻔﺤﺔ ‪ Ado‬ﻭﻴﺴﺘﺨﺩﻡ ﻤﻊ ﻗﻭﺍﻋﺩ ﻤﻌﻁﻴﺎﺕ ﻤﺜل ‪ Access‬ﺃﻭ‬
‫‪ SQL SERVER‬ﺃﻭ ‪. Oracle‬‬
‫‪ 3‬ـ ‪:Interbase‬‬
‫ﻴﺘﻌﺎﻤل ﻫﺫﺍ ﺍﻟﻤﺤﺭﻙ ﻋﻠﻰ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﺼﻔﺤﺔ ‪ Interbase Express‬ﻭﻴﺴﺘﺨﺩﻡ ﻤﻊ ﻗﻭﺍﻋﺩ ﻤﻌﻁﻴﺎﺕ‬
‫‪ Interbase‬ﺍﻟﺘﻲ ﻴﻤﻜﻥ ﺘﺤﻤﻴﻠﻬﺎ ﻤﻥ ﺍﻟﻘﺭﺹ ﺍﻟﺫﻱ ﺘﻭﺠﺩ ﻋﻠﻴﻪ ﺩﻟﻔﻲ ‪.‬‬
‫ﻤﺜﺎل ‪ : 2‬ﺒﻨﺎﺀ ﻨﻤﻭﺫﺝ ﻹﺩﺨﺎل ﺍﻟﻤﻌﻁﻴﺎﺕ ‪:‬‬
‫ﺃﻋﺩ ﺨﻁﻭﺍﺕ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﺤﺘﻰ ﺘﺼل ﺇﻟﻰ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﻲ ﺘﻁﺎﻟﺒﻙ ﺒﻁﺭﻴﻘﺔ ﻋﺭﺽ ﺍﻟﻤﻌﻁﻴﺎﺕ ) ﺍﺨﺘﺭ ﻤﻨﻬﺎ ‪( Vertical‬‬
‫ﻭﺴﺘﻅﻬﺭ ﺒﻌﺩﻫﺎ ﻨﺎﻓﺫﺓ ﺘﺴﺄﻟﻙ ﻋﻥ ﻁﺭﻴﻘﺔ ﻋﺭﺽ ﻋﻨﺎﻭﻴﻥ ﺍﻟﺤﻘﻭل ) ﺍﺨﺘﺭ ﻤﻨﻬﺎ ‪ ( Left‬ﺃﻀﻐﻁ ﻋﻠﻰ ‪ Next‬ﺜﻡ ‪Finish‬‬
‫ﻟﻴﻅﻬﺭ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺘﺎﻟﻲ ‪:‬‬

‫‪81‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻻ ﻤﻥ ﺍﻟﺠﺩﻭل ﻭﺘﻅﻬﺭ‬
‫ﻻﺤﻅ ﻅﻬﻭﺭ ﺤﻘﻭل ﺍﻟﻤﻌﻁﻴﺎﺕ ﺒﺩ ﹰ‬
‫ﻫﺫﺍ ﺍﻟﺤﻘﻭل ﻓﻲ ﺍﻟﻌﻨﺎﺼﺭ ‪ Dbedit‬ﻭﺍﻟﺘﻲ ﺘﺭﺘﺒﻁ ﻤﻊ‬
‫ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻋﺒﺭ ﺍﻟﺨﺎﺼﺔ ‪Datasource‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﺴﺘﺨﺩﻡ ‪ DBNavegator‬ﻟﻠﺘﻨﻘل ﺒﻴﻥ‬
‫ﺍﻟﺤﻘﻭل ) ﺍﻟﺴﺠل ﺍﻟﺤﺎﻟﻲ ﻫﻭ ﺍﻟﺤﻘل ﺍﻟﺫﻱ ﺘﻅﻬﺭ ﻗﻴﻤﻪ‬
‫ﺩﺍﺨل ﺍﻟﺤﻘﻭل (‬

‫ﺃﻀﻑ ﻋﻨﺼﺭ ‪ DBGrid‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪ Datacontrole‬ﻭﺃﻋﻁﻪ ﺍﻟﺨﺎﺼﺔ ‪ Datasource‬ﺍﻟﻘﻴﻤﺔ ‪DataSource1‬‬

‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺤﺎﻭل ﺍﻟﺘﻨﻘل ﺒﻴﻥ ﺍﻟﺴﺠﻼﺕ ﻓﻲ ‪ DBGrid‬ﺒﺎﻟﻔﺄﺭﺓ ﻭﻻﺤﻅ ﻜﻴﻑ ﺘﺘﻐﻴﺭ ﻗﻴﻡ ﺍﻟﺤﻘﻭل ﻓﻲ ‪ DBEdit‬ﺘﺒﻌﹰﺎ‬
‫ﻟﺘﻐﻴﺭ ﺍﻟﺴﺠل ﺍﻟﺤﺎﻟﻲ ‪.‬‬

‫ﻤﺜﺎل ‪:3‬ﺒﻨﺎﺀ ﻨﻤﻭﺫﺝ ﻤﻥ ﺍﻟﻨﻭﻉ ﺍﻟﺭﺌﻴﺴﻲ ﺘﻔﺼﻴﻠﻲ ) ‪:( Master \ Detail Form‬‬
‫ﻭﺠﺩﻨﺎ ﺴﺎﺒﻘﹰﺎ ﻓﻲ ﻤﺜﺎل ﺍﻟﻤﻜﺘﺒﺔ ﻜﻴﻑ ﻴﻤﻜﻥ ﻟﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﺠﺩﺍﻭل ﺃﻥ ﺘﺭﺘﺒﻁ ﻤﻊ ﺒﻌﻀﻬﺎ ﺍﻟﺒﻌﺽ ﻟﺘﺸﻜل ﻗﺎﻋﺩﺓ ﻤﻌﻁﻴﺎﺕ‪،‬‬
‫ﻜﻤﺎ ﻭﺠﺩﻨﺎ ‪:‬ﻜﻴﻑ ﺃﻥ ﺠﺩﻭل ﺍﻟﻤﺅﻟﻔﻴﻥ ﻫﻭ ﺠﺩﻭل ﺭﺌﻴﺴﻲ ﺒﻴﻨﻤﺎ ﺠﺩﻭل ﺍﻟﻜﺘﺏ ﻫﻭ ﺠﺩﻭل ﺜﺎﻨﻭﻱ ﻭﻗﻠﻨﺎ ﺃﻥ ﻫﺫﻩ ﻫﻲ ﻋﻼﻗـﺔ‬
‫ﺭﺃﺱ ﺒﺄﻁﺭﺍﻑ ﺃﻭ ﻭﺍﺤﺩ ﺇﻟﻰ ﻤﺠﻤﻭﻋﺔ ﻟﻨﻔﺘﺭﺽ ﺍﻵﻥ ﺃﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺒﺤﺎﺠﺔ ﻟﻤﻌﺭﻓﺔ ﺠﻤﻴﻊ ﺍﻟﻜﺘﺏ ﺍﻟﺘﻲ ﻜﺘﺒﺕ ﻤـﻥ ﻗﺒـل‬
‫ﻤﺅﻟﻑ ﻤﺎ‪ ،‬ﺘﺩﻋﻰ ﺍﻟﻨﻤﺎﺫﺝ ﺍﻟﺘﻲ ﺘﻘﺩﻡ ﻫﺫﻩ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﺒﺎﻟﻨﻤﺎﺫﺝ ﺫﺍﺕ ﺍﻟﻨﻭﻉ ﺍﻟﺭﺌﻴﺴﻲ ﺘﻔﺼﻴﻠﻲ‪.‬‬
‫ﺴﻨﺴﺘﺨﺩﻡ ﻓﻲ ﻤﺜﺎﻟﻨﺎ ﺍﻵﻥ ﻤﻌﺎﻟﺞ ﺍﻟﻨﻤﺎﺫﺝ ﻹﻨﺸﺎﺀ ﻨﻤﺎﺫﺝ ﻤﻥ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻭﺴﻨﻌﺘﻤﺩ ﻋﻠﻰ ﺍﻟﺠﺩﻭل ﺍﻟﺭﺌﻴﺴﻲ ‪Customer.db‬‬
‫ﻭﺍﻟﺠﺩﻭل ﺍﻟﺘﻔﺼﻴﻠﻲ ‪ Orders.Db‬ﻭﻗﺒل ﺍﻟﺒﺩﺀ ﺴﺄﺸﺭﺡ ﻜل ﻤﻥ ﺍﻟﺠﺩﻭﻟﻴﻥ ‪.‬‬
‫ﺠﺩﻭل ﺍﻟﺯﺒﺎﺌﻥ ‪ : Customer.db :‬ﻴﺤﻭﻱ ﻤﻌﻠﻭﻤﺎﺕ ﻋﻥ ﺍﻟﺯﺒﺎﺌﻥ ) ﺭﻗﻡ ﺍﻟﺯﺒﻭﻥ ‪ ،‬ﺍﻷﺴـﻡ ‪ ،‬ﺍﻟﻌﻨـﻭﺍﻥ ‪ ،‬ﺍﻟﻤﺩﻴﻨـﺔ ‪،‬‬
‫ﺍﻟﻬﺎﺘﻑ ‪ ، ( ......‬ﺍﻟﻤﻔﺘﺎﺡ ﺍﻟﺭﺌﻴﺴﻲ ﻓﻴﻪ ﻫﻭ ﺭﻗﻡ ﺍﻟﺯﺒﻭﻥ‪.‬‬
‫ﺠﺩﻭل ﺍﻟﻁﻠﺒﺎﺕ ‪ : Orders.db‬ﻴﺤﻭﻱ ﻤﻌﻠﻭﻤﺎﺕ ﻋﻥ ﻁﻠﺒﺎﺕ ﺍﻟﺯﺒﺎﺌﻥ ) ﺭﻗﻡ ﺍﻟﻁﻠﺒﻴﺔ ‪ ،‬ﺭﻗﻡ ﺍﻟﺯﺒﻭﻥ ‪ ،‬ﺘﺎﺭﻴﺦ ﺍﻟﺘـﺴﻠﻴﻡ ‪،‬‬
‫ﻁﺭﻴﻘﺔ ﺍﻟﺘﺴﻠﻴﻡ ‪( ....‬‬
‫ﻤﻥ ﺍﻟﻭﺍﻀﺢ ﺃﻥ ﺍﻟﻤﻔﺘﺎﺡ ﺍﻟﺭﺌﻴﺴﻲ ﻟﻬﺫﺍ ﺍﻟﺠﺩﻭل ﻫﻭ ﺭﻗﻡ ﺍﻟﻁﻠﺒﻴﺔ ‪ ،‬ﻜﻤﺎ ﺃﻥ ﻫﻨﺎﻙ ﻤﻔﺘﺎﺡ ﺜﺎﻨﻭﻱ ﻫﻭ ﺭﻗﻡ ﺍﻟﺯﺒﻭﻥ ( ‪.‬‬
‫ﺴﻨﻨﺸﺊ ﺍﻵﻥ ﻨﻤﻭﺫﺠﹰﺎ ﻴﻅﻬﺭ ﻓﻴﻪ ﺠﺩﻭﻟﻲ ﺍﻟﺯﺒﺎﺌﻥ ﻭﺍﻟﻁﻠﺒﻴﺎﺕ ﻭﻟﻜﻥ ﺍﻟﺴﺠﻼﺕ ﺍﻟﻅﺎﻫﺭﺓ ﻓﻲ ﺴﺠل ﺍﻟﻁﻠﺒﻴﺎﺕ ﻫﻲ ﺍﻟﺴﺠﻼﺕ‬
‫ﺍﻟﺘﺎﺒﻌﺔ ﻟﻠﺯﺒﻭﻥ ﺍﻟﺤﺎﻟﻲ ﻓﻲ ﺠﺩﻭل ﺍﻟﺯﺒﺎﺌﻥ ‪.‬‬
‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﺍﹰ‪ ،‬ﺃﻏﻠﻕ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻻﻓﺘﺭﺍﻀﻲ ‪ ،‬ﺍﺨﺘﺭ ﺍﻷﻤﺭ ‪DatabaseÆ Form Wizard‬‬
‫‪82‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻤﻥ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻷﻭﻟﻰ ﻟﻠﻤﻌﺎﻟﺞ ﺤﺩﺩ ﺍﻟﺨﻴﺎﺭ ‪ Create Master Detail Form‬ﻤﻥ ﺍﻟﻘﺴﻡ ‪ Form Option‬ﻭﺍﻀﻐﻁ ﻋﻠـﻰ‬
‫‪Next‬‬
‫ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺜﺎﻨﻴﺔ ﺘﻁﺎﻟﺒﻙ ﺒﺈﺩﺨﺎل ﺍﻟﺠﺩﻭل ﺍﻟﺭﺌﻴﺴﻲ ﺤﺩﺩ ‪ DBDEMOS‬ﻓﻲ ‪ Driver or alias name‬ﻭﺍﺨﺘﺭ ﺍﻟﺠـﺩﻭل‬
‫‪ Customer.db‬ﻭﻤﻥ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﻲ ﺘﻠﻴﻬﺎ ﺤﺩﺩ ﺠﻤﻴﻊ ﺤﻘﻭل ﻫﺫﺍ ﺍﻟﺠﺩﻭل ‪ ،‬ﻭﻓﻲ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺤـﺩﺩ ﻁﺭﻴﻘـﺔ ﺍﻟﻌـﺭﺽ‬
‫ﺒﺠﺩﻭل ‪. in a grid‬‬
‫ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺘﻁﺎﻟﺒﻙ ﺒﺘﺤﺩﻴﺩ ﺍﻟﺠﺩﻭل ﺍﻟﺘﻔﺼﻴﻠﻲ ﺃﺨﺘﺭ ‪ Orders‬ﻤﻥ ‪ DBDEMOS‬ﻭﺍﺨﺘﺭ ﺒﻌـﺩﻫﺎ ﺠﻤﻴـﻊ ﺍﻟﺤﻘـﻭل‬
‫ﻭﻁﺭﻴﻘﺔ ﺍﻟﻌﺭﺽ ﺠﺩﻭل‬
‫ﺘﻅﻬﺭ ﺒﻌﺩﻫﺎ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻤﺠﺎﻭﺭﺓ ) ﺍﺨﺘﺭ ﻤﻥ ﺍﻟﻘﺴﻡ‬
‫‪Available Indexes‬ﺍﻟﻘﻴﻤﺔ ‪CustNo‬‬
‫ﻭﺍﺨﺘـﺭ ﻤـﻥ ﺍﻟﻼﺌﺤـﺔ ‪ Master Fields‬ﺍﻟﻘﻴﻤـﺔ‬
‫‪CustNo‬‬
‫ﻭﻤﻥ ﺍﻟﻼﺌﺤﺔ ‪ Detail Fields‬ﺍﻟﻘﻴﻤﺔ ‪CustNo‬‬
‫ﺇﻀﻐﻁ ﺒﻌﺩﻫﺎ ﻋﻠﻰ ‪ Add‬ﺜﻡ ﻋﻠﻰ ‪ Next‬ﺜﻡ ﻋﻠـﻰ‬
‫‪ Next‬ﻤﺭﺓ ﺃﺨﺭﻯ ‪.‬ﺴﻴﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺍﻟﻨﻤﻭﺫﺝ ﺭﺌﻴﺴﻲ‬
‫ﺘﻔﺼﻴﻠﻲ ‪:‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺘﻨﻘل ﺒﻴﻥ ﺤﻘﻭل ﺍﻟﺠﺩﻭل ‪ Master‬ﻭﻻ‬
‫ﺤﻅ ﺍﻟﺘﻐﻴﺭﺍﺕ ﻋﻠﻰ ﺍﻟﺠﺩﻭل ‪... Detail‬‬

‫ﻟﻘﺩ ﺃﻀﺎﻑ ﻤﻌﺎﻟﺞ ﺍﻟﻨﻤﺎﺫﺝ ﻫﻨﺎ ﻋﻨﺼﺭﻱ ‪ Table‬ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﻋﻨﺼﺭﻱ ‪ Datasource‬ﻭﻗﺎﻡ ﺒـﺎﻟﺭﺒﻁ ﺒﻴﻨﻬﻤـﺎ ﻓـﻲ‬
‫ﺍﻟﺤﻘﻭل ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻓﻲ ﺍﻟﻌﻨﺼﺭ ‪Tabel2‬‬
‫ﺍﻟﺸﺭﺡ‬ ‫ﺍﻟﻘﻴﻤﺔ‬ ‫ﺍﻟﺨﺎﺼﺔ‬
‫ﻴﻌﺭﻑ ﻋﻨﺼﺭ ‪ DataSource‬ﺍﻟﻤﺭﺘﺒﻁ ﻤﻊ ﺍﻟﺠﺩﻭل ﺍﻟﺭﺌﻴﺴﻲ‬ ‫‪Datasource1‬‬ ‫‪MasterSource‬‬
‫ﻴﺤﺩﺩ ﺍﻟﺤﻘل ﺍﻟﺫﻱ ﺴﻴﻘﻭﻡ ﺒﺘﺭﺘﻴﺏ ﻭﻓﻬﺭﺴﺔ ﺍﻟﺴﺠﻼﺕ ﻓﻲ ﺍﻟﺠﺩﻭل‬ ‫‪CustNo‬‬ ‫‪IndexName‬‬

‫ﺒﻌﺩ ﺃﻥ ﺘﻌﻠﻤﻨﺎ ﻜﻴﻔﻴﺔ ﺘﻨﻔﻴﺫ ﺘﻁﺒﻴﻘﺎﺕ ﻗﻭﺍﻋﺩ ﺒﺎﺴﺘﺨﺩﺍﻡ ﻤﻌﺎﻟﺞ ﺍﻟﻨﻤﺎﺫﺝ ﺴﻨﻌﻴﺩ ﺍﻷﻤﺜﻠﺔ ﺍﻟﺴﺎﺒﻘﺔ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻌﻨﺎﺼﺭ ﻤﺒﺎﺸﺭﺓ ‪:‬‬
‫ﻤﺜﺎل ‪: 1‬‬
‫ﺴﻨﻘﻭﻡ ﺒﻜﺘﺎﺒﺔ ﺒﺭﻨﺎﻤﺞ ﻴﻌﺭﺽ ﺍﻟﺠﺩﻭل ‪ Country.db‬ﺍﻟﻤﻭﺠﻭﺩ ﻀﻤﻥ ﺍﻟﻘﺎﻋﺩﺓ ‪DBDemos‬‬
‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ 1‬ـ ﺍﻟﻌﻨﺼﺭ ‪ Table‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪BDE‬‬
‫‪ _ 2‬ﺍﻟﻌﻨﺼﺭ ‪ DataSource‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪. Data Access‬‬

‫‪83‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ 3‬ـ ﺍﻟﻌﻨﺼﺭ ‪ DBGrid‬ﻭ ‪ DBNavigator‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪. Data Control‬‬
‫ﺃﻋﻁ ﺍﻟﻌﻨﺼﺭ ‪ Table‬ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻤﻼﺤﻅﺎﺕ‬ ‫ﺍﻟﻘﻴﻤﺔ‬ ‫ﺍﻟﺨﺎﺼﺔ‬
‫ﺍﻟﻘﻴﻤﺔ ‪ DBDEMOS‬ﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻥ ﺍﺴﻡ ﻤﻌﺭﻑ ﻤﺴﺒﻘﹰﺎ ﻴﺸﻴﺭ ﺇﻟﻰ‬ ‫‪DBDEMOS DataBaseName‬‬
‫ﻤﻜﺎﻥ ﺘﻭﺍﺠﺩ‬
‫) ﻤﺴﺎﺭ ( ﺍﻟﺠﺩﺍﻭل ) ﻨﺴﺘﻁﻴﻊ ﺃﻥ ﻨﻜﺘﺏ ﻤﺴﺎﺭ ﻓﻬﺭﺱ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ‬
‫ﻻ ﻤﻨﻬﺎ‬
‫ﺒﺩ ﹰ‬
‫ﺍﺴﻡ ﺍﻟﺠﺩﻭل ﺍﻟﺫﻱ ﺴﻴﺭﺘﺒﻁ ﻤﻊ ﺍﻟﻌﻨﺼﺭ‬ ‫‪country.db‬‬ ‫‪TableName‬‬
‫ﺃﻋﻁ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻟﻬﺫﻩ ﺍﻟﺨﺎﺼﺔ ﻟﺘﺴﺘﻁﻴﻊ ﻤﺸﺎﻫﺩﺓ ﺍﻟﺠﺩﻭل ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ‬ ‫‪True‬‬ ‫‪Active‬‬
‫ﺃﻋﻁ ﺍﻟﻌﻨﺼﺭ ‪ DataSource‬ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻤﻼﺤﻅﺎﺕ‬ ‫ﺍﻟﻘﻴﻤﺔ‬ ‫ﺍﻟﺨﺎﺼﺔ‬
‫ﺘﺠﻌل ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻓﻲ ﻭﻀﻊ ﺍﻟﺘﺤﺭﻴﺭ ) ﺃﻤﻜﺎﻨﻴﺔ ﺍﻟﺘﻌﺩﻴل ( ﺃﻤﺎ‬ ‫‪True‬‬ ‫‪AutoEdit‬‬
‫ﺇﺫﺍ ﺃﺭﺩﻨﺎ ﺍﺴﺘﻌﺭﺍﺽ ) ﻗﺭﺍﺀﺓ ﺩﻭﻥ ﺘﻐﻴﻴﺭ ( ﺍﻟﻤﻌﻁﻴﺎﺕ ﻓﻘﻁ ﻓﻨﻌﻁﻲ ﻫﺫﻩ‬
‫ﺍﻟﺨﺎﺼﺔ ﺍﻟﻘﻴﻤﺔ ‪False‬‬
‫ﺘﺤﺩﺩ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﺴﻡ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺫﻱ ﺴﻴﺭﺘﺒﻁ ﻤﻌﻪ ﺍﻟـ ‪Datasource‬‬ ‫‪Table1‬‬ ‫‪Dataset‬‬
‫ﻟﻠﺤﺼﻭل ﻋﻠﻰ ﺍﻟﻤﻌﻁﻴﺎﺕ ‪.‬‬
‫ﺃﻋﻁ ﺍﻟﻌﻨﺼﺭ ‪ DBGrid‬ﻭﺍﻟﻌﻨﺼﺭ ‪ DBNavigator‬ﺍﻟﺨﺎﺼﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻤﻼﺤﻅﺎﺕ‬ ‫ﺍﻟﻘﻴﻤﺔ‬ ‫ﺍﻟﺨﺎﺼﺔ‬
‫ﺘﺤﺩﺩ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺫﻱ ﺴﻴﺯﻭﺩ ‪ DBGrid‬ﺒﺎﻟﻤﻌﻁﻴﺎﺕ‬ ‫‪Datasource1‬‬ ‫‪Datasource‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪.‬‬
‫ﻤﺜﺎل ‪: 2‬‬
‫ﺇﻨﺸﺎﺀ ‪ Master Detail Form‬ﺒﺩﻭﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﻌﺎﻟﺞ ‪:‬‬
‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﻋﻨﺼﺭﻱ ‪ Table‬ﻭﻋﻨﺼﺭﻱ ‪ DataSource‬ﻭﻋﻨﺼﺭﻱ ‪ DBGrid‬ﻭﻋﻨﺼﺭ‬
‫‪. DBNavigator‬‬
‫‪ 1‬ـ ﺭﺒﻁ ﺍﻟﺠﺩﻭل ﺍﻟﺭﺌﻴﺴﻲ ) ‪: ( Master‬‬
‫ﺃﻋﻁ ﺍﻟﻌﻨﺼﺭ ‪ Table1‬ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻤﻼﺤﻅﺎﺕ‬ ‫ﺍﻟﻘﻴﻤﺔ‬ ‫ﺍﻟﺨﺎﺼﺔ‬
‫ﺍﻟﻘﻴﻤﺔ ‪ DBDEMOS‬ﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻥ ﺍﺴﻡ ﻤﻌﺭﻑ ﻤﺴﺒﻘﹰﺎ ﻴﺸﻴﺭ ﺇﻟﻰ‬ ‫‪DBDEMOS DataBaseName‬‬
‫ﻤﻜﺎﻥ ﺘﻭﺍﺠﺩ‬
‫) ﻤﺴﺎﺭ ( ﺍﻟﺠﺩﺍﻭل ) ﻨﺴﺘﻁﻴﻊ ﺃﻥ ﻨﻜﺘﺏ ﻤﺴﺎﺭ ﻓﻬﺭﺱ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ‬
‫ﻻ ﻤﻨﻬﺎ‬
‫ﺒﺩ ﹰ‬

‫‪84‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ Customers.db‬ﺍﺴﻡ ﺍﻟﺠﺩﻭل ﺍﻟﺫﻱ ﺴﻴﺭﺘﺒﻁ ﻤﻊ ﺍﻟﻌﻨﺼﺭ‬ ‫‪TableName‬‬
‫ﺃﻋﻁ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻟﻬﺫﻩ ﺍﻟﺨﺎﺼﺔ ﻟﺘﺴﺘﻁﻴﻊ ﻤﺸﺎﻫﺩﺓ ﺍﻟﺠﺩﻭل ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ‬ ‫‪True‬‬ ‫‪Active‬‬
‫ﺃﻋﻁ ﺍﻟﻌﻨﺼﺭ ‪ DataSource1‬ﺍﻟﺨﺎﺼﺔ ‪ DataSet‬ﺍﻟﻘﻴﻤﺔ ‪. Table1‬‬
‫ﺃﻋﻁ ﺍﻟﻌﻨﺼﺭﻴﻥ ‪ DBGrid1‬ﻭ ‪ DBNavigator1‬ﺍﻟﺨﺎﺼﺔ ‪ DataSource‬ﺍﻟﻘﻴﻤﺔ ‪. DataSource1‬‬

‫‪ 2‬ـ ﺭﺒﻁ ﺍﻟﺠﺩﻭل ﺍﻟﺘﻔﺼﻴﻠﻲ ‪: Detail‬‬

‫ﺃﻋﻁ ﺍﻟﻌﻨﺼﺭ ‪ Table2‬ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻤﻼﺤﻅﺎﺕ‬ ‫ﺍﻟﻘﻴﻤﺔ‬ ‫ﺍﻟﺨﺎﺼﺔ‬
‫ﺍﻟﻘﻴﻤﺔ ‪ DBDEMOS‬ﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻥ ﺍﺴﻡ ﻤﻌﺭﻑ ﻤﺴﺒﻘﹰﺎ ﻴﺸﻴﺭ ﺇﻟﻰ‬ ‫‪DBDEMOS DataBaseName‬‬
‫ﻤﻜﺎﻥ ﺘﻭﺍﺠﺩ‬
‫) ﻤﺴﺎﺭ ( ﺍﻟﺠﺩﺍﻭل ) ﻨﺴﺘﻁﻴﻊ ﺃﻥ ﻨﻜﺘﺏ ﻤﺴﺎﺭ ﻓﻬﺭﺱ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ‬
‫ﻻ ﻤﻨﻬﺎ‬
‫ﺒﺩ ﹰ‬
‫ﺍﺴﻡ ﺍﻟﺠﺩﻭل ﺍﻟﺫﻱ ﺴﻴﺭﺘﺒﻁ ﻤﻊ ﺍﻟﻌﻨﺼﺭ‬ ‫‪order.db‬‬ ‫‪TableName‬‬
‫ﺃﻋﻁ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻟﻬﺫﻩ ﺍﻟﺨﺎﺼﺔ ﻟﺘﺴﺘﻁﻴﻊ ﻤﺸﺎﻫﺩﺓ ﺍﻟﺠﺩﻭل ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ‬ ‫‪True‬‬ ‫‪Active‬‬
‫ﺃﻋﻁ ﺍﻟﻌﻨﺼﺭ ‪ DataSource2‬ﺍﻟﺨﺎﺼﺔ ‪ DataSet‬ﺍﻟﻘﻴﻤﺔ ‪. Table2‬‬
‫ﺃﻋﻁ ﺍﻟﻌﻨﺼﺭﻴﻥ ‪ DBGrid2‬ﺍﻟﺨﺎﺼﺔ ‪ DataSource‬ﺍﻟﻘﻴﻤﺔ ‪. DataSource2‬‬
‫ﺒﻬﺫﺍ ﻨﻜﻭﻥ ﻗﺩ ﺭﺒﻁﻨﺎ ﺍﻟﻌﻨﺎﺼﺭ ﻤﻊ ﺍﻟﺠﺩﻭل ﻭﻵﻥ ﻋﻠﻴﻨﺎ ﺃﻥ ﻨﻌﻠﻡ ﺍﻟﺠﺩﻭل ‪ Table2‬ﺃﻨﻪ ﺠﺩﻭل ﺘﻔﺼﻴﻠﻲ ﻟﻠﺠﺩﻭل‬
‫‪. Table1‬‬
‫ﺃﻋﻁ ﺍﻟﻌﻨﺼﺭ ‪ Table2‬ﺍﻟﺨﺎﺼﺔ ‪ MasterSource‬ﺍﻟﻘﻴﻤﺔ ‪ Datasouce1‬ﻭ ﺍﻟﺨﺎﺼﺔ ‪ MasterField‬ﺍﻟﻘﻴﻤﺔ‬
‫‪CustNo‬‬

‫‪85‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ﺍﻟﺨﺎﻤﺴﺔ ﻋﺸﺭ‬
‫ﺒﻨﺎﺀ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪:‬‬
‫ﻴﻭﺠﺩ ﺍﻟﻌﺩﻴﺩ ﻤﻥ ﺒﺭﺍﻤﺞ ﺒﻨﺎﺀ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻴﻌﺘﻤﺩ ﺍﻷﻤﺭ ﻋﻠﻰ ﻨﻭﻉ ﺍﻟﻘﺎﻋﺩﺓ ﺍﻟﺘﻲ ﺘﺭﻴﺩ ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﻓﻠﺒﻨﺎﺀ ﻗﺎﻋﺩﺓ ﻤﺤﻠﻴـﺔ‬
‫ﺘﺴﺘﺨﺩﻡ ﺠﺩﺍﻭل ﺒﺎﺭﺩﻭﻜﺱ ) ‪ ( Paradox‬ﻫﻨﺎﻙ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪ Borland Paradox‬ﻭﻟﺒﻨﺎﺀ ﺠـﺩﺍﻭل ﺘـﺴﺘﺨﺩﻡ ‪Oracle‬‬
‫ﻫﻨﺎﻙ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪ Oracle 9i‬ﻭﻫﻜﺫﺍ ﻭﻗﺩ ﺯﻭﺩﺘﻨﺎ ﺩﻟﻔﻲ ﺒﺄﺩﺍﺓ ﺴﻬﻠﺔ ﻹﻨﺸﺎﺀ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﺘﻌﺩﻴل ﺍﻟﺠﺩﺍﻭل ﺒﺩﻭﻥ ﺍﻟﻌـﻭﺩﺓ‬
‫ﺇﻟﻰ ﺘﻠﻙ ﺍﻟﺒﺭﺍﻤﺞ‪ ،‬ﺤﻴﺙ ﻴﻭﺠﺩ ﻀﻤﻥ ﻤﺠﻤﻭﻋﺔ ﺃﺩﻭﺍﺕ ﺩﻟﻔﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪ Database Desktop‬ﺍﻟﺫﻱ ﻴﻤﻜﻥ ﻋﻥ ﻁﺭﻴﻘـﺔ‬
‫ﺘﺼﻤﻴﻡ ﺍﻟﻌﺩﻴﺩ ﻤﻥ ﺃﻨﻭﺍﻉ ﺠﺩﺍﻭل ﺍﻟﺒﻴﺎﻨﺎﺕ ‪.‬‬
‫‪: DataBase Desktop‬‬
‫ﺃﻓﻀل ﻁﺭﻴﻘﺔ ﻟﺘﻌﻠﻡ ﻫﺫﺍ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻫﻲ ﻨﺒﺩﺃ ﺒﻤﺜﺎل ‪:‬‬
‫ﺍﻟﻤﻁﻠﻭﺏ ﺇﻨﺸﺎﺀ ﺠﺩﺍﻭل ﺘﺘﻌﻠﻕ ﺒﺤﺭﻜﺔ ﺍﻟﺭﻜﺎﺏ ﻓﻲ ﺍﻟﻤﻁﺎﺭ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺠﺩﺍﻭل ﺍﻟﺒﺎﺭﺩﻭﻜﺱ ﻭﻫﺫﻩ ﺍﻟﺠﺩﺍﻭل ﻫﻲ ‪:‬‬
‫ﺒﻠﺩ ﺍﻟﻤﻐﺎﺩﺭﺓ‬ ‫ﻨﺹ‬ ‫‪GoFrom‬‬ ‫ﺠﺩﻭل ﺍﻟﻤﺴﺎﻓﺭﻭﻥ ) ‪( Passengers‬‬
‫ﺒﻠﺩ ﺍﻟﻭﺼﻭل‬ ‫ﻨﺹ‬ ‫‪ArriveTo‬‬ ‫ﺍﻟﺸﺭﺡ‬ ‫ﻨﻭﻉ ﺍﻟﺤﻘل‬ ‫ﺍﺴﻡ ﺍﻟﺤﻘل‬
‫ﻭﻗﺕ ﺍﻟﻤﻐﺎﺩﺭﺓ‬ ‫ﺘﺎﺭﻴﺦ ﻭﻭﻗﺕ‬ ‫‪GoTime‬‬ ‫ﺭﻗﻡ ﺍﻟﻤﺴﺎﻓﺭ‬ ‫ﻋﺩﺩ *‬ ‫‪Pno‬‬
‫ﻭﻗﺕ ﺍﻟﻭﺼﻭل‬ ‫ﺘﺎﺭﻴﺦ ﻭﻭﻗﺕ‬ ‫‪ArriveTime‬‬ ‫ﺍﺴﻡ ﺍﻟﻤﺴﺎﻓﺭ‬ ‫ﻨﺹ‬ ‫‪Pname‬‬
‫ﻋﺩﺩ ﺍﻟﺒﻁﺎﻗﺎﺕ‬ ‫ﻋﺩﺩ‬ ‫‪CardCount‬‬ ‫ﺍﻟﺠﻨﺴﻴﺔ‬ ‫ﻨﺹ‬ ‫‪Nationality‬‬
‫ﺍﻟﻤﺘﻭﻓﺭﺓ‬ ‫ـﻭﺍﺯ‬
‫ـﻡ ﺠـ‬
‫ﺭﻗـ‬ ‫ﻋﺩﺩ‬ ‫‪PassNo‬‬
‫ﺍﻟﺴﻔﺭ‬

‫ﺠﺩﻭل ﺍﻟﻤﺴﺎﻓﺭﻭﻥ ﻭﺍﻟﺭﺤﻼﺕ‬

‫‪TripsAndPassengers‬‬
‫ﺍﻟﺸﺭﺡ‬ ‫ﻨﻭﻉ ﺍﻟﺤﻘل‬ ‫ﺍﺴﻡ ﺍﻟﺤﻘل‬
‫ﺭﻗﻡ ﺍﻟﻤﺴﺎﻓﺭ‬ ‫ﻋﺩﺩ‬ ‫‪Pno‬‬
‫ﺭﻗﻡ ﺍﻟﺭﺤﻠﺔ‬ ‫ﻋﺩﺩ‬ ‫‪TripNo‬‬
‫ﺭﻗﻡ ﺍﻟﻤﻘﻌﺩ‬ ‫ﻋﺩﺩ‬ ‫‪SeatNo‬‬
‫ﺭﻗﻡ ﺍﻟﺼﻑ‬ ‫ﻋﺩﺩ‬ ‫‪ClassNo‬‬

‫ﺠﺩﻭل ﺍﻟﺭﺤﻼﺕ ) ‪( Trips‬‬

‫ﺍﻟﺸﺭﺡ‬ ‫ﻨﻭﻉ ﺍﻟﺤﻘل‬ ‫ﺍﺴﻡ ﺍﻟﺤﻘل‬
‫ﺭﻗﻡ ﺍﻟﺭﺤﻠﺔ‬ ‫ﻋﺩﺩ *‬ ‫‪TripNo‬‬
‫ﺍﺴﻡ ﺍﻟﺸﺭﻜﺔ‬ ‫ﻨﺹ‬ ‫‪Company‬‬

‫‪86‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬

‫ﺘﺩل ﺍﻟﻨﺠﻤﺔ ) * ( ﻋﻠﻰ ﺃﻥ ﻫﺫﺍ ﺍﻟﺤﻘل ﻤﻔﺘﺎﺡ ﺭﺌﻴﺴﻲ ‪.‬‬

‫ﻭﺘﺒﻴﻥ ﺍﻷﺴﻬﻡ ﻁﺭﻴﻘﺔ ﺭﺒﻁ ﺍﻟﺠﺩﺍﻭل ‪.‬‬
‫ﺭﻗﻡ ﺍﻟﻤﻘﻌﺩ ﻴﺠﺏ ﺃﻥ ﻴﺄﺨﺫ ﻗﻴﻤﺔ ﺒﻴﻥ ‪ 1‬ﻭ ‪. 200‬‬
‫‪ 1‬ـ ﻓﻲ ﺍﻟﺒﺩﺍﻴﺔ ﺃﻨﺸﺄ ﺍﻟﻔﻬﺭﺱ ‪ AirLines‬ﻋﻠﻰ ﺍﻟﻘﺭﺹ ‪ C‬ﺤﻴﺙ ﺴﻴﺘﻡ ﻭﻀﻊ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﻫﺫﺍ ﺍﻟﻔﻬﺭﺱ ‪.‬‬
‫‪ 2‬ـ ﺘﺸﻐﻴل ﺍﻟﺒﺭﻨﺎﻤﺞ ‪: Database Desktop‬‬
‫ﻴﻤﻜﻨﻙ ﺘﺸﻐﻴل ﺍﻟﺒﺭﻨﺎﻤﺞ ﺨﺎﺭﺝ ﺇﻁﺎﺭ ﺩﻟﻔﻲ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﻘﺎﺌﻤﺔ‬
‫‪Start Æ Programs ÆBorland Delphi ÆDatabase Desktop‬‬
‫ﺃﻭ ﻤﻥ ﺩﺍﺨل ﺩﻟﻔﻲ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﻘﺎﺌﻤﺔ ‪Tools Æ Database Desktop‬‬

‫‪ 2‬ـ ﺘﺤﺩﻴﺩ ﻓﻬﺭﺱ ﺍﻟﻌﻤل ‪:‬‬

‫ﺇﻥ ﻓﻬﺭﺱ ﺍﻟﻌﻤل ﻓﻲ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻴﻌﻨﻲ ﺍﻟﻤﻜﺎﻥ ﺍﻟﺫﻱ ﺴﻴﺒﺤﺙ ﻓﻴـﻪ‬
‫ﺍﻟﺒﺭﻨﺎﻤﺞ ﻋﻥ ﺍﻟﻤﻠﻔﺎﺕ ﻭﺴﻴﻜﻭﻥ ﻫﻭ ﺍﻟﻔﻬﺭﺱ ﺍﻻﻓﺘﺭﺍﻀـﻲ ﻭﺴـﻴﻅﻬﺭ‬
‫ﻀﻤﻥ ﺼﻨﺩﻭﻗﻲ ﻓﺘﺢ ﻭﺤﻔﻅ ﺍﻟﻤﻠﻔﺎﺕ ‪ ،‬ﻭﻟﺘﺤﺩﻴﺩ ﺍﻟﻔﻬﺭﺱ ﺍﻻﻓﺘﺭﺍﻀـﻲ‬
‫ﺍﺨﺘﺭ ﺍﻷﻤﺭ‬
‫‪File Æ Working Directory‬‬
‫ﻓﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺍﻟﻨﺎﻓﺫﺓ ‪ ،‬ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟـﺯﺭ ‪ Browse‬ﻭﺍﺨﺘـﺭ \‪C:‬‬
‫‪AirLines‬‬
‫ﺍﻀﻐﻁ ﺒﻌﺩﻫﺎ ﻋﻠﻰ ‪ ok‬ﻟﻠﺨﺭﻭﺝ ‪.‬‬

‫‪ 3‬ـ ﺘﻌﺭﻴﻑ ﺍﺴﻡ ﺒﺩﻴل ‪: Alias‬‬

‫ﻗﻠﻨﺎ ﺃﻥ ﺍﻻﺴﻡ ﺍﻟﺒﺩﻴل ﻋﺒﺎﺭﺓ ﻋﻥ ﺃﺴﻡ ﻴـﺴﺘﺨﺩﻤﻪ ﺍﻟﻨﻅـﺎﻡ‬
‫ﻟﻠﻭﺼﻭل ﺇﻟﻰ ﻓﻬﺭﺱ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻟﺘﻌﺭﻴﻑ ﺍﺴﻡ ﺒـﺩﻴل‬
‫ﻟﻠﻔﻬﺭﺱ ‪ C:\AirLines‬ﻨﺨﺘﺎﺭ ﺍﻷﻤﺭ ‪Alias Manger‬‬
‫ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪ Tools‬ﻓﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪Database Desktop‬‬
‫‪:‬‬
‫ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ New‬ﻭﺍﻜﺘﺏ ﻓﻲ ﺍﻟﻼﺌﺤﺔ ‪Database‬‬
‫‪Alias‬‬
‫ﺍﻟﺴﻠﺴﻠﺔ ) ‪( Travel‬‬
‫ﻭﻓﻲ ﺍﻟﻼﺌﺤﺔ ‪ Driver Type‬ﺍﻟﻘﻴﻤﺔ ‪) STANDARD‬‬
‫‪87‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺘﺤﺩﺩ ﻫﺫﻩ ﺍﻟﻼﺌﺤﺔ ﻨﻭﻉ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﻭﺘﻌﻁﻰ ﺍﻟﻘﻴﻤﺔ ‪ Standard‬ﺇﺫﺍ ﻜﺎﻨﺕ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨـﺎﺕ ﻤـﻥ ﺍﻟﻨـﻭﻉ‬
‫ﺒﺎﺭﺍﺩﻭﻜﺱ (‪.‬‬

‫ﺤﺩﺩ ﺒﻌﺩﻫﺎ ﻤﺴﺎﺭ ﺍﻟﻘﺎﻋﺩﺓ ‪ C:\AirLiens‬ﻓﻲ ﺍﻟﻘﺴﻡ ‪ ) Path‬ﻴﻤﻜﻥ ﺃﻥ ﺘﻜﺘﺒﻪ ﻜﺘﺎﺒﺔ ﺃﻭ ﺘﺨﺘﺎﺭ ﺍﻟﺯﺭ ‪( Browse‬‬
‫ﺍﻀﻐﻁ ﺒﻌﺩﻫﺎ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Keep New‬ﻹﻀﺎﻓﺔ ﺍﻟﻘﺎﻋﺩﺓ ﺍﻟﺠﺩﻴﺩﺓ ﺇﻀﻐﻁ ﺒﻌﺩﻫﺎ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Ok‬ﺴﺘﻅﻬﺭ ﺭﺴﺎﻟﺔ ﺘﺴﺄﻟﻙ ﺇﻥ‬
‫ﻜﻨﺕ ﺘﺭﻴﺩ ﺤﻔﻅ ﺍﻟﺘﻐﻴﺭﺍﺕ ﻓﻲ ‪ IDAPI32.CFG‬ﻋﻠﻴﻙ ﺃﻥ ﺘﺠﻴﺏ ﻋﻠﻰ ‪ Yes‬ﻟﺤﻔﻅ ﺍﻟﻘﺎﻋﺩﺓ ﺍﻟﺠﺩﻴﺩﺓ ‪.‬‬
‫ﻤﻼﺤﻅﺎﺕ ‪:‬‬
‫‪ 1‬ـ ﻴﺴﺘﺨﺩﻡ ﺍﻻﺴﻡ ﺍﻟﺒﺩﻴل ﻓﻲ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﻹﻋﻁﺎﺀ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺍﻟﺤﺭﻴﺔ ﻓﻲ ﺍﺨﺘﻴﺎﺭ ﻤﻜﺎﻥ ﺘﺨﺯﻴﻥ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ ،‬ﻻﺤﻅ‬
‫ﻼ ﺃﻨـﻙ ﻟـﻡ‬
‫ﺇﻥ ﻤﻌﻅﻡ ﺍﻟﺒﺭﺍﻤﺞ ﺘﻌﻁﻲ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺤﺭﻴﺔ ﻓﻲ ﺍﺨﺘﻴﺎﺭ ﻤﻜﺎﻥ ﻭﻀﻊ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﺼﻴﺏ‪ ،‬ﺘﺼﻭﺭ ﻤﺜ ﹰ‬
‫ﺘﺴﺘﺨﺩﻡ ﺍﻻﺴﻡ ﺍﻟﺒﺩﻴل ﻭﺃﻋﻁﻴﺕ ﺍﻟﺨﺎﺼﺔ ‪ DatabaseName‬ﻟﻠﻌﻨﺼﺭ ‪ Table‬ﺍﻟﻘﻴﻤﺔ ‪ C:\AirLiens‬ﻋﻨﺩﻫﺎ ﻋﻠﻴﻙ‬
‫ﺃﻥ ﺘﻀﻊ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﻫﺫﺍ ﺍﻟﻔﻬﺭﺱ ﻋﻠﻰ ﺠﻤﻴﻊ ﺍﻷﺠﻬﺯﺓ ﺍﻟﺘﻲ ﺴﺘﺴﺘﺨﺩﻡ ﺒﺭﻨﺎﻤﺠﻙ ‪.‬‬
‫‪ 2‬ـ ﺇﺤﺩﻯ ﻓﻭﺍﺌﺩ ﺍﻻﺴﻡ ﺍﻟﺒﺩﻴل ﺍﻷﺨﺭﻯ ﻫﻲ ﺍﻟﻌﻭﺩﺓ ﺇﻟﻰ ﺠﺩﺍﻭل ﺴﺎﺒﻘﺔ ﻭﺨﺎﺼﺔ ﻓﻲ ﺒـﺭﺍﻤﺞ ﺍﻟﻤﺤﺎﺴـﺒﺔ‪ ،‬ﺘـﺼﻭﺭ ﺇﻥ‬
‫ﺍﻟﻤﺴﺘﺨﺩﻡ ﻴﺭﻴﺩ ﺍﻟﻌﻭﺩﺓ ﺇﻟﻰ ﻤﺩﺨﻼﺕ ﺴﻨﺔ ‪ 1998‬ﺤﻴﺙ ﻜﺎﻥ ﻗﺩ ﺤﻔﻅﻬﺎ ﻋﻠﻰ ﺍﻟﻔﻬﺭﺱ ‪ D:\1998‬ﻋﻨﺩﻫﺎ ﻋﻠﻴﻙ ﺘﻐﻴﺭ‬
‫ﻤﺴﺎﺭ ﺍﻻﺴﻡ ﺍﻟﺒﺩﻴل ﻓﻘﻁ ﺩﻭﻥ ﺍﻟﺘﻐﻴﺭ ﻓﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪.‬‬
‫‪ 3‬ـ ﻴﻤﻜﻥ ﺇﻨﺸﺎﺀ ﻭﺤﺫﻑ ﺍﻻﺴﻡ ﺍﻟﺒﺩﻴل ﺒﺭﻤﺠﻴﹰﺎ ‪.‬‬
‫‪ 4‬ـ ﻓﻲ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺴﺎﺒﻘﺔ ‪ Alias Manger‬ﻓﻲ ﺤﺎل ﺇﺯﺍﻟﺔ ﺍﻟﺨﻴﺎﺭ ‪ Public Alias‬ﺴﻴﺘﻡ ﺘﻌﺭﻴﻑ ‪ Alias‬ﺠﺩﻴـﺩ ﻓـﻲ‬
‫ﺍﻟﺒﺭﻨﺎﻤﺞ ‪ Database Desktop‬ﻓﻘﻁ ﻭﻻ ﻴﻤﻜﻥ ﺍﻟﻭﺼﻭل ﺇﻟﻰ ﻫﺫﺍ ﺍﻟـ ‪ Alias‬ﻤﻥ ﺍﻟﺩﻟﻔﻲ ﻤﺜ ﹰ‬
‫ﻼ‪.‬‬
‫‪ 5‬ـ ﻴﺴﺘﺨﺩﻡ ﺍﻟﺯﺭ ‪ Remove‬ﻟﺤﺫﻑ ﺍﺴﻡ ﺒﺩﻴل ‪.‬‬
‫ﺍﻟﺒﺩﺀ ﺒﺠﺩﻭل ﺠﺩﻴﺩ ‪:‬‬
‫ﻟﻠﺒﺩﺀ ﺒﺠﺩﻭل ﺠﺩﻴﺩ ﺍﺨﺘﺭ ﺍﻷﻤﺭ ‪File Æ New Æ Table‬‬
‫ﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻤﺠﺎﻭﺭﺓ ﻟﺘﺤﺩﻴﺩ ﻨﻭﻉ ﺍﻟﺠﺩﻭل ﺤﻴﺙ ﻴﻤﻜﻥ ﺇﻨﺸﺎﺀ ﺍﻟﻌﺩﻴﺩ ﻤﻥ‬
‫ﺃﻨﻭﺍﻉ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺎﺴـﺘﺨﺩﺍﻡ ﺍﻟﺒﺭﻨـﺎﻤﺞ ‪) Database Desktop‬‬
‫ﺍﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺍﻟﻼﺌﺤﺔ ﻟﻤﺸﺎﻫﺩﺓ ﻫﺫﻩ ﺍﻷﻨﻭﺍﻉ ( ‪ ،‬ﺍﺨﺘﺭ ﻤﻥ ﺍﻟﻼﺌﺤﺔ ‪ Paradox7‬ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﻤﻭﺍﻓﻕ‪.‬‬

‫ﻤﻌﻅﻡ ﺍﻟﻌﻤل ﻓـﻲ ﺍﻟﺒﺭﻨـﺎﻤﺞ ‪Database‬‬

‫‪ Desktop‬ﻴﺘﻡ ﻓـﻲ ﻫـﺫﻩ ﺍﻟﻨﺎﻓـﺫﺓ ﻟـﺫﻟﻙ‬
‫ﺴﺘﺸﺭﺡ ﺒﺸﻲﺀ ﻤﻥ ﺍﻟﺘﻔﺼﻴل‬
‫ﺠﺩﻭل ﺍﻟﺤﻘﻭل ‪: Field roster‬‬
‫ﻴﺘﻡ ﻓﻲ ﻫﺫﺍ ﺍﻟﺠﺩﻭل ﺘﻌﺭﻴﻑ ﺤﻘﻭل ﺍﻟﺠـﺩﻭل‬
‫ﻭﺘﺘﺄﻟﻑ ﻤﻥ‬
‫‪ 1‬ـ ﺍﺴﻡ ﺍﻟﺤﻘل ‪: Field Name‬‬

‫‪88‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻴﻭﻀﻊ ﻓﻲ ﻫﺫﺍ ﺍﻟﻘﺴﻡ ﺍﺴﻡ ﺍﻟﺤﻘل‪ ،‬ﻭﺃﺴﻤﺎﺀ ﺍﻟﺤﻘﻭل ﻓﻲ ﺠﺩﺍﻭل ﺍﻟﺒﺎﺭﺩﻭﻜﺱ ﻴﺠﺏ ﺃﻥ ﻻ ﺘﺘﺠﺎﻭﺯ ‪ 25‬ﺤﺭﻑ‪ ،‬ﻜﻤﺎ ﻴﻤﻜـﻥ‬
‫ﺃﻥ ﺘﺤﺘﻭﻱ ﻋﻠﻰ ﻓﺭﺍﻏﺎﺕ ﻭﻴﻤﻜﻥ ﺃﻥ ﻴﻜﻭﻥ ﺍﺴﻡ ﺍﻟﺤﻘل ﺒﺎﻟﻠﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ ﻭﻟﻜﻥ ﻴﻨﺼﺢ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺃﺴﻤﺎﺀ ﺤﻘﻭل ﺇﻨﻜﻠﻴﺯﻴﺔ ﺩﺍﺌﻤﹰﺎ‬
‫ﻭﻋﺩﻡ ﺍﺤﺘﻭﺍﺌﻬﺎ ﻋﻠﻰ ﻓﺭﺍﻏﺎﺕ ﻭﺨﺎﺼﺔ ﻋﻨﺩ ﺍﺴﺘﺨﺩﺍﻡ ‪ ، SQL‬ﻜﻤﺎ ﻴﺠﺏ ﺍﻻﺒﺘﻌﺎﺩ ﻋﻥ ﺒﻌﺽ ﺍﻷﺴﻤﺎﺀ ﺍﻟﻤﺤﺠﻭﺯﺓ ﻓﻲ ﻟﻐﺔ‬
‫‪ SQL‬ﻤﺜل ‪ SELECT‬ﺃﻭ ‪ From‬ﺃﻭ ‪... Date‬‬
‫‪ 2‬ـ ﻨﻭﻉ ﺍﻟﺤﻘل ‪: Type‬‬
‫ﻴﺼﻑ ﻫﺫﺍ ﺍﻟﺤﻘل ﻨﻭﻉ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻟﺫﻱ ﺴﻴﺨﺯﻥ ﻓﻲ ﻫﺫﺍ ﺍﻟﺤﻘل ﻭﻫﻨﺎﻙ ﻋﺩﺩ ﻤﻥ ﺍﻷﻨﻭﺍﻉ ﺍﻟﺘﻲ ﻴﻤﻜـﻥ ﺃﻥ ﻴﻨﺘﻤـﻲ ﺇﻟﻴﻬـﺎ‬
‫ﺍﻟﺤﻘل ﻭﻟﻤﻌﺭﻓﺔ ﻫﺫﻩ ﺍﻷﻨﻭﺍﻉ ﺇﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﻤﻴﻨﻲ ﻓﻲ ﺍﻟﻌﻤﻭﺩ ‪ Type‬ﺃﻭ ﺍﻀﻐﻁ ﻋﻠﻰ ﻤﻔﺘـﺎﺡ ﺍﻟﻤـﺴﺎﻓﺔ ‪Space‬‬
‫ﻻ ‪ ،‬ﻭﺍﻟﺠﺩﻭل ﺍﻟﺘﺎﻟﻲ ﻴﺒﻴﻥ ﺍﻷﻨﻭﺍﻉ ﺍﻟﺘﻲ ﺘﻭﻓﺭﻫﺎ ﺠﺩﺍﻭل ‪: Paradox‬‬
‫ﻋﻨﺩﻤﺎ ﻴﻜﻭﻥ ﺍﻟﻌﻤﻭﺩ ‪ Type‬ﻓﻌﺎ ﹰ‬
‫ﻤﻼﺤﻅﺎﺕ‬ ‫ﺍﻟﺭﻤﺯ‬ ‫ﺍﻟﺤﺠﻡ‬ ‫ﺍﻟﻨﻭﻉ‬
‫ﻨﺹ ﻋﺎﺩﻱ ﻴﻤﻜﻥ ﺃﻥ ﻴﺤﺘﻭﻱ ﺭﻤﻭﺯﹰﺍ ﺃﻭ ﺃﺭﻗﺎﻡ ﻭﻴﺤﺩﺩ ﺤﺠﻡ ﺍﻟﺤﻘل ﻁﻭل‬ ‫‪A 255 – 1‬‬ ‫‪Alpha‬‬
‫ﺍﻟﺴﻠﺴﻠﺔ ﺍﻟﺘﻲ ﺴﻴﺄﺨﺫﻩ ﺍﻟﺤﻘل‬
‫ﻋﺩﺩ ﺤﻘﻴﻘﻲ‬ ‫‪N‬‬ ‫‪Number‬‬
‫ﻨﻔﺱ ﺍﻟﻨﻭﻉ ﺍﻟﺴﺎﺒﻕ ﻭﻟﻜﻥ ﺒﺼﻴﻐﺔ ﻤﺎﻟﻴﺔ‬ ‫‪$‬‬ ‫‪Money‬‬
‫ﻋﺩﺩ ﺼﺤﻴﺢ ﻁﻭﻴل ﺒﻁﻭل ﺒﺎﻴﺘﻴﻥ ﻤﻥ ﺍﻟﻨﻭﻉ ‪Integer‬‬ ‫‪S‬‬ ‫‪Short‬‬
‫ﻋﺩﺩ ﺼﺤﻴﺢ ﻁﻭﻴل ﻤﻥ ﺍﻟﻨﻭﻉ ‪Longint‬‬ ‫‪I‬‬ ‫‪Long Integer‬‬
‫ﻋﺩﺩ ﺼﺤﻴﺢ ﻋﺸﺭﻱ ﻤﻀﻐﻭﻁ ) ﺍﻟﺘﻤﺜﻴل ﺍﻟﺜﻨـﺎﺌﻲ ﻹﻋـﺩﺍﺩ ﺍﻟﻔﺎﺼـﻠﺔ‬ ‫‪#‬‬ ‫‪0 .. 32‬‬ ‫‪BCD‬‬
‫)‪(1‬‬
‫ﺍﻟﻌﺸﺭﻴﺔ (‬
‫ﺘﺎﺭﻴﺦ‬ ‫‪D‬‬ ‫‪Date‬‬
‫ﻭﻗﺕ‬ ‫‪T‬‬ ‫‪Time‬‬
‫ﻴﺩﻤﺞ ﺍﻟﺘﺎﺭﻴﺦ ﻭﺍﻟﻭﻗﺕ ﻓﻲ ﺤﻘل ﻭﺍﺤﺩ‬ ‫@‬ ‫‪TimeStamp‬‬
‫)‪(2‬‬
‫ﻨﺹ ﺒﺤﺠﻡ ﻜﺒﻴﺭ‪.‬‬ ‫‪M‬‬ ‫‪1..240‬‬ ‫‪Memo‬‬
‫ﻨﺹ ﺒﺤﺠﻡ ﻜﺒﻴﺭ ﻤﻊ ﺘﺨﺯﻴﻥ ﻁﺭﻴﻘﺔ ﺘﻨﺴﻴﻕ ﻫﺫﺍ ﺍﻟﻨﺹ ) ﻟﻭﻥ ﺍﻟﻨﺹ ﻭ‬ ‫‪F‬‬ ‫‪0.. 240‬‬ ‫‪Formatted‬‬
‫)‪(2‬‬ ‫‪Memo‬‬
‫ﻨﻭﻉ ﺍﻟﺨﻁ ‪(..‬‬
‫)‪(3‬‬
‫ﺼﻭﺭﺓ‬ ‫‪G‬‬ ‫‪0..240‬‬ ‫‪Graphic‬‬
‫)‪(3‬‬
‫ﻼ(‬
‫ﻴﻤﺜل ﺤﺎﻭﻴﺔ ﻟﺭﺒﻁ ﻭﺇﺩﺭﺍﺝ ﺍﻟﻜﺎﺌﻨﺎﺕ ) ﺇﺩﺭﺍﺝ ﻤﻠﻑ ‪ Excel‬ﻤﺜ ﹰ‬ ‫‪O‬‬ ‫‪0..240‬‬ ‫‪OLE‬‬
‫ﻴﻤﺜل ﻗﻴﻤﺔ ﻤﻨﻁﻘﻴﺔ ‪ True‬ﺃﻭ ‪False‬‬ ‫‪L‬‬ ‫‪Logical‬‬
‫ﻋﺩﺩ ﺼﺤﻴﺢ ﻁﻭﻴل ﻴﺯﺩﺍﺩ ﺘﻠﻘﺎﺌﻴﹰﺎ‬ ‫‪+‬‬ ‫‪Auto increment‬‬
‫)‪(3‬‬
‫ﻴﺨﺯﻥ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﺜﻨﺎﺌﻴﹰﺎ ﺩﺍﺨل ﻤﻠﻔﺎﺕ ‪.Mb‬‬ ‫‪B‬‬ ‫‪0..240‬‬ ‫‪Binary‬‬
‫ﻤﻌﻁﻴﺎﺕ ﺒﺎﻟﺼﻴﻐﺔ ﺍﻟﺜﻨﺎﺌﻴﺔ ﺘﺨﺯﻥ ﻀﻤﻥ ﻤﻠﻑ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪Db‬‬ ‫‪Y‬‬ ‫‪1..255‬‬ ‫‪Byte‬‬
‫) ‪ : ( 1‬ﺍﻟﺭﻗﻡ ﻓﻲ ﺍﻟﻌﻤﻭﺩ ﺤﺠﻡ ﺘﺤﺩﺩ ﻋﺩﺩ ﺍﻷﺭﻗﺎﻡ ﺒﻌﺩ ﺍﻟﻔﺎﺼﻠﺔ‬

‫‪89‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫) ‪ : ( 2‬ﻴﺴﺘﺨﺩﻡ ﺍﻟﻨﻭﻉ ‪ Memo‬ﻓﻲ ﺤﺎل ﺍﻟﻨﺼﻭﺹ ﺍﻟﺘﻲ ﻴﺒﻠﻎ ﺤﺠﻤﻬﺎ ﺃﻜﺜﺭ ﻤﻥ ‪ 255‬ﺤﺭﻑ ﻭﺘﺨﺯﻥ ﻋﺎﺩﺓ ﺨﺎﺭﺝ ﻤﻠﻑ‬
‫ﺍﻟﺠﺩﻭل ﻓﻲ ﻤﻠﻔﺎﺕ ﺫﺍﺕ ﺍﻤﺘﺩﺍﺩ ‪ MB‬ﻭﻴﺩل ﺍﻟﺭﻗﻡ ﺍﻟﻤﺩﺨل ﻓﻲ ﻋﻤﻭﺩ ﺍﻟﺤﺠﻡ ﻋﻠﻰ ﻋﺩﺩ ﺍﻷﺤﺭﻑ ﺍﻟﺫﻱ ﺴـﻴﺨﺯﻥ ﺩﺍﺨـل‬
‫ﻤﻠﻑ ﺍﻟﺠﺩﻭل ‪ ) .Db‬ﺒﻔﺭﺽ ﺃﻋﻁﻴﻨﺎ ﺍﻟﻘﻴﻤﺔ ‪ 30‬ﻓﻲ ﻋﻤﻭﺩ ﺍﻟﺤﺠﻡ ﻋﻨﺩﻫﺎ ﻓﻲ ﺤﺎل ﺃﺩﺨل ﺍﻟﻤﺴﺘﺨﺩﻡ ‪ 30‬ﺤﺭﻑ ﺃﻭ ﺃﻗـل‬
‫ﺴﺘﺨﺯﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺩﺍﺨل ﻤﻠﻑ ﺍﻟﻘﺎﻋﺩﺓ ﺃﻤﺎ ﺇﺫﺍ ﺇﺩﺨل ﺍﻟﻤﺴﺘﺨﺩﻡ ﺃﻜﺜﺭ ﻤﻥ ‪ 30‬ﺤﺭﻑ ﺴﺘﺨﺯﻥ ﻋﻨﺩﻫﺎ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺩﺍﺨل ﻤﻠـﻑ‬
‫ﻤﻥ ﺍﻟﻨﻭﻉ ‪.Mb‬‬
‫) ‪ ( 3‬ﻴﻤﻜﻥ ﻋﺩﻡ ﺘﺤﺩﻴﺩ ﺤﺠﻡ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ‪.‬‬
‫‪ 3‬ـ ﺤﺠﻡ ﺍﻟﺤﻘل ‪ Size‬ﻜﻤﺎ ﻫﻭ ﻤﻼﺤﻅ ﻓﻲ ﺍﻟﺠﺩﻭل ﺍﻟﺴﺎﺒﻕ ﻫﻨﺎﻙ ﺒﻌﺽ ﺃﻨﻭﺍﻉ ﺍﻟﺤﻘﻭل ﺒﺤﺎﺠﺔ ﻟﺘﺤﺩﻴﺩ ﺤﺠﻤﻬﺎ ﻟﻨﺄﺨـﺫ‬
‫ﻻ ﻋﻠﻰ ﺫﻟﻙ ﺍﻟﺤﻘل ﻤﻥ ﻨﻭﻉ ‪ Alpha‬ﺒﻔﺭﺽ ﺃﻨﻪ ﻋﺭﻓﻨﺎ ﺤﻘل ﺍﺴﻡ ﺍﻟﻤﺴﺎﻓﺭ ﻤﻥ ﺍﻟﻨـﻭﻉ ‪ A‬ﻭﺒﺤﺠـﻡ ‪ ، 20‬ﻨـﺴﺘﻁﻴﻊ‬
‫ﻤﺜﺎ ﹰ‬
‫ﻋﻨﺩﻫﺎ ﺇﺩﺨﺎل ﺃﺴﻤﺎﺀ ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﺫﺍﺕ ﻁﻭل ﻋﺸﺭﻴﻥ ﺤﺭﻑ ﺃﻭ ﺃﻗل ﺃﻤﺎ ﺇﺫﺍ ﻜﺎﻥ ﺍﺴﻡ ﺃﺤﺩ ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﺃﻁﻭل ﻤﻥ ﻋـﺸﺭﻴﻥ‬
‫ﺤﺭﻑ ﻓﺴﻴﺘﻡ ﺘﺨﺯﻴﻥ ﺍﻟﻌﺸﺭﻴﻥ ﺤﺭﻑ ﺍﻷﻭﻟﻰ ﻭﺘﺠﺎﻫل ﺍﻟﺒﺎﻗﻲ ‪ ،‬ﻤﺸﻜﻠﺔ ﺃﺨﺭﻯ ﻴﻤﻜﻥ ﺃﻥ ﺘﻅﻬﺭ ‪ ،‬ﺒﻔﺭﺽ ﺃﻥ ﺍﺴـﻡ ﺃﺤـﺩ‬
‫ﻼ ﻓﺈﻥ ﺍﺴﻡ ﻫﺫﺍ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺴﻴﺨﺯﻥ ﻓﻲ ﺍﻟﻘﺎﻋﺩﺓ ﺒﺤﺠـﻡ ﻋـﺸﺭﻴﻥ‬
‫ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻤﻜﻭﻥ ﻤﻥ ﻋﺸﺭﺓ ﺃﺤﺭﻑ " ﻤﺤﻤﺩ ﺁﻏﺎ " ﻤﺜ ﹰ‬
‫ﺒﺎﻴﺕ ‪ ،‬ﺃﻱ ﺃﻨﻪ ﺠﻤﻴﻊ ﺤﻘﻭل ﺍﻟﻌﻤﻭﺩ ﻓﻲ ﺠﺩﻭل ﺍﻟﺒﺎﺭﺩﻭﻜﺱ ﺘﺄﺨﺫ ﻨﻔﺱ ﺍﻟﺤﺠﻡ ﻤﻬﻤﺎ ﻜﺎﻥ ﻁﻭل ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﺍﻟﻤﺩﺨﻠﺔ ‪.‬‬
‫‪ 4‬ـ ﺍﻟﻤﻔﺘﺎﺡ ﺍﻟﺭﺌﻴﺴﻲ ) ﺍﻷﺴﺎﺴﻲ ( ‪ : Key‬ﺍﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻷﻴﺴﺭ ﻓﻲ ﻫﺫﺍ ﺍﻟﺤﻘل ﺇﺫﺍ ﺃﺭﺩﺕ ﺃﻥ ﻴﻜﻭﻥ ﻫﺫﺍ ﺍﻟﺤﻘل‬
‫ﻤﻔﺘﺎﺡ ﺭﺌﻴﺴﻲ ﻭﺇﺫﺍ ﺃﺭﺩﺕ ﻤﺯﻴﺩ ﻤﻥ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﻋﻥ ﺍﻟﻤﻔﺎﺘﻴﺢ ﺍﻟﺭﺌﻴﺴﻴﺔ ﺍﻗﺭﺃ ﺍﻟﻔﻘﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﺤﻭل ﺍﻟﻤﻔﺎﺘﻴﺢ ﺍﻷﺴﺎﺴﻴﺔ‬
‫ﺘﺄﺘﻲ ﻓﺎﻋﻠﻴﺔ ﻨﻅﺎﻡ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻌﻼﺌﻘﻴﺔ ﻤﻥ ﺍﻟﻘﺩﺭﺓ ﻋﻠﻰ ﺍﻟﻌﺜﻭﺭ ﻋﻠﻰ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﺍﻟﻤﺨﺯﻨﺔ ﻓﻲ ﺠﺩﺍﻭل ﻤﻨﻔﺼﻠﺔ ﺒﺴﺭﻋﺔ‬
‫ﻭﺘﺠﻤﻴﻌﻬﺎ ﻤﻌﹰﺎ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﺴﺘﻌﻼﻤﺎﺕ ﻭﻨﻤﺎﺫﺝ ﻭﺘﻘﺎﺭﻴﺭ‪ .‬ﻟﻜﻲ ﻴﺘﻡ ﺫﻟﻙ‪ ،‬ﻴﺠﺏ ﺃﻥ ﻴﺤﺘﻭﻱ ﻜـل ﺠـﺩﻭل ﻋﻠـﻰ ﺤﻘـل ﺃﻭ‬
‫ﻤﺠﻤﻭﻋﺔ ﺤﻘﻭل ﺘﻘﻭﻡ ﺒﺘﻌﺭﻴﻑ ﻜل ﺴﺠل ﻤﺨﺯﻥ ﻓﻲ ﺍﻟﺠﺩﻭل ﺒﺸﻜل ﻓﺭﻴﺩ‪ ،‬ﻭﺘﺴﻤﻰ ﻫﺫﻩ ﺍﻟﻤﻌﻠﻭﻤـﺔ ﺍﻟﻤﻔﺘـﺎﺡ ﺍﻷﺴﺎﺴـﻲ‬
‫ﻟﻠﺠﺩﻭل) ﺭﻗﻡ ﺍﻟﻤﺴﺎﻓﺭ ﻴﻌﺭﻑ ﺍﻟﻤﺴﺎﻓﺭ ﺒﺸﻜل ﻓﺭﻴﺩ ‪ ،‬ﻜﺫﻟﻙ ﺭﻗﻡ ﺍﻟﺭﺤﻠﺔ ﻴﻌﺭﻑ ﺭﺤﻠﺔ ﻭﺤﻴﺩﺓ ﺃﻱ ﺒﻤﺠﺭﺩ ﻤﻌﺭﻓـﺔ ﺭﻗـﻡ‬
‫ﺍﻟﺭﺤﻠﺔ ﻨﺴﺘﻁﻴﻊ ﻤﻌﺭﻓﺔ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﺍﻟﻤﺘﻌﻠﻘﺔ ﺒﺎﺴﻡ ﺸﺭﻜﺔ ﺍﻟﻁﻴﺭﺍﻥ ﻭﺒﻠﺩ ﺍﻟﻤﻐﺎﺩﺭﺓ ﻭﺒﻠﺩ ﺍﻟﻭﺼﻭل ﻭﺴﺎﻋﺔ ﺍﻟﻤﻐﺎﺩﺭﺓ ﻭﺴﺎﻋﺔ‬
‫ﺍﻟﻭﺼﻭل ‪( ..‬‬
‫ﻤﺘﻰ ﻗﻤﺕ ﺒﺘﻌﻴﻴﻥ ﻤﻔﺘﺎﺤﹰﺎ ﺃﺴﺎﺴﻴﹰﺎ ﻟﻠﺠﺩﻭل‪ ،‬ﻴﻤﻨﻊ ﺇﺩﺨﺎل ﺃﻱ ﻗﻴﻡ ﻤﻜﺭﺭﺓ ﺃﻭ ﻗﻴﻡ "ﺨﺎﻟﻴﺔ" ‪ Null‬ﻓﻲ ﺤﻘﻭل ﺍﻟﻤﻔﺘﺎﺡ ﺍﻷﺴﺎﺴﻲ‪.‬‬
‫ﻫﻨﺎﻙ ﺜﻼﺜﺔ ﺃﻨﻭﺍﻉ ﻤﻥ ﺍﻟﻤﻔﺎﺘﻴﺢ ﺍﻷﺴﺎﺴﻴﺔ ﺍﻟﺘﻲ ﻴﻤﻜﻥ ﺘﻌﺭﻴﻔﻬﺎ ‪:‬‬
‫ﺍﻟﻤﻔﺎﺘﻴﺢ ﺍﻷﺴﺎﺴﻴﺔ ﻤﻥ ﻨﻭﻉ ﺍﻟﺘﺭﻗﻴﻡ ﺍﻟﺘﻠﻘﺎﺌﻲ‬
‫ﻴﻤﻜﻥ ﺇﻋﺩﺍﺩ ﺤﻘل ﺍﻟﺘﺭﻗﻴﻡ ﺍﻟﺘﻠﻘﺎﺌﻲ ﻹﺩﺨﺎل ﺭﻗﻡ ﺘﺴﻠﺴﻠﻲ ﺘﻠﻘﺎﺌﻴﹰﺎ ﻋﻨﺩ ﺇﻀﺎﻓﺔ ﻜل ﺴﺠل ﺇﻟﻰ ﺍﻟﺠﺩﻭل‪ .‬ﺘﻌﺩ ﺃﺒـﺴﻁ ﻁﺭﻴﻘـﺔ‬
‫ﻹﻨﺸﺎﺀ ﻤﻔﺘﺎﺡ ﺃﺴﺎﺴﻲ ﻫﻲ ﺘﻌﻴﻴﻥ ﻤﺜل ﻫﺫﺍ ﺍﻟﺤﻘل ﻜﻤﻔﺘﺎﺡ ﺃﺴﺎﺴـﻲ ﻭﻟﺘﻌﺭﻴـﻑ ﺤﻘـل ﺘـﺭﻗﻴﻡ ﺘﻠﻘـﺎﺌﻲ ﺍﺨﺘـﺭ ‪Auto‬‬
‫‪. Increment‬‬
‫ﺍﻟﻤﻔﺎﺘﻴﺢ ﺍﻷﺴﺎﺴﻴﺔ ﻤﻥ ﻨﻭﻉ ﺍﻟﺤﻘل ﺍﻟﻤﻔﺭﺩ ‪:‬‬
‫ﻼ ﻴﺘﻀﻤﻥ ﻗﻴﻡ ﻓﺭﻴﺩﺓ ﻤﺜل ﺭﻗﻡ ﺍﻟﻬﻭﻴﺔ ﺍﻟﺸﺨﺼﻴﺔ‪ ،‬ﻴﻤﻜﻨﻙ ﺘﻌﻴﻴﻥ ﻫﺫﺍ ﺍﻟﺤﻘل ﻋﻠﻰ ﺃﻨﻪ ﺍﻟﻤﻔﺘﺎﺡ ﺍﻷﺴﺎﺴﻲ‪.‬‬
‫ﺇﺫﺍ ﻜﺎﻥ ﻟﺩﻴﻙ ﺤﻘ ﹰ‬
‫ﻭﻴﻤﻜﻨﻙ ﺘﺤﺩﻴﺩ ﻤﻔﺘﺎﺡ ﺃﺴﺎﺴﻲ ﻟﺤﻘل ﻴﺤﺘﻭﻱ ﺒﺎﻟﻔﻌل ﻋﻠﻰ ﺒﻴﺎﻨﺎﺕ ﻁﺎﻟﻤﺎ ﻻ ﻴﺤﺘﻭﻱ ﻫﺫﺍ ﺍﻟﺤﻘل ﻋﻠﻰ ﻗﻴﻡ ﻤﻜـﺭﺭﺓ ﺃﻭ ﻗـﻴﻡ‬
‫"ﺨﺎﻟﻴﺔ" ‪.Null‬‬
‫ﺍﻟﻤﻔﺎﺘﻴﺢ ﺍﻷﺴﺎﺴﻴﺔ ﻤﻥ ﻨﻭﻉ ﺍﻟﺤﻘل ﺍﻟﻤﺘﻌﺩﺩ ‪:‬‬
‫‪90‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻓﻲ ﺍﻟﺤﺎﻻﺕ ﺍﻟﺘﻲ ﻻ ﻴﻤﻜﻨﻙ ﻓﻴﻬﺎ ﻀﻤﺎﻥ ﻭﺠﻭﺩ ﺤﻘل ﻓﺭﺩﻱ‪ ،‬ﻗﺩ ﻴﻜﻭﻥ ﺒﺈﻤﻜﺎﻨﻙ ﺘﻌﻴﻴﻥ ﺤﻘﻠﻴﻥ ﺃﻭ ﺃﻜﺜﺭ ﺒﺎﻋﺘﺒﺎﺭﻫﻤﺎ ﻤﻔﺘﺎﺤﹰﺎ‬
‫ﺃﺴﺎﺴﻴﹰﺎ‪ .‬ﻭﺍﻟﺤﺎﻟﺔ ﺍﻷﻜﺜﺭ ﺸﻴﻭﻋﹰﺎ ﺍﻟﺘﻲ ﻴﺤﺩﺙ ﻓﻴﻬﺎ ﺫﻟﻙ ﻫﻲ ﺍﻟﺠﺩﻭل ﺍﻟﻤﺴﺘﺨﺩﻡ ﻟﺭﺒﻁ ﺠﺩﻭﻟﻴﻥ ﺁﺨﺭﻴﻥ ﻓﻲ ﻋﻼﻗﺔ ﺃﻁـﺭﺍﻑ‬
‫ﺒﺄﻁﺭﺍﻑ ) ‪ .( Many to Many‬ﻋﻠﻰ ﺴﺒﻴل ﺍﻟﻤﺜﺎل‪ ،‬ﻴﻤﻜﻥ ﺃﻥ ﻴﺭﺒﻁ ﺠﺩﻭل "ﻤﺅﻟﻔﻲ ﺍﻟﻜﺘﺏ" ﺒـﻴﻥ ﺠـﺩﻭﻟﻲ "ﺍﻟﻜﺘـﺏ"‬
‫ﻭ"ﺍﻟﻤﺅﻟﻔﻴﻥ"‪ .‬ﻭﻴﺘﻜﻭﻥ ﻤﻔﺘﺎﺤﻪ ﺍﻷﺴﺎﺴﻲ ﻤﻥ ﺤﻘﻠﻲ‪" :‬ﺭﻗﻡ ﺍﻟﻜﺘﺎﺏ" ﻭ"ﺭﻗﻡ ﺍﻟﻤﺅﻟﻑ"‪.‬‬
‫ﺇﺫﺍ ﻜﺎﻥ ﻟﺩﻴﻙ ﺃﻱ ﺸﻙ ﺤﻭل ﺇﻤﻜﺎﻨﻴﺔ ﺘﺤﺩﻴﺩ ﺘﺭﻜﻴﺏ ﻤﻨﺎﺴﺏ ﻤﻥ ﺍﻟﺤﻘﻭل ﻟﻤﻔﺘﺎﺡ ﺃﺴﺎﺴﻲ ﻤﺘﻌﺩﺩ ﺍﻟﺤﻘﻭل‪ ،‬ﻓﺭﺒﻤﺎ ﻴﺠﺏ ﻋﻠﻴﻙ‬
‫ﻻ ﻤﻥ ﺫﻟﻙ‪ .‬ﻋﻠﻰ ﺴﺒﻴل ﺍﻟﻤﺜﺎل‪ ،‬ﻓﺈﻥ ﻀﻡ ﺤﻘﻠـﻲ "ﺍﻻﺴـﻡ ﺍﻷﻭل"‬
‫ﺇﻀﺎﻓﺔ ﺤﻘل "ﺘﺭﻗﻴﻡ ﺘﻠﻘﺎﺌﻲ" ﻭﺘﻌﻴﻴﻨﻪ ﻜﻤﻔﺘﺎﺡ ﺃﺴﺎﺴﻲ ﺒﺩ ﹰ‬
‫ﻭ"ﺍﻻﺴﻡ ﺍﻷﺨﻴﺭ" ﻟﺘﻜﻭﻴﻥ ﻤﻔﺘﺎﺡ ﺃﺴﺎﺴﻲ ﻻ ﻴ‪‬ﻌﺘﺒﺭ ﺍﺨﺘﻴﺎﺭﹰﺍ ﺼﺎﺌﺒﺎﹰ‪ ،‬ﺒﺴﺒﺏ ﺇﻤﻜﺎﻨﻴﺔ ﻤﺼﺎﺩﻓﺔ ﺘﻜﺭﺍﺭ ﻓﻲ ﻀﻡ ﻫﺫﻴﻥ ﺍﻟﺤﻘﻠـﻴﻥ‬
‫ﻓﻲ ﺍﻟﻤﺴﺘﻘﺒل‪.‬‬
‫ﺇﻨﺸﺎﺀ ﺠﺩﻭل ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ‪:‬‬
‫ﻤﺎﺯﻟﻨﺎ ﻓﻲ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺴﺎﺒﻘﺔ‪ ،‬ﻹﻀﺎﻓﺔ ﺍﻟﺤﻘل ﺭﻗﻡ ﺍﻟﻤﺴﺎﻓﺭ ﺃﻜﺘﺏ ﻓـﻲ ﺍﻟﻌﻤـﻭﺩ‬
‫‪ " PNo " Filed Name‬ﻭﺍﻟﻌﻤﻭﺩ ‪ + Type‬ﺃﻱ ﺃﻥ ﺍﻟﺤﻘل ﻤﻥ ﺍﻟﻨﻭﻉ ﺘﺭﻗﻴﻡ‬
‫ﺘﻠﻘﺎﺌﻲ ) ﻻ ﺤﺎﺠﺔ ﻟﺘﺤﺩﻴﺩ ﺤﺠﻡ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ( ﻭﻀﻊ ﺇﺸﺎﺭﺓ ﻓﻲ ﺍﻟﺤﻘـل ‪Key‬‬
‫ﻷﻥ ﻫﺫﺍ ﺍﻟﺤﻘل ﺴﻴﻜﻭﻥ ﻤﻔﺘﺎﺡ ﺃﺴﺎﺴﻲ ‪.‬‬
‫ﻹﻀﺎﻓﺔ ﺍﻟﺤﻘل ﺍﺴﻡ ﺍﻟﻤﺴﺎﻓﺭ ﺃﻜﺘﺏ ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺜﺎﻨﻲ ﻤـﻥ ﺍﻟﻌﻤـﻭﺩ ‪Field‬‬
‫‪ Name‬ﺍﻟﻘﻴﻤﺔ ‪ Pname‬ﻭﺍﻟﻌﻤﻭﺩ ‪ "A" Type‬ﻷﻥ ﺍﻟﺤﻘل ﻤﻥ ﻨﻭﻉ ﻨﺹ ‪ ،‬ﻓﻲ ﺍﻟﻌﻤﻭﺩ ‪ Size‬ﺍﻜﺘﺏ ﺍﻟﻘﻴﻤﺔ ‪ ، 30‬ﺃﻱ ﺃﻥ‬
‫ﻁﻭل ﺍﻟﺤﻘل ‪ 30‬ﺤﺭﻑ ‪ ،‬ﻭﺍﺘﺭﻙ ﺍﻟﻌﻤﻭﺩ ‪ Key‬ﻓﺎﺭﻏﹰﺎ ﻭﺍﻜﻤل ﻜﻤﺎ ﻓﻲ ﺍﻟﺸﻜل ﺍﻟﻤﺠﺎﻭﺭ ‪.‬‬
‫ﻟﺤﻔﻅ ﺍﻟﺠﺩﻭل ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Save As‬ﺴﻴﻅﻬﺭ ﻟﻙ ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ﺤﻔﻅ ﺒﺎﺴﻡ ﺍﺨﺘﺭ ﻤﻥ ﺍﻟﻼﺌﺤﺔ ‪ Alias‬ﺍﻟﻘﻴﻤـﺔ‬
‫‪ Travel‬ﺃﺩﺨل ﺍﺴﻡ ﺍﻟﻤﻠﻑ ‪ Passengers‬ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺤﻔﻅ ‪.‬‬
‫ﺇﻨﺸﺎﺀ ﺠﺩﻭل ﺍﻟﺭﺤﻼﺕ ‪:‬‬
‫ﺍﺨﺘﺭ ﺍﻷﻤﺭ ‪ FileÆ newÆ table‬ﻭﺍﺨﺘﺭ ‪ Paradox7‬ﻤـﻥ ﺍﻟﻘﺎﺌﻤـﺔ‬
‫ﻓﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺴﺎﺒﻘﺔ ﺃﺩﺨل ﺍﻟﻘﻴﻡ ﻓﻴﻬﺎ ﻜﻤﺎ ﻓﻲ ﺍﻟﺠﺩﻭل ﺍﻟﻤﺠﺎﻭﺭ ‪:‬‬
‫ﺍﺤﻔﻅ ﺍﻟﺠﺩﻭل ﻀﻤﻥ ‪ Travel‬ﺒﺎﺴﻡ ‪. Trips‬‬

‫ﺇﻨﺸﺎﺀ ﺠﺩﻭل ﺍﻟﻤﺴﺎﻓﺭﻭﻥ ﻭﺍﻟﺭﺤﻼﺕ ‪:‬‬

‫ﺍﺨﺘﺭ ﺍﻷﻤﺭ ‪ FileÆ newÆ table‬ﻭﺍﺨﺘﺭ ‪ Paradox7‬ﻤـﻥ ﺍﻟﻘﺎﺌﻤـﺔ‬
‫ﻓﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺴﺎﺒﻘﺔ ﺃﺩﺨل ﺍﻟﻘﻴﻡ ﻓﻴﻬﺎ ﻜﻤﺎ ﻓﻲ ﺍﻟﺠﺩﻭل ﺍﻟﻤﺠﺎﻭﺭ ‪:‬‬
‫ﺍﺤﻔﻅ ﺍﻟﺠﺩﻭل ﻀﻤﻥ ‪ Travel‬ﺒﺎﺴﻡ ‪PassAndTrips‬‬

‫ﻤﻼﺤﻅﺔ ‪ :‬ﺘﺨﺯﻥ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ Paradox‬ﻓﻲ ﻨﻭﻋﻴﻥ ﻤﻥ ﺍﻟﻤﻠﻔﺎﺕ ‪:‬‬

‫‪ 1‬ـ ﻤﻠﻔﺎﺕ ﻤﻥ ﺍﻻﻤﺘﺩﺍﺩ ‪ Db‬ﺤﻴﺙ ﻴﺘﻡ ﺘﺨﺯﻴﻥ ﻤﻌﻅﻡ ﺒﻴﺎﻨﺎﺕ ﺍﻟﺠﺩﻭل ‪.‬‬
‫‪ 2‬ـ ﻤﻠﻔﺎﺕ ﻤﻥ ﺍﻻﻤﺘﺩﺍﺩ ‪ Mb‬ﺤﻴﺙ ﻴﺘﻡ ﺘﺨﺯﻴﻥ ﺍﻷﺠﺯﺍﺀ ﺍﻟﻜﺒﻴﺭﺓ ﻤﺜل ﺍﻟﻤﻔﻜﺭﺍﺕ ﻭ ﺍﻟﺼﻭﺭ ‪....‬‬
‫ﻓﺘﺢ ﺠﺩﻭل ‪:‬‬
‫‪91‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻟﻔﺘﺢ ﺠﺩﻭل ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﺃﺨﺘﺭ ﺍﻷﻤﺭ ‪ FileÆOpen Æ Table‬ﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺍﻟﻨﺎﻓﺫﺓ ﻓﺘﺢ ﻤﻠﻑ ﺍﺨﺘـﺭ ﻤﻨﻬـﺎ ﺍﻟﻤﻠـﻑ‬
‫‪Passengers.db‬‬
‫ﺘﻌﺩﻴل ﺠﺩﻭل ‪:‬‬
‫ﺒﻔﺭﺽ ﺃﻨﻙ ﺒﺤﺎﺠﺔ ﻹﻀﺎﻓﺔ ﺤﻘل ﺠﺩﻴﺩ ﺇﻟﻰ ﺠﺩﻭل ﺃﻭ ﺤﺫﻑ ﺃﺤﺩ ﺍﻟﺤﻘﻭل ﺃﻭ ﺘﻐﻴﺭ ﻨﻭﻋﻪ ﻴﻤﻜﻥ ﺫﻟﻙ ﻋﻥ ﻁﺭﻴـﻕ ﻓـﺘﺢ‬
‫ﺍﻟﺠﺩﻭل ﻭﻤﻥ ﺜﻡ ﺍﺨﺘﻴﺎﺭ ﺍﻷﻤﺭ‬
‫‪ Table Æ Restructure‬ﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﻨﺎﻓﺫﺓ ﺒﻨﺎﺀ ﺍﻟﺠﺩﺍﻭل ﻴﻤﻜﻨﻙ ﺍﻟﻌﻤل ﻓﻴﻬﺎ ﻜﻤﺎ ﺘﻌﻠﻤﻨﺎ ﺴﺎﺒﻘﹰﺎ‪.‬‬
‫ﺴﻨﺘﻌﺭﻑ ﺍﻵﻥ ﻋﻠﻰ ﻋﻨﺎﺼﺭ ﺍﻟﻘﺎﺌﻤﺔ ‪ Table properties‬ﻓﻲ ﻨﺎﻓﺫﺓ ﺇﻨﺸﺎﺀ ﺠﺩﻭل ﺃﻭ ﻨﺎﻓﺫﺓ ﺘﻌﺩﻴل ﺠﺩﻭل ‪.‬‬
‫‪ 1‬ـ ﻀﺒﻁ ﺍﻟﻤﺩﺨﻼﺕ ‪: Validity Checks‬‬
‫ﻴﺤﺩﺩ ﻫﺫﺍ ﺍﻟﺨﻴﺎﺭ ﻁﺭﻴﻘﺔ ﻋﺭﺽ ﻭﻗﺒﻭل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﻜل ﺤﻘل ﻭﻟﻪ ﺍﻟﻔﺭﻭﻉ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ 1‬ـ ‪ : Required Field‬ﻋﻨﺩ ﺘﻔﻌﻴل ﻫﺫﺍ ﺍﻟﺼﻨﺩﻭﻕ ﻴﻨﺒﻐﻲ ﺇﺩﺨﺎل ﻗﻴﻤﺔ ﻓﻲ ﻫﺫﺍ ﺍﻟﺤﻘل ﻭﻻ ﻴﻤﻜﻥ ﺃﻥ ﻴﺘﺭﻙ ﻓﺎﺭﻏﹰﺎ‬
‫‪.‬‬
‫‪ 2‬ـ ‪ : Minimum‬ﻴﺠﺏ ﺃﻥ ﺘﻜﻭﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﻲ ﺴﻨﺩﺨﻠﻬﺎ ﻓﻲ ﺍﻟﺤﻘل ﺃﻜﺒﺭ ﺃﻭ ﺘﺴﺎﻭﻱ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﺤﺩﺩﺓ ﻫﻨﺎ ‪.‬‬
‫‪ 3‬ـ ‪ : Maximum‬ﻴﺠﺏ ﺃﻥ ﺘﻜﻭﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﻲ ﺴﻨﺩﺨﻠﻬﺎ ﻓﻲ ﺍﻟﺤﻘل ﺃﻜﺒﺭ ﺃﻭ ﺘﺴﺎﻭﻱ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﺤﺩﺩﺓ ﻫﻨﺎ ‪.‬‬
‫‪ 4‬ـ ‪ : Default Value‬ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﺤﺩﺩ ﻓﻲ ﻫﻨﺎ ﺴﺘﻜﻭﻥ ﺍﻟﻘﻴﻤﺔ ﺍﻻﻓﺘﺭﺍﻀﻴﺔ ﻭﻴﻤﻜﻥ ﺘﻌﺩﻴﻠﻬﺎ ﻓﻴﻤﺎ ﺒﻌﺩ‬
‫‪ 5‬ـ ‪ : Picture‬ﺘﺸﺒﻪ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﻓﻲ ﻋﻤﻠﻬﺎ ﺍﻟﻌﻨﺼﺭ ‪ MaskEdit‬ﺤﻴﺙ ﻴﻤﻜﻥ ﺘﺤﺩﻴﺩ ﻁﺭﻴﻘﺔ ﺇﺩﺨﺎل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ‬
‫ﺤﻘل ﻤﺎ‪ ،‬ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Assist‬ﻻﺨﺘﻴﺎﺭ ﻗﻭﺍﻟﺏ ﺠﺎﻫﺯﺓ ‪.‬‬
‫ﻤﺜﺎل ‪:‬‬
‫ﻓﻲ ﺠﺩﻭل ﺍﻟﺭﺤﻼﺕ ‪ Trips‬ﺍﺠﻌل ﺍﻟﺤﻘل ﺍﺴﻡ ﺍﻟﺸﺭﻜﺔ ﻤﻁﻠﻭﺒﹰﺎ ﻭ ﺍﻟﺤﻘل ﻋﺩﺩ ﺍﻟﺒﻁﺎﻗﺎﺕ ﺍﻟﻤﺘﻭﻓﺭﺓ ﻴﺠﺏ ﺃﻥ ﻴﺄﺨﺫ ﻗﻴﻤـﺔ‬
‫ﺒﻴﻥ ‪ 0‬ﻭ ‪350‬‬
‫ﻨﻔﺘﺢ ﺍﻟﺠﺩﻭل ‪ Trips‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪ FileÆOpen Æ table‬ﺜﻡ ﻨﺨﺘﺎﺭ ‪ TableÆ Restructure‬ﻓﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ﺘﻌﺩﻴل‬
‫ﺍﻟﺠﺩﻭل‬
‫‪ Validity Checks‬ﻤﻥ ﺍﻟﻼﺌﺤﺔ ‪ Table Properties‬ﺜﻡ ﻨﺨﺘﺎﺭ ﺍﻟﺤﻘل ‪ Company‬ﻭﻨﻔﻌـل ﺍﻟﺨﻴـﺎﺭ ‪Required‬‬
‫‪.Field‬‬
‫ﺜﻡ ﻨﺨﺘﺎﺭ ﺍﻟﺤﻘل ‪ CardNo‬ﻭﻨﻀﻊ ﻓﻲ ‪ Minimum‬ﺍﻟﻘﻴﻤﺔ ‪ 0‬ﻭﻓﻲ ‪ Maximum‬ﺍﻟﻘﻴﻤﺔ ‪. 350‬‬
‫ﻨﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Save‬ﻟﺤﻔﻅ ﺍﻟﺘﻐﻴﺭﺍﺕ ‪.‬‬
‫‪ 2‬ـ ﺘﺤﺩﻴﺩ ﺠﺩﻭل ﺍﻟﺒﺤﺙ ‪: Table Lookup‬‬
‫ﻴﻤﻜﻥ ﺘﺤﺩﻴﺩ ﻗﻴﻤﺔ ﻟﺤﻘل ﻤﺎ ﻓﻲ ﺠﺩﻭل ﻋﺒﺭ ﻻﺌﺤﺔ ﻤﻥ‬
‫ﺍﻟﻘﻴﻡ ﻤﻥ ﺠﺩﻭل ﺁﺨﺭ ‪ ،‬ﻴﺩﻋﻰ ﺍﻟﺠﺩﻭل ﺍﻵﺨﺭ ﺒﺠﺩﻭل‬
‫ﺍﻟﺒﺤﺙ ‪.‬‬
‫ﻤﺜﺎل ‪ :‬ﻨﻌﻠﻡ ﺃﻥ ﻗﻴﻤﺔ ﺍﻟﺤﻘل ﺭﻗﻡ ﺍﻟﻤﺴﺎﻓﺭ ﻓﻲ ﺠـﺩﻭل‬
‫ﺍﻟﻤﺴﺎﻓﺭﻭﻥ ﻭﺍﻟﺭﺤﻼﺕ ﻴﺠـﺏ ﺃﻥ ﺘﻜـﻭﻥ ﻤـﺴﺎﻭﻴﺔ‬
‫ﻹﺤﺩﻯ ﻗﻴﻡ ﺍﻟﻌﻤـﻭﺩ ﺭﻗـﻡ ﺍﻟﻤـﺴﺎﻓﺭ ﻓـﻲ ﺠـﺩﻭل‬
‫‪92‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﻤﺴﺎﻓﺭﻭﻥ ﻜﻤﺎ ﺃﻥ ﺍﻟﻘﻴﻤﺔ ﺭﻗﻡ ﺍﻟﺭﺤﻠﺔ ﻓﻲ ﺠﺩﻭل ﺍﻟﻤﺴﺎﻓﺭﻭﻥ ﻭﺍﻟﺭﺤﻼﺕ ﻴﺠﺏ ﺃﻥ ﺘﻜﻭﻥ ﻤﺴﺎﻭﻴﺔ ﻹﺤﺩﻯ ﻗﻴﻡ ﺍﻟﻌﻤـﻭﺩ‬
‫ﺭﻗﻡ ﺍﻟﺭﺤﻠﺔ ﻓﻲ ﺠﺩﻭل ﺍﻟﺭﺤﻼﺕ ﻟﺘﺤﻘﻴﻕ ﺫﻟﻙ ‪:‬‬
‫ﺍﻓﺘﺢ ﺍﻟﺠﺩﻭل ‪ PassAndTrips‬ﻭﺍﺩﺨل ﺇﻟﻰ ﺍﻟﻨﺎﻓﺫﺓ ﺘﻌﺩﻴل ﺍﻟﺠﺩﻭل ‪Table Æ Restructure‬‬
‫ﺍﺨﺘﺭ ﺍﻟﺤﻘل ‪ PNo‬ﻭﺍﺨﺘﺭ ‪ Table LookUp‬ﻤﻥ ﺍﻟﻼﺌﺤﺔ ‪ Table Properties‬ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪Define‬‬
‫ﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻤﺠﺎﻭﺭﺓ ‪:‬‬
‫ﻤﻥ ﺍﻟﻼﺌﺤﺔ ‪ Lookup Table‬ﺍﺨﺘﺭ ﺍﻟﺠﺩﻭل ‪ Passengers.db‬ﻭﺍﻀﻐﻁ ﻋﻠﻰ ‪. Ok‬‬
‫ﺃﻋﺩ ﻨﻔﺱ ﺍﻟﺨﻁﻭﺍﺕ ﻟﻠﺒﺤﺙ ﻋﻥ ﻗﻴﻤﺔ ‪ TripNo‬ﻓﻲ ﺍﻟﺠﺩﻭل ‪. Trips‬‬
‫ﻟﻥ ﻨﺸﺭﺡ ﻫﺫﻩ ﺍﻟﻤﻴﺯﺓ ﺒﻤﺯﻴﺩ ﻤﻥ ﺍﻟﺘﻔﺼﻴل ﻷﻥ ﺘﻁﺒﻴﻘﻬﺎ ﺒﺭﻤﺠﻴﹰﺎ ﺃﺴﻬل ‪ ..‬ﻭﻟﻜﻥ ﺴﻨﺘﻌﻠﻡ ﻓﺎﺌﺩﺘﻬﺎ ﻋﻨﺩ ﺇﺩﺨـﺎل ﻗـﻴﻡ ﺇﻟـﻰ‬
‫ﺍﻟﺠﺩﻭل ‪.‬‬
‫‪ 3‬ـ ﺍﻟﻔﻬﺭﺴﺔ ﺍﻟﺜﺎﻨﻭﻴﺔ ‪:Secondary index‬‬
‫ﺘﺴﺘﺨﺩﻡ ﺍﻟﻔﻬﺭﺴﺔ ﺍﻟﺜﺎﻨﻭﻴﺔ ﻟﺘﺭﺘﻴﺏ ﺍﻟﺠﺩﻭل ﺒﺘﺭﺘﻴﺏ ﻤﺨﺘﻠﻑ ﻋﻥ ﺍﻟﺘﺭﺘﻴﺒﺏ ﺍﻟﻤﻔﺘﺎﺤﻲ ﻟﻠﺠﺩﻭل ) ﺃﻱ ﻴﺨﺘﻠﻑ ﻋـﻥ ﺘﺭﺘﻴـﺏ‬
‫ﺍﻟﻤﻔﺘﺎﺡ ﺍﻟﺭﺌﻴﺴﻲ ( ‪.‬‬

‫ﻤﺎﺫﺍ ﺘﻌﻨﻲ ﺍﻟﻔﻬﺎﺭﺱ ﺍﻟﺜﺎﻨﻭﻴﺔ ) ﻟﻺﻁﻼﻉ (‪:‬‬

‫ﺍﻓﺘﺭﺽ ﺃﻨﹼﻙ ﺘﺭﻴﺩ ﺃﻥ ﺘﺒﺤﺙ ﻋﻥ ﻗﻴﻤﺔ ﻤﻌﻴ‪‬ﻨﺔ ﻓﻲ ﺃﺤﺩ ﺍﻷﻋﻤﺩﺓ‪ ،‬ﻜﺄﻥ ﺘﺭﻴﺩ ﺍﻟﺒﺤﺙ ﻤﺜﻼ ﻋﻥ )ﺃﺤﻤﺩ ﺴﻌﻴﺩ( ﻓﻲ ﺤﻘل ﺍﺴـﻡ‬
‫ﻥ ﺍﻟﻜﻤﺒﻴﻭﺘﺭ ﺴﻴﻔﺤﺹ ﺃﺴﻤﺎﺀ ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻭﺍﺤـﺩﺍ ﻭﺭﺍﺀ ﺍﻵﺨـﺭ ﻤـﻥ ﺍﻟﺒﺩﺍﻴـﺔ‬
‫ﺍﻟﻤﺴﺎﻓﺭ ‪ ..‬ﺃﻭ‪‬ل ﻤﺎ ﺴﻴﺠﻭل ﺒﺫﻫﻨﻙ ﻫﻭ ﺃ ‪‬‬
‫ﻟﻠﻨﻬﺎﻴﺔ‪ ..‬ﻟﻸﺴﻑ‪ :‬ﺭﺒ‪‬ﻤﺎ ﺘﺒﺩﻭ ﻫﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﺴﻬﻠﺔ‪ ،‬ﻭﻟﻜﻨﹼﻬﺎ ﺃﺴﻭﺃ ﻁﺭﻴﻘﺔ ﻴﻤﻜﻥ ﺃﻥ ﻴﺘ ‪‬ﻡ ﺍﻟﺒﺤﺙ ﺒﻬﺎ‪ ،‬ﻷﻨﹼﻬﺎ ﻗﺩ ﺘﺘﺴﺒ‪‬ﺏ ﻓﻲ ﺒﻁ ٍﺀ‬
‫ﻑ ﺃﻭ‬
‫ﻥ ﺍﻟﻌﻤﻭﺩ ﻗﺩ ﻴﺤﺘﻭﻱ ﻋﻠﻰ ﻋﺩﺩ ﻜﺒﻴﺭ ﻤﻥ ﺍﻟﺼﻔﻭﻑ‪ ،‬ﻗﺩ ﻴﺯﻴﺩ ﻋـﻥ ﻋـﺸﺭﺓ ﺁﻻ ٍ‬
‫ﺸﻨﻴﻊ ﻓﻲ ﺃﺩﺍﺀ ﺍﻟﺒﺭﻨﺎﻤﺞ‪ ،‬ﺨﺎﺼ‪‬ﺔ ﻭﺃ ‪‬‬
‫ﺃﻜﺜﺭ‪.‬‬
‫ﻥ ﺍﻟﺒﺤﺙ ﻓـﻲ ﻋﻤـﻭﺩ ﻤﺭﺘﹼـﺏ‬
‫ﻥ ﻫﻨﺎﻙ ﺍﻟﻌﺩﻴﺩ ﻤﻥ ﺍﻟﻁﺭﻕ ﻟﺘﺴﺭﻴﻊ ﺍﻟﺒﺤﺙ‪ ،‬ﺘﺒﺩﺃ ﺒﺘﺭﺘﻴﺏ ﺍﻟﻌﻤﻭﺩ ﺃﺒﺠﺩﻴ‪‬ﺎ‪ ،‬ﻭﺫﻟﻙ ﻷ ‪‬‬
‫ﻟﻬﺫﺍ ﻓﺈ ‪‬‬
‫ﺃﺴﺭﻉ ﺒﻜﺜﻴﺭ ﻤﻥ ﺍﻟﺒﺤﺙ ﻓﻲ ﻋﻤﻭﺩ ﻋﺸﻭﺍﺌﻲ‪ ،‬ﺨﺎﺼ‪‬ﺔ ﻤﻊ ﺍﺴﺘﺨﺩﺍﻡ ﻁﺭﻴﻘﺔ ﺒﺤﺙ ﺠﻴ‪‬ﺩﺓ‪،‬ﻭﻟﻜﻥ‪ ،‬ﺭﻏﻡ ﺴﺭﻋﺔ ﻫـﺫﻩ ﺍﻟﺒﺤـﺙ‬
‫ﻥ ﺍﻟﺘﺭﺘﻴﺏ ﻨﻔﺴﻪ ﻗﺩ ﻴﻜﻭﻥ ﻤﺄﺴﺎﺓ!‪ ..‬ﻫل ﺘﺘﺨﻴ‪‬ل ﻜﻡ ﻤﻥ ﺍﻟﻭﻗﺕ ﻴﻤﻜﻥ ﺃﻥ ﻴﻀﻴ‪‬ﻌﻪ ﺒﺭﻨﺎﻤﺠـﻙ ﻟﺘﺭﺘﻴـﺏ‬
‫ﺒﻌﺩ ﺍﻟﺘﺭﺘﻴﺏ‪ ،‬ﺇﻻ ﺇ ‪‬‬
‫ﺹ ﻤﺜﻼ؟‪ ..‬ﻓﻤﺎ ﺒﺎﻟﻙ ﺇﺫﻥ ﺤﻴﻨﻤﺎ ﻴﻘﻭﻡ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒﺘﻜﺭﺍﺭ ﺍﻟﺒﺤﺙ ﻓﻲ ﻨﻔﺱ ﺍﻟﻌﻤﻭﺩ ﺃﻜﺜﺭ ﻤﻥ ﻤﺭ‪‬ﺓ؟!‬
‫ﺨﻤﺴﻴﻥ ﺃﻟﻑ ﻨ ‪‬‬
‫ﺇﺫﻥ ﻤﺎ ﺍﻟﺤل؟‬
‫ﺒﺴﻴﻁ ﺠﺩ‪‬ﺍ‪ :‬ﻨﺭﺘﹼﺏ ﺍﻟﻌﻤﻭﺩ ﻓﻲ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻨﺫ ﺍﻟﺒﺩﺍﻴﺔ!‬
‫ﻱ ﻤﻨﻬـﺎ ﺴـﻭﻑ ﻨﺭﺘﹼـﺏ‬
‫ﺠﻤﻴل‪ ،‬ﻭﻟﻜﻥ ﻤﺎﺫﺍ ﻟﻭ ﻜﺎﻥ ﺍﻟﺠﺩﻭل ﻴﺤﺘﻭﻱ ﻋﻠﻰ ﺃﻜﺜﺭ ﻤﻥ ﻋﻤﻭﺩ ﺘﺤﺘﺎﺝ ﻟﻠﺒﺤﺙ ﻓﻴﻬﺎ‪ ،‬ﻓﺘﺒﻌﺎ ﻷ ‪‬‬
‫ﺍﻟﺠﺩﻭل؟!!‬
‫ﻲ‪ :‬ﺍﻟﻔﻬﺎﺭﺱ ‪ ..Indexes‬ﺘﺨﻴ‪‬ل ﻤﻌﻲ ﺃﻨﹼﻨﺎ ﻁﻠﺒﻨﺎ ﻤﻥ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻨﺸﺎﺀ ﻓﻬـﺭﺱ ﻟﻌﻤـﻭﺩ ﺍﺴـﻡ‬
‫ل ﺍﻟﻌﻤﻠ ‪‬‬
‫ﻫﻨﺎ ﻴﺒﺭﺯ ﺍﻟﺤ ّ‬
‫ﻲ‬
‫ﺍﻟﻤﺴﺎﻓﺭ ‪ ..‬ﻫﻨﺎ ﺴﺘﻘﻭﻡ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺘﺭﺘﻴﺏ ﻫﺫﺍ ﺍﻟﻌﻤﻭﺩ‪ ،‬ﻤﻊ ﺇﻨﺸﺎﺀ ﻤﺎ ﻴﺸﺒﻪ ﻋﻤﻭﺩﺍ ﺠﺩﻴﺩﺍ ﺘﻀﻊ ﻓﻴﻪ ﺍﻟﺘﺭﺘﻴﺏ ﺍﻟﺭﻗﻤـ ‪‬‬
‫ل ﻤﺴﺎﻓﺭ‪ ..‬ﻓﻤﺜﻼ‪ ،‬ﺴﻴﺄﺨﺫ )ﺃﺤﻤﺩ ﺴﻌﻴﺩ( ﺭﻗﻡ ‪ 1‬ﻓﻲ ﻫﺫﺍ ﺍﻟﻌﻤﻭﺩ ﺍﻟﺨﻔﻲ‪ ،‬ﺒﻴﻨﻤﺎ ﺴـﻴﺄﺨﺫ )ﺘﻭﻓﻴـﻕ ﺍﻟﺤﻜـﻴﻡ( ﺭﻗـﻡ ‪،2‬‬
‫ﻟﻜ ّ‬
‫ﻭﻫﻜﺫﺍ‪. ...‬‬
‫ﺒﻬﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﺴﻨﺤﻘﹼﻕ ﻤﺎ ﻴﻠﻲ‪:‬‬
‫‪93‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻟﻥ ﻨﺤﺘﺎﺝ ﻟﺘﻐﻴﻴﺭ ﺘﺭﺘﻴﺏ ﻋﺭﺽ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ ،‬ﻭﺒﺎﻟﺘﺎﻟﻲ ﺴﻨﺘﺭﻙ ﻟﻠﻤﺴﺘﺨﺩﻡ ﺤﺭﻴ‪‬ﺔ ﺘﺭﺘﻴﺏ ﺍﻟﺒﻴﺎﻨـﺎﺕ ﻜﻤـﺎ‬
‫ﻴﺤﻠﻭ ﻟﻪ‪.‬‬
‫ل ﻫﺫﻩ ﺍﻷﻋﻤﺩﺓ‪.‬‬
‫ﻴﻤﻜﻨﻨﺎ ﺇﻨﺸﺎﺀ ﺃﻜﺜﺭ ﻤﻥ ﻓﻬﺭﺱ ﻷﻜﺜﺭ ﻤﻥ ﻋﻤﻭ ٍﺩ ﻓﻲ ﻨﻔﺱ ﺍﻟﺠﺩﻭل‪ ،‬ﻤﻤ‪‬ﺎ ﻴﻌﻨﻲ ﻗﺩﺭﺘﻨﺎ ﻋﻠﻰ ﺘﺭﺘﻴﺏ ﻜ ّ‬
‫ﺴﻨﻭﻓﹼﺭ ﻭﻗﺕ ﺘﺭﺘﻴﺏ ﺍﻟﻌﻤﻭﺩ‪ ،‬ﺃﺜﻨﺎﺀ ﺍﻟﺒﺭﻤﺠﺔ‪ ،‬ﻭﺇﻥ ﻜﺎﻥ ﻫﺫﺍ ﺍﻟﻭﻗﺕ ﺴﻴﺴﺘﻬﻠﻙ ﻋﻨﺩ ﺇﻨﺸﺎﺀ ﺍﻟﻔﻬﺭﺱ ﻷﻭ‪‬ل ﻤﺭ‪‬ﺓ‪.‬‬
‫ﺴﺘﻜﻭﻥ ﻋﻤﻠﻴ‪‬ﺔ ﺍﻟﺒﺤﺙ ﺃﺴﺭﻉ‪ ،‬ﺤﻴﺙ ﺴﻴﺘ ‪‬ﻡ ﺍﻟﺒﺤﺙ ﻓﻲ ﺍﻟﺴﺠﻼﺕ ﺤﺴﺏ ﺘﺭﺘﻴﺏ ﻓﻬﺎﺭﺴﻬﺎ‪.‬‬
‫ﻭﻓﻲ ﺍﻹﻤﻜﺎﻥ ﻜﺫﻟﻙ ﺇﻨﺸﺎﺀ ﻓﻬﺭﺱ ﻷﻜﺜﺭ ﻤﻥ ﻋﻤﻭﺩ ﻤﻌﺎ‪ ،‬ﺤﻴﺙ ﺴﻴﺘﻡ ﺍﻟﺘﺭﺘﻴﺏ ﺘﺒﻌﺎ ﻟﻠﻌﻤﻭﺩ ﺍﻷﻭ‪‬ل‪ ،‬ﻓﺈﻥ ﺘﻤﺎﺜﻠﺕ ﻗﻴﻡ ﺒﻌﺽ‬
‫ﺍﻟﺼﻔﻭﻑ‪ ،‬ﻴﺘﻡ ﺘﺭﺘﻴﺏ ﻫﺫﻩ ﺍﻟﺼﻔﻭﻑ ﻋﻠﻰ ﺃﺴﺎﺱ ﺍﻟﻌﻤﻭﺩ ﺍﻟﺜﺎﻨﻲ‪.‬‬
‫ﻭﻟﻜﻥ‪ ..‬ﻁﺒﻌﺎ ﻻ ﺘﻭﺠﺩ ﻁﺭﻴﻘﺔ ﻤﺜﺎﻟﻴ‪‬ﺔ‪ ..‬ﻫﻨﺎﻙ ﻋﻴﺒﺎﻥ ﺃﺴﺎﺴﻴ‪‬ﺎﻥ ﻟﻬﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ‪:‬‬
‫ﺍﻟﻔﻬﺎﺭﺱ ﺍﻟﻤﻨﺸﺌﺔ ﻴﺘ ‪‬ﻡ ﺤﻔﻅﻬﺎ ﻓﻲ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ ،‬ﻤﻤ‪‬ﺎ ﻴﻌﻤل ﻋﻠﻰ ﺯﻴﺎﺩﺓ ﺤﺠﻤﻬﺎ‪ ..‬ﻟﻬﺫﺍ ﺇﺫﺍ ﻜﺎﻥ ﺤﺠـﻡ ﻗﺎﻋـﺩﺓ ﺒﻴﺎﻨﺎﺘـﻙ‬
‫ﻜﺒﻴﺭﺍ‪ ،‬ﻓﻼ ﺒ ‪‬ﺩ ﺃﻥ ﺘﻭﺍﺯﻥ ﺒﻴﻥ ﺤﺎﺠﺘﻙ ﻟﺘﻭﻓﻴﺭ ﺍﻟﻭﻗﺕ ﻭﺤﺎﺠﺘﻙ ﻟﺘﻭﻓﻴﺭ ﺍﻟﺤﺠﻡ!‬
‫ﻥ ﺒﺭﻨﺎﻤﺠﻙ ﺴﻴﺤﺘﺎﺝ ﻟﻠﺒﺤﺙ ﻓﻴﻬﺎ ﺒﻐﺯﺍﺭﺓ‪.‬‬
‫ﻭﻜﻘﺎﻋﺩﺓ‪ :‬ﻻ ﺘﻨﺸﺊ ﻓﻬﺎﺭﺱ ﺇﻻ ﻟﻠﺤﻘﻭل ﺍﻟﺘﻲ ﺘﺘﻭﻗﹼﻊ ﺃ ‪‬‬
‫ﻱ ﺼﻑﹼ‪ ،‬ﻻ ﺒ ‪‬ﺩ ﻤﻥ ﺇﻋـﺎﺩﺓ ﺘﺤـﺩﻴﺙ ﺍﻟﻔﻬـﺎﺭﺱ ﻟﻤﺭﺍﻋـﺎﺓ‬
‫ﻱ ﺨﺎﻨﺔ ﻓﻲ ﺍﻟﻌﻤﻭﺩ ﺃﻭ ﺤﺫﻑ ﺃﻭ ﺇﻀﺎﻓﺔ ﺃ ‪‬‬
‫ﻋﻨﺩ ﺘﻌﺩﻴل ﻗﻴﻤﺔ ﺃ ‪‬‬
‫ﺍﻻﺨﺘﻼﻑ ﺍﻟﺫﻱ ﺃﺤﺩﺜﺘﻪ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺠﺩﻴﺩﺓ‪ ..‬ﻤﺜل ﻫﺫﺍ ﺍﻷﻤﺭ ﻴﺴﺒ‪‬ﺏ ﻋﻴﺒﺎ ﺨﻁﻴﺭﺍ‪ ،‬ﻫﻭ ﺒﻁﺀ ﻋﻤﻠﻴ‪‬ـﺎﺕ ﺍﻟﺘﺤـﺩﻴﺙ ﻭﺍﻟﺤـﺫﻑ‬
‫ﻭﺍﻹﻀﺎﻓﺔ ﺒﻁﺭﻴﻘﺔ ﻤﻠﺤﻭﻅﺔ‪ ،‬ﺘﺯﺩﺍﺩ ﺴﻭﺀﺍ ﻤﻊ ﺍﺯﺩﻴﺎﺩ ﻁﻭل ﺍﻟﺠﺩﻭل‪ ..‬ﻫﻨﺎ ﻴﺠﺏ ﺃﻥ ﺘﻭﺍﺯﻥ ﻓﻲ ﺒﺭﻨﺎﻤﺠﻙ‪ ،‬ﺒﻴﻥ ﺤﺎﺠﺘـﻙ‬
‫ﻟﺴﺭﻋﺔ ﺍﻟﺒﺤﺙ ﻭﺤﺎﺠﺘﻙ ﻟﺴﺭﻋﺔ ﺍﻟﺘﺤﺩﻴﺙ ﻭﺍﻟﺤﺫﻑ ﻭﺍﻹﻀﺎﻓﺔ‪ ..‬ﻓﺈﺫﺍ ﻜﺎﻥ ﻤﻥ ﺍﻟﻤﺘﻭﻗﹼﻊ ﺃﻥ ﻴﻘﻭﻡ ﺒﺭﻨﺎﻤﺠﻙ ﺒﻤﺌﺎﺕ ﻤﻥ ﻫﺫﻩ‬
‫ﺍﻟﻌﻤﻠﻴ‪‬ﺎﺕ ﺒﻁﺭﻴﻘﺔ ﻤﺘﺘﺎﻟﻴﺔ‪ ،‬ﻓﻤﻥ ﺍﻷﻓﻀل ﺤﺫﻑ ﺍﻟﻔﻬﺭﺱ ﺇﻟﻰ ﺃﻥ ﺘﻨﺘﻬﻲ ﻫﺫﻩ ﺍﻟﻌﻤﻠﻴ‪‬ﺎﺕ‪ ،‬ﺜ ‪‬ﻡ ﺇﻋﺎﺩﺓ ﺇﻨﺸﺎﺌﻪ ﻤﺭ‪‬ﺓ ﺃﺨﺭﻯ ﻗﺒـل‬
‫ﺍﻟﺸﺭﻭﻉ ﻓﻲ ﻋﻤﻠﻴ‪‬ﺎﺕ ﺍﻟﺒﺤﺙ‪ ،‬ﺭﻏﻡ ﻤﺎ ﺘﻀﻴ‪‬ﻌﻪ ﻋﻤﻠﻴ‪‬ﺔ ﺇﻋﺎﺩﺓ ﺇﻨﺸﺎﺀ ﺍﻟﻔﻬﺭﺱ ﻤﻥ ﻭﻗﺕ!‬
‫ﻹﻨﺸﺎﺀ ﻓﻬﺭﺱ ﺜﺎﻨﻭﻱ ‪:‬‬
‫ﺒﻔﺭﺽ ﺃﻨﻨﺎ ﻨﺭﻴﺩ ﺇﻨﺸﺎﺀ ﻓﻬﺭﺱ ﺜﺎﻨﻭﻱ ﻟﻠﺤﻘل ﺍﺴﻡ ﺍﻟﻤﺴﺎﻓﺭ ﻓﻲ ﺠﺩﻭل ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ‪.‬‬
‫ﻗﻡ ﺒﻔﺘﺢ ﺍﻟﺠﺩﻭل ﺜﻡ ﺍﺨﺘﺭ ‪ TableÆ Restructure‬ﻤـﻥ ﺍﻟﻼﺌﺤـﺔ‬
‫‪ Table Properties‬ﺍﺨﺘﺭ ﺍﻟﻘﻴﻤﺔ ‪ Secondary Index‬ﻭﺍﻀﻐﻁ‬
‫ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Define‬ﻋﻨﺩﺌﺫ ﺴﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻤﺠﺎﻭﺭﺓ ‪:‬‬
‫ﺍﺨﺘﺭ ﺍﻟﺤﻘل ‪ PName‬ﻤﻥ ﺍﻟﻼﺌﺤـﺔ ‪ Fields‬ﻭﺍﻀـﻐﻁ ﻋﻠـﻰ ‪Æ‬‬
‫ﺴﻴﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺍﺴﻡ ﺍﻟﺤﻘل ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ‪ Indexed Fields‬ﻨﻼﺤـﻅ‬
‫ﻭﺠﻭﺩ ﺍﻟﺨﻴﺎﺭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺍﻟﻘﺴﻡ ‪: Index Option‬‬
‫‪ 1‬ـ ‪ : Unique‬ﻓﻌل ﻫﺫﺍ ﺍﻟﺨﻴﺎﺭ ﺇﺫﺍ ﻜﺎﻨﺕ ﻗﻴﻤﺔ ﻫﺫﺍ ﺍﻟﺤﻘل ﻓﺭﻴﺩﺓ‬
‫ﺃﻱ ﻻ ﻴﻤﻜﻥ ﺃﻥ ﺘﺘﻜﺭﺭ ) ﻓﻲ ﻤﺜﺎﻟﻨﺎ ﻗﺩ ﻴﻜﻭﻥ ﻫﻨﺎﻙ ﻤﺴﺎﻓﺭﻴﻥ ﻟﻬﻤـﺎ‬
‫ﻨﻔﺱ ﺍﻻﺴﻡ ﻟﺫﻟﻙ ﻻ ﻴﻤﻜﻥ ﺘﻔﻌﻴل ﻫﺫﺍ ﺍﻟﺨﻴﺎﺭ ( ‪.‬‬
‫‪ 2‬ـ ‪ : Maintained‬ﻓﻌل ﻫﺫﺍ ﺍﻟﺨﻴﺎﺭ ﺇﺫﺍ ﺃﺭﺩﺕ ﻤﻥ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺘﺤﺩﻴﺙ ﺠﺩﻭل ﺍﻟﻔﻬﺭﺱ ﻜﻠﻤﺎ ﺘﻡ ﺘﻌﺩﻴل ﺍﻟﺒﻴﺎﻨـﺎﺕ‬
‫ﻓﻲ ﺍﻟﺠﺩﻭل ﻭﻓﻲ ﺤﺎل ﻋﺩﻡ ﺘﻔﻌﻴﻠﻪ ﻴﺘﻡ ﺘﺤﺩﻴﺙ ﺠﺩﻭل ﺍﻟﻔﻬﺭﺱ ﻓﻘﻁ ﻋﻨﺩ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻔﻬﺭﺱ ‪.‬‬
‫‪ 3‬ـ ‪ : Case Sensitive‬ﻓﻌل ﻫﺫﺍ ﺍﻟﺨﻴﺎﺭ ﺇﺫﺍ ﺃﺭﺩﺕ ﻤﻥ ﺍﻟﻔﻬﺭﺱ ﺍﻟﺘﻤﻴﺯ ﺒﻴﻥ ﺍﻟﺤﺭﻭﻑ ﺍﻟﻜﺒﻴﺭﺓ ﻭ ﺍﻟﺼﻐﻴﺭﺓ ‪.‬‬
‫‪ 4‬ـ ‪ : Descending‬ﻓﻌل ﻫﺫﺍ ﺍﻟﺨﻴﺎﺭ ﺇﺫﺍ ﺃﺭﺩﺕ ﺘﺭﺘﻴﺏ ﺍﻟﺤﻘﻭل ﺘﻨﺎﺯﻟﻴﹰﺎ ‪.‬‬
‫‪94‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Ok‬ﺴﺘﻁﺎﻟﺏ ﺒﺈﻋﻁﺎﺀ ﺍﺴﻡ ﻟﻠﻔﻬﺭﺱ ﺃﻋﻁﻪ ﺍﻻﺴﻡ ‪. PNameIndex‬‬
‫ﻤﻼﺤﻅﺔ ‪:‬‬
‫‪ 1‬ـ ﻴﻤﻜﻥ ﺘﻁﺒﻴﻕ ﺍﻟﻔﻬﺎﺭﺱ ﺍﻟﺜﺎﻨﻭﻴﺔ ﻋﻠﻰ ﺃﻜﺜﺭ ﻤﻥ ﺤﻘل ) ﻟﻜل ﺤﻘل ﻓﻬﺭﺱ ﺜﺎﻨﻭﻱ ( ‪.‬‬
‫ﻼ ﺇﻨﺸﺎﺀ ﻓﻬﺭﺱ ﺜﺎﻨﻭﻱ ﻟﺤﻘﻠﻲ ﺍﺴﻡ ﺍﻟﻤﺴﺎﻓﺭ‬
‫‪ 2‬ـ ﻴﻤﻜﻥ ﺘﻁﺒﻴﻕ ﻓﻬﺭﺱ ﺜﺎﻨﻭﻱ ﻭﺍﺤﺩ ﻋﻠﻰ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﺤﻘﻭل ﻴﻤﻜﻥ ﻤﺜ ﹰ‬
‫ﻭﺍﻟﺠﻨﺴﻴﺔ ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﻓﻲ ﺤﺎل ﻜﻨﺎ ﻨﺒﺤﺙ ﻓﻲ ﺠﺩﻭل ﻤﺎ ﻋﻠﻰ ﺍﻟﺤﻘﻠﻴﻥ ﻤﻌﹰﺎ ‪.‬‬
‫‪ 3‬ـ ﺴﺘﺘﻀﺢ ﻫﺫﻩ ﺍﻷﻤﻭﺭ ﻻﺤﻘﹰﺎ ﻋﻨﺩ ﺩﺭﺍﺴﺔ ﺍﻟﺒﺤﺙ ﻓﻲ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪.‬‬
‫ﺘﻌﺭﻴﻑ ﻋﻼﻤﺔ ﻤﺭﺠﻌﻴﺔ ﻤﺘﻜﺎﻤﻠﺔ ‪: Referential Integrity‬‬
‫ﻭﺠﺩﻨﺎ ﺴﺎﺒﻘﹰﺎ ﻜﻴﻑ ﻴﺘﻡ ﺍﻟﺭﺒﻁ ﺒﻴﻥ ﺠﺩﺍﻭل ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺸﻜل ﻨﻅﺭﻱ ) ﺍﻟﺭﺒﻁ ﺒﻴﻥ ﺠﺩﻭﻟﻲ ﺍﻟﻤﺅﻟﻔﻴﻥ ﻭﺍﻟﻜﺘﺏ ﻭﺍﻟـﺭﺒﻁ‬
‫ﺒﻴﻥ ﺠﺩﻭﻟﻲ ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻭﺠﺩﻭل ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻭﺍﻟﺭﺤﻼﺕ ( ﺃﻱ ﺒﻌﺒﺎﺭﺓ ﺃﺨﺭﻯ ﺴﻨﻘﻭﻡ ﺍﻵﻥ ﺒﺘﻌﺭﻴﻑ ﻤﻔﺘﺎﺡ ﺜﺎﻨﻭﻱ ﻓﻲ ﺠﺩﻭل‬
‫ﻤﺎ ﻴﺄﺨﺫ ﻗﻴﻤﺔ ﻤﻥ ﺠﺩﻭل ﺁﺨﺭ ‪.‬‬
‫ﺇﺫﺍ ﺃﻨﺸﺄﻨﺎ ﻋﻼﻤﺔ ﻤﺭﺠﻌﻴﺔ ﻤﺘﻜﺎﻤﻠﺔ ﺒﻴﻥ ﺍﻟﺠﺩﻭﻟﻴﻥ "ﺍﻟﻤﺴﺎﻓﺭﻴﻥ" ﻭ"ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻭﺍﻟﺭﺤﻼﺕ" ﻓﻬﺫﺍ ﻴﻌﻨـﻲ ﺃﻥ ﺍﻟﺤﻘـل ﺭﻗـﻡ‬
‫ﺍﻟﻤﺴﺎﻓﺭ ﻓﻲ ﺠﺩﻭل "ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻭﺍﻟﺭﺤﻼﺕ " ﺴﻴﺄﺨﺫ ﻗﻴﻤﻪ ﻤﻥ ﺍﻟﺤﻘل ﺭﻗﻡ ﺍﻟﻤﺴﺎﻓﺭ ﻓﻲ ﺠﺩﻭل ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ‪.‬‬
‫ﻴﺩﻋﻰ ﺍﻟﺠﺩﻭل ﺍﻟﺫﻱ ﺴﻨﺤﺼل ﻤﻨﻪ ﻋﻠﻰ ﺍﻟﻘﻴﻡ ﺒﺎﻟﺠﺩﻭل ﺍﻷﺏ ﻭﺍﻟﺠﺩﻭل ﺍﻟﺫﻱ ﺴﻴﺨﺯﻥ ﺍﻟﻘﻴﻡ ﺒﺎﻟﺠﺩﻭل ﺍﻻﺒﻥ ‪.‬‬
‫ﻹﻨﺸﺎﺀ ﻋﻼﻤﺔ ﺘﻜﺎﻤل ﻤﺭﺠﻌﻴﺔ ‪:‬‬
‫ﺍﻓﺘﺢ ﺍﻟﺠﺩﻭل ﺍﻹﺒﻥ ‪ PassAndTrips‬ﻭﺍﺨﺘـﺭ ﺍﻷﻤـﺭ ‪ TableÆ Restructure‬ﻭﺍﺨﺘـﺭ ﺍﻟﻘﻴﻤـﺔ ‪Referential‬‬
‫‪ Integrity‬ﻤﻥ ﺍﻟﻼﺌﺤﺔ ‪ Table Properties‬ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪: Define‬‬
‫ﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻨﺨﺘﺎﺭ ﺍﻟﺤﻘل ‪ PNo‬ﻤﻥ ﻻﺌﺤﺔ ﺍﻟﺤﻘﻭل ﻭﻨﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Æ‬ﺜﻡ ﻨﺨﺘﺎﺭ ﺠـﺩﻭل ﺍﻟﻤـﺴﺎﻓﺭﻴﻥ ﻤـﻥ ﺍﻟﻼﺌﺤـﺔ ‪Table‬‬
‫ﻭﻨﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪Å‬‬
‫ﻴﺠـــﺏ ﺒﻌـــﺩ ﺫﻟـــﻙ ﺘﺤﺩﻴـــﺩ ﻨـــﻭﻉ ﺍﻟﺘﻌـــﺩﻴل ﻓـــﻲ ﺍﻟـــﺼﻨﺩﻭﻕ ‪Update Rule‬‬

‫‪ 1‬ـ ﺍﻟﺨﻴﺎﺭ ‪ : Cascade‬ﻫﺫﺍ ﺍﻟﺨﻴﺎﺭ ﻴﻌﻨﻲ ﺃﻨﻪ ﺃﻱ ﺘﻌﺩﻴل ﻓﻲ ﺍﻟﺤﻘل ﺍﻟﻤﻭﺠﻭﺩ ﻓﻲ ﺍﻟﺠﺩﻭل ﺍﻷﺏ ﺴﻴﺅﺩﻱ ﺇﻟﻰ ﺘﻌﺩﻴﻼﺕ‬
‫ﻓﻲ ﺍﻟﺤﻘﻭل ﺍﻟﻤﺭﺒﻭﻁﻪ ﻤﻌﻪ ﻓﻲ ﺠﺩﻭل ﺍﻻﺒﻥ ) ﻓﻲ ﺤﺎل ﺤﺫﻑ ﺍﻟﺤﻘل ﺴﺠل ﻤﺎ ﻤﻥ ﺠﺩﻭل ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﺴﻴﺘﻡ ﺤﺫﻑ‬
‫ﺍﻟﺴﺠﻼﺕ ﺍﻟﻤﺭﺘﺒﻁﺔ ﻤﻌﻪ ﻓﻲ ﺠﺩﻭل " ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻭﺍﻟﺭﺤﻼﺕ " ‪،‬‬

‫‪95‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ 2‬ـ ﺍﻟﺨﻴﺎﺭ ‪ : Prohibit‬ﻴﻤﻨﻊ ﻫﺫﺍ ﺍﻟﺤﻘل ﺘﺤﺩﻴﺙ ﺍﻟﺤﻘﻭل ﻓﻲ ﺠﺩﻭل ﺍﻷﺏ ﺇﺫﺍ ﻜﺎﻨﺕ ﻤﺭﺘﺒﻁﺔ ﻤﻊ ﺤﻘﻭل ﻓـﻲ ﺠـﺩﻭل‬
‫ﺍﻻﺒﻥ ) ﻻ ﻴﻤﻜﻥ ﺤﺫﻑ ﺴﺠل ﻤﻥ ﺠﺩﻭل ﺃﺏ ﻤﺭﺘﺒﻁ ﻤﻊ ﺴﺠﻼﺕ ﻓﻲ ﺍﻟﺠﺩﻭل ﺍﻻﺒﻥ ( ‪.‬‬
‫‪ 3‬ـ ‪ : Strict Referential Integrity‬ﻓﻌل ﻫﺫﺍ ﺍﻟﺨﻴﺎﺭ ﺇﺫﺍ ﻜﻨﺕ ﺴﺘﺴﺘﺨﺩﻡ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻫﺫﻩ ﻤﻊ ﺒـﺭﺍﻤﺞ ﻗﺩﻴﻤـﺔ‬
‫‪.Dos‬‬ ‫ﺘﻌﻤل ﺘﺤﺕ ﺍﻟﻨﻅﺎﻡ‬
‫ﺍﻀﻐﻁ ﻋﻠﻰ ﺒﻌﺩﻫﺎ ﻋﻠﻰ ﺯﺭ ‪ Ok‬ﺴﺘﻁﺎﻟﺏ ﻋﻨﺩﻫﺎ ﺒﺎﺨﺘﻴﺎﺭ ﺍﺴﻡ ﻟﻠﻌﻼﻤﺔ ﺍﻟﻤﺭﺠﻌﻴﺔ ﺃﺩﺨل ﺃﻱ ﺍﺴﻡ ﺘﺭﻴﺩﻩ ﻭﺍﻀﻐﻁ ﻋﻠـﻰ‬
‫ﻤﻭﺍﻓﻕ ‪...‬‬
‫ﻤﻼﺤﻅﺎﺕ ‪:‬‬
‫‪ 1‬ـ ﺍﻟﺨﻴﺎﺭ ‪ Prohibit‬ﻫﻭ ﺍﻟﺨﻴﺎﺭ ﺍﻟﺫﻱ ﺘﻌﻤل ﺒﻪ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨـﺎﺕ ‪ Paradox‬ﻭﻻ ﻴﻤﻜـﻥ ﺍﻻﺴـﺘﻔﺎﺩﺓ ﻤـﻥ ﺍﻟﺨﻴـﺎﺭ‬
‫‪ Cascade‬ﺇﻻ ﻓﻲ ﺤﺎل ﺍﺴﺘﺨﺩﺍﻡ ﺒﻌﺽ ﺒﺭﺍﻤﺞ ‪ SQL‬ﺍﻟﺤﺩﻴﺜﺔ‪.‬‬
‫‪ 2‬ـ ﻟﺤﺫﻑ ﺴﺠل ﺃﺏ ﻤﺭﺘﺒﻁ ﻤﻊ ﺴﺠﻼﺕ ﺃﺒﻨﺎﺀ ﻋﻠﻴﻙ ﺃﻥ ﺘﺤﺫﻑ ﺠﻤﻴﻊ ﺍﻟﺴﺠﻼﺕ ﻓﻲ ﺍﻟﺠﺩﻭل ﺍﻻﺒﻥ ﺍﻟﻤﺭﺘﺒﻁﺔ ﻤﻊ ﻫـﺫﺍ‬
‫ﺍﻟﺴﺠل ‪.‬‬
‫ـ ﺒﻨﻔﺱ ﺍﻟﻁﺭﻴﻘﺔ ﺃﺭﺒﻁ ﺒﻴﻥ ﺭﻗﻡ ﺍﻟﺭﺤﻠﺔ ﻓﻲ ﺍﻟﺠﺩﻭل " ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻭﺍﻟﺭﺤﻼﺕ " ﻤﻊ ﺭﻗﻡ ﺍﻟﺭﺤﻠﺔ ﻓﻲ ﺠﺩﻭل ﺍﻟﺭﺤﻼﺕ ‪.‬‬
‫‪ 5‬ـ ﻭﻀﻊ ﻜﻠﻤﺎﺕ ﺴﺭ ﻟﻠﺠﺩﺍﻭل ‪:‬‬
‫ﻗﺩ ﻨﺤﺘﺎﺝ ﻓﻲ ﺒﻌﺽ ﺍﻷﺤﻴﺎﻥ ﺇﻟﻰ ﺤﻤﺎﻴﺔ ﺠﺩﺍﻭل ﺃﻭ ﺍﻟﺤﻘﻭل ﻤﻥ ﺃﻥ ﻴﺼل ﺇﻟﻴﻬﺎ ﺃﻭ ﻴﺴﺘﺨﺩﻤﻬﺎ ﻏﻴﺭﻨﺎ‪ ،‬ﻟﺫﻟﻙ ﻴﻤﻜﻥ ﻭﻀـﻊ‬
‫ﻼ ﺃﻭ ﻟﺤﻘل ﺃﻭ ﻋﺩﺩ ﻤﻥ ﺤﻘﻭﻟﻪ ﻓﻘﻁ ‪.‬‬
‫ﻜﻠﻤﺔ ﺴﺭ ﻟﻠﺠﺩﻭل ﻜﺎﻤ ﹰ‬
‫ﻭﻹﻋﻁﺎﺀ ﺍﻟﺠﺩﻭل ﻜﻠﻤﺔ ﺴﺭ ﻟﺠﺩﻭل ﺍﻟﻤﺴﺎﻓﺭﻴﻥ‬
‫‪ 1‬ـ ﺍﻓﺘﺢ ﺍﻟﺠﺩﻭل ﻭﺍﺨﺘﺭ ﺍﻷﻤـﺭ ‪ Table Æ Restructure‬ﻭﺍﺨﺘـﺎﺭ ‪ Table Security‬ﻤـﻥ ﺍﻟﻼﺌﺤـﺔ ‪Table‬‬
‫‪ properties‬ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Define‬ﺴﻴﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ‬
‫ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫ﺍﻜﺘﺏ ﻜﻠﻤﺔ ﺍﻟﺴﺭ ﻓﻲ ﺍﻟﺤﻘل ‪ Master Password‬ﻭﺃﻋﺩ ﻜﺘﺎﺒﺘﻬﺎ ﻓﻲ ﺍﻟﺤﻘل‬
‫‪ Verify Master Password‬ﻭﺍﻀﻐﻁ ﻋﻠﻰ ‪.Ok‬‬
‫ﺃﻤﺎ ﻟﺘﺤﺩﻴﺩ ﻜﻠﻤﺔ ﺴﺭ ﻟﻠﺤﻘﻭل ﻨﻌﻴﺩ ﺍﻟﺨﻁﻭﺍﺕ ﺍﻟﺴﺎﺒﻘﺔ ﻭﻨﺨﺘﺎﺭ ﺒﻌﺩﻫﺎ‬
‫‪ Auxiliary Password‬ﻓﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺍﻟﻨﺎﻓﺫﺓ )ﻓﻲ ﺍﻷﺴﻔل(‪.‬‬
‫ﺃﻜﺘﺏ ﻜﻠﻤﺔ ﺍﻟﺴﺭ ﻓـﻲ ﺍﻟﺤﻘـل ‪ Current Password‬ﻭﺤـﺩﺩ ﺴـﻤﺎﺤﻴﺎﺕ‬
‫ﺍﻟﻭﺼﻭل ﻤﻥ ‪ Table rights‬ﻭﺍﻀﻐﻁ ﻋﻠﻰ ‪Add‬‬
‫ﻴﻤﻜﻨﻙ ﺃﻥ ﺘﻌﻁﻲ ﺃﻜﺜﺭ ﻤﻥ ﻜﻠﻤﺔ ﺴﺭ ﻟﻠﺤﻘل ﺍﻟﻭﺍﺤﺩ‬
‫ﺃﻭ ﻟﻤﺠﻤﻭﻋﺔ ﺤﻘﻭل ‪،‬ﺒﺎﻟﻨﺴﺒﺔ ﻟﺴﻤﺎﺤﻴﺎﺕ ﺍﻟﻭﺼﻭل‬
‫ﻓﺘﺤﺩﺩ ﻁﺭﻴﻘﺔ ﺘﻌﺎﻤل ﺍﻟﻤﺴﺘﺨﺩﻡ ﻤﻊ ﺍﻟﺠﺩﻭل ﻓـﺈﺫﺍ‬
‫ﻜﺎﻨﺕ ﺍﻟﻘﻴﻤﺔ ‪ Read Only‬ﻓﻼ ﻴﻤﻜﻥ ﻟﻠﻤـﺴﺘﺨﺩﻡ‬
‫ﺇﺩﺨﺎل ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ ، ....‬ﻜل ﻤﺭﺓ ﻴﺘﻡ ﻓﺘﺢ ﺍﻟﺠـﺩﻭل‬
‫ﻓﻴﻬﺎ ﺴﻴﻁﺎﻟﺏ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺒﺈﺩﺨﺎل ﻜﻠﻤـﺔ ﺍﻟـﺴﺭ ﻭ‬

‫‪96‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺘﻌﻁﻰ ﺍﻟﺴﻤﺎﺤﻴﺎﺕ ﻟﻬﺫﺍ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺘﺒﻌﹰﺎ ﻟﻜﻠﻤﺔ ﺍﻟﺴﺭ ﺍﻟﻤﺩﺨﻠﺔ ‪.‬‬
‫ﻟﺤﺫﻑ ﻜﻠﻤﺔ ﺴﺭ ﻭﻀﻌﺕ ﻋﻠﻰ ﺠﺩﻭل ﺃﻋﺩ ﺍﻟﺨﻁﻭﺍﺕ ﻓﻲ ‪1‬‬
‫ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Modify‬ﻭﺍﺨﺘﺭ ﺒﻌﺩﻫﺎ ﺍﻟﺯﺭ ‪. Delete‬‬
‫ﻤﻼﺤﻅﺔ ﻫﺎﻤﺔ ‪:‬‬
‫ﺇﺫﺍ ﻜﺎﻨﺕ ﺴﺭﻴﺔ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺘﻬﻤﻙ ﻓﻼ ﺘﺴﺘﺨﺩﻡ ﻗﻭﺍﻋﺩ ﺒﻴﺎﻨﺎﺕ ‪ Paradox‬ﻓﻬﻨﺎﻙ ﻤﺌﺎﺕ ﺍﻟﺒﺭﺍﻤﺞ ﺍﻟﺘﻲ ﺘﺴﺘﻁﻴﻊ ﺍﻜﺘﺸﺎﻑ‬
‫ﻜﻠﻤﺔ ﺴﺭ ﺍﻟﻘﺎﻋﺩﺓ ‪ ،‬ﻭﻴﺴﺘﻁﻴﻊ ﺃﻱ ﻫﺎﻭﻱ ﺃﻥ ﻴﺩﺨل ﺇﻟﻰ ﺠﺩﺍﻭﻟﻙ ﻭﺍﻟﺤﺼﻭل ﻋﻠﻰ ﻤﻌﻠﻭﻤﺎﺘﻬﺎ ﻭﺘﻌﺩﻴﻠﻬﺎ ‪،‬ﻋﻤﻠﻴﹰﺎ ﺃﻗﻭﻯ ﻗﻭﺍﻋﺩ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ ﺤﻴﺙ ﺍﻟﺴﺭﻴﺔ ﻭﺍﻟﺴﻤﺎﺤﻴﺎﺕ ﺃﻴﻀﹰﺎ ﻫﻲ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ MySQL‬ﻭ‪Oracle‬‬
‫ﻭ‪. MS SQL Server‬‬
‫‪ 6‬ـ ﺘﺤﺩﻴﺩ ﻟﻐﺔ ﺍﻟﺠﺩﻭل ‪: Table Language‬‬
‫ﻟﺘﺤﺩﻴﺩ ﻟﻐﺔ ﺍﻟﺠﺩﻭل ﺍﺨﺘﺭ ‪ Table Language‬ﻤﻥ ﺍﻟﻼﺌﺤﺔ ﺨﺼﺎﺌﺹ‬
‫ﺍﻟﺠﺩﻭل‬
‫ﺇﺫﺍ ﻜﺎﻨﺕ ﺒﻴﺎﻨﺎﺕ ﺍﻟﺠﺩﻭل ﺍﻟﺘﻲ ﺘﺩﺨﻠﻬﺎ ﺒﺎﻟﻠﻐـﺔ ﺍﻟﻌﺭﺒﻴـﺔ ﻓـﺄﺒﻕ ﻫـﺫﺍ‬
‫ﺍﻟﺼﻨﺩﻭﻕ ﻋﻠﻰ ﺍﻟﺨﻴﺎﺭ ﺍﻻﻓﺘﺭﺍﻀﻲ ‪. 'Ascii' ANSI‬‬
‫‪ 7‬ـ ﻋﺭﺽ ﺍﻟﺠﺩﺍﻭل ﺍﻟﺘﺎﺒﻌﺔ ﺍﻟﺠﺩﻭل ‪: Dependent Table‬‬
‫ﺒﻌﺩ ﺃﻥ ﻨﻨﺸﺊ ﻋﻼﻗﺔ ﺭﺒﻁ ﻤﺘﻜﺎﻤﻠﺔ ﺒﻴﻥ ﺍﻟﺠﺩﺍﻭل ﻨﻜﻭﻥ ﻗﺩ ﻋﺭﻓﻨﺎ ﻋﻼﻗﺔ ﺒﻴﻥ ﺠﺩﻭل ﺃﺏ ﻭﺠﺩﻭل ﺍﺒﻥ ﻭﻟﺭﺅﻴﺔ ﻫﺫﻩ ﺍﻟﻌﻼﻗﺔ‬
‫‪:‬‬
‫ﻨﻔﺘﺢ ﺍﻟﺠﺩﻭل ﺍﻷﺏ ) ‪ ( Passengers‬ﻭﻨﻔﺘﺢ ﺍﻟﻨﺎﻓﺫﺓ ﺘﻌﺩﻴل ﺍﻟﺠﺩﻭل ﺜﻡ ﻨﺨﺘـﺎﺭ ‪ Dependent Table‬ﻤـﻥ ﺍﻟﻼﺌﺤـﺔ‬
‫‪ Table properties‬ﻋﻨﺩﺌﺫ ﺘﻅﻬﺭ ﺍﻟﺠﺩﺍﻭل ﺍﻟﻤﺭﺘﺒﻁﺔ ﻤﻊ ﻫﺫﺍ ﺍﻟﺠﺩﻭل ) ‪. ( PassAndTrips‬‬
‫ﻤﻼﺤﻅﺎﺕ ‪:‬‬
‫‪ 1‬ـ ﺇﻟﻰ ﻫﻨﺎ ﻨﻜﻭﻥ ﻗﺩ ﺘﻌﻠﻤﻨﺎ ﺇﻨﺸﺎﺀ ﺠﺩﺍﻭل ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Paradox‬ﻭﻴﻜﻭﻥ ﺇﻨﺸﺎﺀ ﺠﺩﺍﻭل ﻤﻥ ﺃﻨﻭﺍﻉ ﺃﺨﺭﻯ ﻤﺸﺎﺒﻬﺔ ﻟﻬﺫﻩ‬
‫ﻼ ﺘﺨﺘﻠﻑ ﻋﻥ ﺃﻨﻭﺍﻉ ﺍﻟﺤﻘﻭل ﻓـﻲ ﺠـﺩﺍﻭل‬
‫ﺍﻟﻁﺭﻴﻘﺔ ﻭﻟﻜﻥ ﺘﺘﻐﻴﺭ ﺒﻌﺽ ﺍﻷﺸﻴﺎﺀ ﻓﺄﻨﻭﺍﻉ ﺍﻟﺤﻘﻭل ﻓﻲ ﺠﺩﺍﻭل ‪ Dbase‬ﻤﺜ ﹰ‬
‫‪ Paradox‬ﺒﺎﻻﺴﻡ ﻓﻘﻁ ﻭﻟﻜﻥ ﺘﺒﻘﻰ ﺠﻤﻴﻊ ﺃﻨﻭﺍﻉ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﺼﻤﻤﺔ ﻟﺘﺨﺯﻴﻥ ﺍﻟﻨﺼﻭﺹ ﻭ ﺍﻷﺭﻗﺎﻡ ﻭ‪....‬‬
‫‪ 2‬ـ ﻴﻔﻀل ﻓﻲ ﺍﻟﺒﺩﺍﻴﺔ ﺘﺼﻤﻴﻡ ﺍﻟﺠﺩﺍﻭل ﻋﻠﻰ ﺍﻟﻭﺭﻕ ﺒﻤﺎ ﻓﻴﻬﺎ ﺘﺤﺩﻴﺩ ﺍﻻﺭﺘﺒﺎﻁﺎﺕ ﻭﺃﻨﻭﺍﻉ ﺍﻟﺤﻘﻭل ﻭﺍﻟﻘﻴﻭﺩ ﺇﻟﻰ ﺍﻟﺤﻘـﻭل‬
‫ﻭﺜﻡ ﺍﻟﺒﺩﺀ ﺒﺈﻨﺸﺎﺀ ﺍﻟﺠﺩﺍﻭل ﺍﻵﺒﺎﺀ ﺜﻡ ﺍﻷﺒﻨﺎﺀ ﻭﺘﻌﺭﻴﻑ ﺨﺼﺎﺌﺹ ﺍﻟﺠﺩﻭل ﻋﻨﺩ ﺇﻨﺸﺎﺀﻩ ‪.‬‬
‫‪ 3‬ـ ﻋﻤﻠﻴﹰﺎ ﻴﻔﻀل ﺃﻥ ﺘﻜﻭﻥ ﺠﻤﻴﻊ ﺠﺩﺍﻭل ﺍﻟﻘﺎﻋﺩﺓ ﺠﺎﻫﺯﺓ ﻗﺒل ﺍﻟﺒﺩﺀ ﺒﺈﺩﺨﺎل ﺍﻟﻤﻌﻁﻴﺎﺕ ﺇﻟﻴﻬﺎ ‪.‬‬
‫‪ 4‬ـ ﺠﺩﺍﻭل ﺍﻟﻘﺎﻋﺩﺓ ﺍﻟﻤﻌﺘﻤﺩﺓ ﻓﻲ ﻫﺫﺍ ﺍﻟﻤﺜﺎل ﻭﺍﻟﻁﺭﻕ ﺍﻟﺘﻲ ﺍﺘﺒﻌﺕ ﻓﻲ ﺇﻨﺸﺎﺀﻫﺎ ﻏﻴﺭ ﻤﺜﺎﻟﻴﺔ ﻭﺍﻋﺘﻤﺩﺕ ﻫﻨﺎ ﺒﻬﺩﻑ ﺘﻌﻠﻴﻤﻲ‬
‫ﻓﻘﻁ ‪.‬‬
‫ﺇﺩﺨﺎل ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻟﻰ ﺍﻟﺠﺩﺍﻭل ‪:‬‬
‫ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺇﻤﻜﺎﻨﻴﺔ ﺒﻨﺎﺀ ﺍﻟﺠﺩﺍﻭل ﻴﺘﻴﺢ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪ Database Desktop‬ﺇﺩﺨﺎل ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻟﻴﻬﺎ ﻭﺘﻌﺩﻴﻠﻬﺎ ‪.‬‬

‫‪97‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺇﺩﺨﺎل ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺎﻟﻠﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ ‪:‬‬
‫ﻟﻜﻲ ﺘﺴﺘﻁﻴﻊ ﺇﺩﺨﺎل ﻨﺼﻭﺹ ﺒﺎﻟﻠﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ ﻓﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪ Database Desktop‬ﻋﻠﻴﻙ ﺘﻐﻴﺭ ﺍﻟﺨﻁ ﺍﻟﻤـﺴﺘﺨﺩﻡ ﻓـﻲ‬
‫ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻴﺘﻡ ﺫﻟﻙ ﺒﺎﺨﺘﻴﺎﺭ ﺍﻷﻤﺭ ‪ Edit Æ Peferences‬ﻭﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Change‬ﻟﺘﻐﻴﺭ ﺍﻟﺨﻁ ﺃﺨﺘـﺭ ﻤـﻥ‬
‫ﻼ‪.‬‬
‫ﺍﻟﻘﺎﺌﻤﺔ ﺃﺤﺩ ﺍﻟﺨﻁﻭﻁ ﺍﻟﺘﻲ ﺘﺩﻋﻡ ﺍﻟﻠﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ ‪ Arabic Transparent‬ﻤﺜ ﹰ‬
‫ﺍﺴﺘﺨﺩﺍﻡ ﻨﻤﻁ ﺍﻟﺘﺤﺭﻴﺭ ‪:‬‬
‫ﻗﺒل ﺍﻟﺒﺩﺀ ﺒﺈﺩﺨﺎل ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻟﻰ ﺍﻟﺠﺩﻭل ﻴﺠﺏ ﺍﻟﺩﺨﻭل ﺇﻟﻰ ﻨﻤﻁ ﺍﻟﺘﺤﺭﻴﺭ ﻭﻴﺘﻡ ﺫﻟﻙ ﻋﻥ ﻁﺭﻴﻕ ﺍﺨﺘﻴﺎﺭ ﺍﻷﻤﺭ ‪ Edit‬ﻤـﻥ‬
‫ﺍﻟﻘﺎﺌﻤﺔ ‪ Table‬ﺃﻭ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ F9‬ﺃﻭ ﺯﺭ ﺍﻟﺴﺭﻋﺔ ﻓﻲ ﺃﻗﺼﻰ ﻴﻤﻴﻥ ﺸﺭﻴﻁ ﺍﻟﺴﺭﻋﺔ ) ﻁﺒﻌﹰﺎ ﻴﺠـﺏ ﺃﻥ ﻴﻜـﻭﻥ‬
‫ﺍﻟﺠﺩﻭل ﻤﻔﺘﻭﺤﹰﺎ ( ‪.‬‬
‫ﺃﺩﺨل ﺍﻵﻥ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﺇﻟﻰ ﺠﺩﻭل ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ‪:‬‬
‫ﻻ ﺠﺩﻭل ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻭﺍﺩﺨل ﻓﻲ ﻨﻤﻁ ﺍﻟﺘﺤﺭﻴﺭ‬
‫ﺍﻓﺘﺢ ﺍﻭ ﹰ‬
‫ﺍﺴﺘﺨﺩﻡ ﺍﻟﺯﺭ ‪ Tab‬ﻟﻠﺘﻨﻘل ﺒﻴﻥ ﺍﻟﺤﻘﻭل ﻜﻤـﺎ ﺃﻥ ﻨﻔـﺱ ﺍﻟـﺯﺭ‬
‫ﺴﻴﻨﻘﻠﻙ ﺇﻟﻰ ﺴﺠل ﺠﺩﻴﺩ ‪.‬‬
‫ﻻﺤﻅ ﺍﻨﻪ ﻻ ﻴﺴﻤﺢ ﻟﻙ ﺒﺈﺩﺨﺎل ﻗﻴﻤﺔ ﻓﻲ ﺤﻘل ﻤﻥ ﺍﻟﻨﻭﻉ ﺘـﺭﻗﻴﻡ‬
‫ﺘﻠﻘﺎﺌﻲ ﻹﻥ ﻫﺫﺍ ﺍﻟﺤﻘل ﻴﺄﺨﺫ ﻗﻴﻤﺘﻪ ﺘﻠﻘﺎﺌﻴﹰﺎ ﻭﻴﺯﺍﺩﺍﺩ ﺒﻤﻘﺩﺍﺭ ‪ 1‬ﻋﻨﺩ ﺇﻀﺎﻓﺔ ﺴﺠل ﺠﺩﻴﺩ ‪.‬‬
‫ﻜﻤﺎ ﺃﻨﻪ ﻻ ﺤﺎﺠﺔ ﻟﺤﻔﻅ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﺍﻟﻤﺩﺨﻠﺔ ﻓﻲ ﺍﻟﺠﺩﻭل ‪ ،‬ﺤﻴﺙ ﻴﻘﻭﻡ ﺍﻟﺠﺩﻭل ﺒﺤﻔﻅ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﺘﻠﻘﺎﺌﻴﹰﺎ ﻋﻨﺩ ﺍﻻﻨﺘﻘﺎل ﺇﻟﻰ‬
‫ﺴﺠل ﺠﺩﻴﺩ ‪.‬‬
‫ﺃﺩﺨل ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﺇﻟﻰ ﺠﺩﻭل ﺍﻟﺭﺤﻼﺕ ‪ :‬ﺍﻓﺘﺢ ﺍﻟﺠﺩﻭل ﻭﺍﻨﺘﻘل ﺇﻟﻰ ﻭﻀﻊ ﺍﻟﺘﺤﺭﻴﺭ‬

‫ﺤﺎﻭل ﺇﺩﺨﺎل ﺍﻟﻘﻴﻤﺔ ‪ 400‬ﻓﻲ ﺍﻟﺤﻘل ‪ CardCount‬ﻭﻻﺤﻅ ﻋﺩﻡ ﻗﺒﻭل ﺍﻟﺒﺭﻨﺎﻤﺞ ﻟﻬﺫﻩ ﺍﻟﻘﻴﻤـﺔ ﻭﺘـﺫﻜﺭ ﺍﻟـﺸﺭﻁ ﺍﻟـﺫﻱ‬
‫ﻭﻀﻌﻨﺎﻩ ﻋﻠﻰ ﻫﺫﺍ ﺍﻟﺤﻘل‬
‫) ﺇﻗﺭﺃ ﺍﻟﺭﺴﺎﻟﺔ ﺍﻟﺘﻲ ﺘﻅﻬﺭ ﻓﻲ ﺍﻟﺯﺍﻭﻴﺔ ﺍﻟﻴﺴﺎﺭﻴﺔ ﺍﻟﺴﻔﻠﻰ ﻟﻠﺒﺭﻨﺎﻤﺞ ( ‪.‬‬
‫ﻓﻲ ﺍﻟﺤﻘﻭل ﻤﻥ ﺍﻟﻨﻭﻉ ‪ TimeStamp‬ﻴﻤﻜﻥ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﻤﻔﺘﺎﺡ ﺍﻟﻤﺴﺎﻓﺔ ﻹﺩﺨﺎل ﺍﻟﻭﻗﺕ ﻭﺍﻟﺘﺎﺭﻴﺦ ﺍﻟﺤﺎﻟﻲ ‪.‬‬
‫ﺃﺩﺨل ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻟﻰ ﺠﺩﻭل ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻭﺍﻟﺭﺤﻼﺕ ‪ :‬ﺍﻓﺘﺢ ﺍﻟﺠﺩﻭل ﻭﺍﻨﺘﻘل ﺇﻟﻰ ﺠﺩﻭل ﺍﻟﺭﺤﻼﺕ‬
‫ﺘﻌﻠﻡ ﺃﻨﻨﺎ ﻗﺩ ﺭﺒﻁﻨﺎ ﺍﻟﺤﻘـل ‪ PNo‬ﺒﺠـﺩﻭل‬
‫ﺒﺤﺙ‬
‫ﻟﻼﺴﺘﻔﺎﺩﺓ ﻤﻥ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺃﻀـﻐﻁ ﻋﻠـﻰ‬
‫ﺍﻟﻤﻔـﺎﺘﻴﺢ ‪ Ctrl + Space‬ﺃﺜﻨـﺎﺀ ﻭﺠـﻭﺩ‬
‫ﺍﻟﻤﺅﺸﺭ ﻓﻲ ﺍﻟﺤﻘل ‪ PNO‬ﺴـﺘﻅﻬﺭ ﻨﺎﻓـﺫﺓ‬

‫‪98‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺠﺩﻴﺩﺓ ﻓﻴﻬﺎ ﺠﻤﻴﻊ ﺤﻘﻭل ﺠﺩﻭل ﺍﻟﺒﺤﺙ ‪ Passengers.db‬ﺃﺨﺘﺭ ﺃﺤﺩ ﺍﻟﺴﺠﻼﺕ ﻭﺍﻀﻐﻁ ﻋﻠﻴﻪ ﻤﺭﺘﻴﻥ ﺴـﺘﻐﻠﻕ ﺍﻟﻨﺎﻓـﺫﺓ‬
‫ﻭﺘﻨﺘﻘل ﻗﻴﻤﺔ ﺍﻟﺤﻘل ‪ PNo‬ﻓﻲ ﺍﻟﺴﺠل ﺍﻟﻤﺨﺘﺎﺭ ﺇﻟﻰ ﺍﻟﺠﺩﻭل ﺍﻟﺤﺎﻟﻲ ‪.‬‬
‫ﻴﻤﻜﻨﻙ ﺃﻴﻀﹰﺎ ﺇﺩﺨﺎل ﺭﻗﻡ ﺍﻟﻤﺴﺎﻓﺭ ﻴﺩﻭﻴﹰﺎ ﻭﻟﻜﻥ ﻻ ﻴﺴﻤﺢ ﻟﻙ ﺒﺈﺩﺨﺎل ﺭﻗﻡ ﻤﺴﺎﻓﺭ ﻏﻴﺭ ﻤﻭﺠﻭﺩ ﻓﻲ ﺠﺩﻭل ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ‪ ،‬ﻜﻤﺎ‬
‫ﻻ ﻴﺴﻤﺢ ﺒﺈﺩﺨﺎل ﻨﻔﺱ ﺍﻟﻤﺴﺎﻓﺭ ﻋﻠﻰ ﻨﻔﺱ ﺍﻟﺭﺤﻠﺔ ﻤﺭﺘﻴﻥ ) ﻻ ﻴﻤﻜﻥ ﻟﻠﻤﺴﺎﻓﺭ ﺃﻥ ﻴﺴﺎﻓﺭ ﻓﻲ ﺭﺤﻠـﺔ ﻭﺍﺤـﺩﺓ ﻤـﺭﺘﻴﻥ (‬
‫ﻭﺘﻅﻬﺭ ﺍﻟﺭﺴﺎﻟﺔ ‪ Key Violation‬ﻭﺫﻟﻙ ﻷﻨﻪ ﻻ ﻴﻤﻜﻥ ﺃﻥ ﺘﻜﻭﻥ ﺍﻟﻘﻴﻡ ﻓﻲ ﺍﻟﻤﻔﺘﺎﺡ ﺍﻟﺭﺌﻴﺴﻲ ﻤﻜﺭﺭﺓ ‪.‬‬
‫ـ ﺃﺨﻴﺭﹰﺍ ﺤﺎﻭل ﺍﻟﺘﺩﺭﺏ ﻋﻠﻰ ﺍﻷﻭﺍﻤﺭ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ‪. Record‬‬

‫‪99‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ﺍﻟﺴﺎﺩﺴﺔ ﻋﺸﺭ‬
‫ﺒﺒﻌﺩ ﺃﻥ ﻗﻤﻨﺎ ﺒﺒﻨﺎﺀ ﺍﻟﺠﺩﺍﻭل ﺒﺎﺴﺘﺨﺩﺍﻡ ‪ Database Desktop‬ﺴﻨﻜﻤل ﺍﻵﻥ ﻤﺸﻭﺍﺭﻨﺎ ﺒﺘﻌﻠﻡ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫ﻤﻥ ﺨﻼل ﺩﻟﻔﻲ ﺒﺎﺴﺘﺨﺩﺍﻡ ﻫﺫﻩ ﺍﻟﺠﺩﺍﻭل‬
‫ﻋﺭﺽ ﺠﺩﻭل ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻓﻲ ﻨﺎﻓﺫﺓ ‪:‬‬
‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﺃﻀﻑ ﺇﻟﻴﻪ ﺍﻟﻌﻨﺎﺼﺭ ‪. Table, DBGrid, DataSource, DBNavigator‬‬
‫ﺃﻋﻁ ﺍﻟﻌﻨﺼﺭ ‪ Table1‬ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ‬
‫ﺍﻟﻘﻴﻤﺔ‬ ‫ﺍﻟﺨﺎﺼﺔ‬
‫‪Travel‬‬ ‫‪DatabaseName‬‬
‫‪Passengers‬‬ ‫‪TableName‬‬
‫‪True‬‬ ‫‪Active‬‬
‫ﺃﻋﻁ ﺍﻟﻌﻨﺼﺭ ‪ DataSource‬ﺍﻟﺨﺎﺼﺔ ‪ DataSet‬ﺍﻟﻘﻴﻤﺔ ‪Table1‬‬
‫ﺃﻋﻁ ﺍﻟﻌﻨﺼﺭﻴﻥ ‪ DBNavigator‬ﻭ ‪ DBGrid‬ﺍﻟﺨﺎﺼﺔ ‪ DataSource‬ﺍﻟﻘﻴﻤﺔ ‪DataSource1‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻻﺤﻅ ﺍﻟﻨﺘﺎﺌﺞ ‪...‬‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺤﻘﻭل ‪:‬‬
‫ﺘﻤﻜﻨﻨﺎ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﺼﻔﺤﺔ ‪ Data Control‬ﻤﻥ ﺭﺅﻴﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﺘﺤﺭﻴﺭﻫﺎ ﺃﻤﺎ ﺇﺫﺍ ﺃﺭﺩﻨﺎ ﺍﻟﻭﺼـﻭل ﺇﻟـﻰ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﺍﻟﺘﺤﻜﻡ ﺒﻁﺭﻴﻘﺔ ﻋﺭﻀﻬﺎ ﻋﻠﻴﻨﺎ ﺇﻨﺸﺎﺀ ﻋﻨﺎﺼﺭ ﺍﻟﺤﻘﻭل ‪.‬‬
‫ﺇﻨﺸﺎﺀ ﻋﻨﺎﺼﺭ ﺍﻟﺤﻘﻭل ‪:Tfield‬‬
‫ﻴﻤﻜﻥ ﺍﺴﺘﺨﺩﺍﻡ ﻤﺤﺭﺭ ﺍﻟﺤﻘﻭل ﻟﺘﻌﺭﻴﻑ ﻻﺌﺤﺔ ﻤﻥ ﺍﻟﺤﻘﻭل ﻀﻤﻥ ﺍﻟﺠﺩﻭل ) ﻋﻨﺼﺭ ﺍﻟﺠﺩﻭل ‪ ( Table‬ﻭﻤﻥ ﺃﺠل ﻜـل‬
‫ﺤﻘل ﺘﻨﺸﺊ ﺩﻟﻔﻲ ﻋﻨﺼﺭ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Tfield‬ﻭﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻏﻴﺭ ﻤﺭﺌﻲ ﻭﻟﻜﻥ ﻴﻤﻜـﻥ ﻤـﻥ‬
‫ﺨﻼﻟﻪ ﺍﻟﻭﺼﻭل ﺇﻟﻰ ﻗﻴﻤﺔ ﺍﻟﺤﻘل ﻭﺍﻟﺘﺤﻜﻡ ﺒﻤﻭﺍﺼﻔﺎﺘﻬﺎ ‪.‬‬
‫ﻟﻔﺘﺢ ﺼﻨﺩﻭﻕ ﺤﻭﺍﺭ ﻤﺤﺭﺭ ﺍﻟﺤﻘﻭل ﺍﻀﻐﻁ ﻤﺭﺘﻴﻥ ﻋﻠﻰ ﺍﻟﻌﻨﺼﺭ ‪ Table1‬ﻟﺘﻅﻬﺭ ﺍﻟﻨﺎﻓـﺫﺓ‬
‫ﺍﻟﻤﺠﺎﻭﺭﺓ ‪ ،‬ﺇﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻷﻴﻤﻥ ﻓﻲ ﻭﺴﻁ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﻟﺘﻅﻬﺭ ﻗﺎﺌﻤﺔ ﺍﺨﺘﺭ ﻤﻨﻬﺎ ‪Add‬‬
‫‪ All Field‬ﻋﻨﺩﻫﺎ ﺴﺘﻅﻬﺭ ﺤﻘﻭل ﺠﺩﻭل ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻓﻲ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ‪ ،‬ﺃﻋﺩ ﺍﻟـﻀﻐﻁ ﺒـﺯﺭ‬
‫ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﻤﻴﻨﻲ ﻋﻠﻰ ﺃﺤﺩ ﻫﺫﻩ ﺍﻟﺤﻘﻭل ﺘﻅﻬﺭ ﺍﻟﻘﺎﺌﻤﺔ ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ ﻋﻤﻠﻴﺎﺕ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻫﺫﻩ‬
‫ﺍﻟﻼﺌﺤﺔ ﻤﻥ ﻗﺹ ﻭﻨﺴﺦ ﻭﺤﺫﻑ ‪..‬‬
‫‪1‬ـ ﺍﺤﺫﻑ ﺍﻟﺤﻘل ‪ Pno‬ﻤﻥ ﺍﻟﻼﺌﺤﺔ ﻭﻻﺤﻅ ﺍﺨﺘﻔﺎﺀﻩ ﻤﻥ ﺍﻟﻌﻨﺼﺭ ‪. DBGrid‬‬
‫‪ 2‬ـ ﺃﻋﺩ ﺘﺭﺘﻴﺏ ﺍﻟﺤﻘﻭل ﻀﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ﻭﺫﻟﻙ ﻋﻥ ﻁﺭﻴﻕ ﺴﺤﺏ ﺍﻟﺤﻘل ‪ PassNo‬ﻭﺇﻓﻼﺘﻪ ﻓﻲ ﺃﻋﻠﻰ ﺍﻟﻘﺎﺌﻤـﺔ ﻭﻻﺤـﻅ‬
‫ﺘﺄﺜﻴﺭ ﺫﻟﻙ ﻋﻠﻰ ﺍﻟﻌﻨﺼﺭ ‪. DBGrid‬‬
‫ﺍﻓﺘﺢ ﻤﺤﺭﺭ ﺍﻟﺸﻴﻔﺭﺓ ﻭﺍﻨﺘﻘل ﺇﻟﻰ ﺍﻟﻘﺴﻡ ‪ Type‬ﻭﻻﺤﻅ ﻗﻴﺎﻡ ‪ Delphi‬ﺒﺘﻌﺭﻴﻑ ﻋﺩﺩ ﻤﻥ ﺍﻟﻤﺘﺤﻭﻻﺕ‬
‫ﺘﻡ ﺘﻌﺭﻴﻑ ﺤﻘل ﻤﻥ ﺍﻟﻨﻭﻉ ﺍﻟﻨﺼﻲ ﻷﻥ ﺍﻟﺤﻘل ﻤﻥ ﺍﻟﻨﻭﻉ ﻨﺹ ‪Table1Pname: TStringField; //‬‬
‫;‪Table1Nationalty: TStringField‬‬
‫ﺘﻡ ﺘﻌﺭﻴﻑ ﺤﻘل ﻤﻥ ﺍﻟﻨﻭﻉ ﺍﻟﺼﺤﻴﺢ ﻷﻥ ﺍﻟﺤﻘل ﻤﻥ ﺍﻟﻨﻭﻉ ﺍﻟﺼﺤﻴﺢ ‪Table1PassNo: TIntegerField; //‬‬

‫‪100‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺘﺤﺩﻴﺩ ﺨﻭﺍﺹ ﺍﻟﻌﻨﺼﺭ ﻤﻥ ﺍﻟﻨﻭﻉ ‪: Tfield‬‬
‫ﺍﻓﺘﺢ ﻤﺤﺭﺭ ﺍﻟﺤﻘﻭل ﻭﺍﺨﺘﺭ ﺍﻟﺤﻘل ‪ PassNo‬ﻭﻻﺤﻅ ﺨﻭﺍﺹ ﻫﺫﺍ ﺍﻟﺤﻘل ﻓﻲ ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ﺤﻴﺙ ﻴﻅﻬﺭ ﻓـﻲ ﺃﻋﻠـﻰ‬
‫ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ﺍﺴﻡ ﺍﻟﻌﻨﺼﺭ ﻭﻨﻭﻉ ﺍﻟﻌﻨﺼﺭ ‪ Table1Pname: TStringField‬ﺤﻴﺙ ﺘﻌﻁﻲ ﺩﻟﻔﻲ ﺍﺴﻡ ﻫﺫﺍ ﺍﻟﺤﻘـل‬
‫ﺘﻠﻘﺎﺌﻴﹰﺎ ﻭﺍﻟﺫﻱ ﻴﻤﻜﻥ ﺘﻐﻴﺭﻩ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﺨﺎﺼﺔ ‪. Name‬‬
‫‪ 3‬ـ ﻏﻴﺭ ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﺔ ‪ Alignment‬ﺇﻟﻰ ﺍﻟﻘﻴﻤﺔ ‪ taCenter‬ﻭﻻﺤﻅ ﺘﺄﺜﻴﺭ ﺫﻟﻙ ﻋﻠﻰ ﺍﻟﻌﻨﺼﺭ ‪. DBGrid‬‬
‫‪ 4‬ـ ﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ DisplayLabel‬ﺍﻟﻘﻴﻤﺔ " ﺭﻗﻡ ﺠﻭﺍﺯ ﺍﻟﺴﻔﺭ " ‪.‬‬
‫ﺴﻨﺘﻌﺭﻑ ﻻﺤﻘﹰﺎ ﻋﻠﻰ ﺇﻤﻜﺎﻨﻴﺎﺕ ﺇﻀﺎﻓﻴﺔ ﻟﻬﺫﺍ ﻟﻤﺤﺭﺭ ﺍﻟﺤﻘﻭل ﺃﻤﺎ ﺍﻵﻥ ﻓﺴﻨﺘﻌﻠﻡ ﻜﻴﻔﻴﺔ ﺍﻟﻭﺼﻭل ﺇﻟﻰ ﻗﻴﻤﺔ ﺍﻟﺤﻘل ﺒﺭﻤﺠﻴﹰﺎ ‪:‬‬
‫ﻗﺭﺍﺀﺓ ﻗﻴﻡ ﺍﻟﺤﻘﻭل ‪:‬‬
‫ﺍﻟﻁﺭﻴﻘﺔ ﺍﻷﻭﻟﻰ ‪ :‬ﺒﺎﻻﻋﺘﻤﺎﺩ ﻋﻠﻰ ﻋﻨﺎﺼﺭ ﺍﻟﺤﻘﻭل ‪: TFeild‬‬
‫ﺃﻀﻑ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺴﺎﺒﻕ ﻋﻨﺼﺭ ‪ label1‬ﻭﺯﺭ ‪:‬‬
‫ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; ‪Label1.Caption := Table1Pname.value‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﻭﻻﺤﻅ ﻅﻬﻭﺭ ﻗﻴﻤﺔ ﺍﻟﺤﻘل ‪ Pname‬ﻓﻲ ﺍﻟﻌﻨﺼﺭ ‪ ، Label‬ﻏﻴـﺭ ﺍﻟـﺴﺠل ﺍﻟﺤـﺎﻟﻲ‬
‫ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﻤﺭﺓ ﺃﺨﺭﻯ ‪...‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺈﻟﺤﺎﻕ ﻗﻴﻤﺔ ﺍﻟﺤﻘل ‪ Tabel1Pname‬ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ Caption‬ﻭﺫﻟﻙ ﻷﻥ ﺍﻟﺤﻘل ﻭﺍل‪ Caption‬ﻤـﻥ‬
‫ﻨﻭﻉ ‪ String‬ﺃﻤﺎ ﺇﺫﺍ ﺃﺭﺩﺕ ﺇﻟﺤﺎﻕ ﻗﻴﻤﺔ ﺤﻘل ﻋﺩﺩﻱ ﺇﻟﻰ ﻨﻭﻉ ﻨﺹ ﺍﺴﺘﺒﺩل ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺴﺎﺒﻘﺔ ﺒﺎﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; ‪Label1.Caption := Tabel1PassNo.AsString‬‬
‫ﻭﻴﻤﻠﻙ ﺍﻟﻌﻨﺼﺭ ‪ TField‬ﻋﺩﺩ ﻤﻥ ﺍﻟﺨﻭﺍﺹ ﻴﺸﺒﻪ ﺍﻟﺨﺎﺼﺔ ﺍﻟﺴﺎﺒﻘﺔ ﻭﻫﻲ ‪، AsFloat ، AsInteger ، AsBoolean‬‬
‫‪. AsDateTime‬‬
‫ﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﺜﺎﻨﻴﺔ ‪ :‬ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﺨﺎﺼﺔ ) ﺍﻟﻤﻨﻬﺞ ( ‪: FieldByName‬‬
‫‪TableName.FeildByName('FieldName').Value‬‬ ‫ﻭﻟﻪ ﺍﻟﺸﻜل ﺍﻟﺘﺎﻟﻲ ‪:‬‬

‫‪TableName.FeildByName('FieldName').AsType‬‬ ‫ﻭﻟﻠﺘﺤﻭﻴل ﺒﻴﻥ ﺍﻷﻨﻭﺍﻉ ‪:‬‬

‫ﻤﺜﺎل ) ‪ : ( 1‬ﺃﻀﻑ ﺯﺭﻴﻥ ﺇﻟﻰ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﺴﺎﺒﻕ ﻭﻋﻨﺼﺭ ﻨﺹ ‪: Label‬‬
‫ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪label1.Caption := Table1.FieldByName('Pname').Value‬‬
‫ﻭﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺜﺎﻨﻲ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; ‪Label2.Caption := table1.fieldbyname('PassNo').AsString‬‬
‫ﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﺜﺎﻟﺜﺔ ‪:‬ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺤﻘل ﻜﻨﻭﻉ ‪Variant‬‬
‫]'‪Table1['FieldName‬‬ ‫ﻭﻟﻬﺎ ﺍﻟﺸﻜل ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫ﻤﺜﺎل ‪ :‬ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻷﻭل ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ‬
‫; ]'‪Label1.Caption := Table1['Pname‬‬
‫ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺜﺎﻨﻲ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫‪101‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫; ]'‪Label2.Caption := table1['PassNo‬‬
‫ﻻﺤﻅ ﺃﻨﻪ ﻻ ﺤﺎﺠﺔ ﻻﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﻨﻬﺞ ‪AsString‬‬
‫ﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﺭﺍﺒﻌﺔ ‪:‬‬
‫‪TableName.Field[Index].Value‬‬
‫‪.AsString‬‬
‫ﻤﺜﺎل ‪ :‬ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻷﻭل ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ‬
‫; ]'‪Label1.Caption := Table1['Pname‬‬
‫ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺜﺎﻨﻲ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; ‪Label2.Caption := table1.Fields[3].AsString‬‬

‫ﺇﻟﺤﺎﻕ ﻗﻴﻡ ﺒﺎﻟﺤﻘﻭل ‪:‬‬

‫‪ 1‬ـ ﺘﻌﺩﻴل ﺴﺠل ) ﺤﻘل ( ‪:‬‬
‫ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ ﻨﺭﻴﺩ ﺃﻥ ﻨﻐﻴﺭ ﻓﻲ ﻗﻴﻤﺔ ﺍﻟﺴﺠل ﺍﻟﺤﺎﻟﻲ ﻭﻨﺴﺘﺨﺩﻡ ﺍﻷﺴﻠﻭﺏ ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫; ‪Table1.Edit‬‬
‫; ‪Tabel1.FieldByName( 'FieldName').Value := NewValue‬‬
‫;‪Table1.Post‬‬
‫ﻜﻤﺎ ﻭﺠﺩﻨﺎ ﻋﻨﺩ ﺇﺩﺨﺎل ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻟﻰ ﺍﻟﺠﺩﺍﻭل ﻓﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪ Database Desktop‬ﻗﻤﻨﺎ ﺒﺎﻻﻨﺘﻘﺎل ﺇﻟﻰ ﻭﻀﻊ ﺍﻟﺘﺤﺭﻴـﺭ‬
‫ﺒﻨﻔﺱ ﺍﻟﻁﺭﻴﻘﺔ ﻋﻨﺩ ﺇﺩﺨﺎل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ﻋﻠﻴﻨﺎ ﺃﻥ ﻨﻀﻊ ﺍﻟﺠﺩﻭل ﻓﻲ ﻭﻀﻊ ﺍﻟﺘﺤﺭﻴﺭ ﻟﺫﻟﻙ ﺍﺴﺘﺨﺩﻤﻨﺎ ﺍﻟﺘﻌﻠﻴﻤﺔ‬
‫‪. Table1.Edit‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺜﺎﻨﻴﺔ ﺘﻘﻭﻡ ﺒﺈﺩﺨﺎل ﺍﻟﻘﻴﻤﺔ ﺍﻟﺠﺩﻴﺩﺓ ﺩﺍﺨل ﺍﻟﺤﻘل ‪ ،‬ﺃﻤﺎ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ Table1.Post‬ﻓﻤﻬﻤﺘﻬﺎ ﺜﺜﺒﻴﺕ ﺍﻟﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺩﺨﻠﺔ‬
‫ﻋﻠﻰ ﺍﻟﺠﺩﻭل ﻭﺘﹲﺨﺭﺝ ﺍﻟﺠﺩﻭل ﻤﻥ ﻭﻀﻊ ﺍﻟﺘﺤﺭﻴﺭ ‪.‬‬
‫ﻤﺜﺎل ‪ :‬ﺃﻀﻑ ﺜﻼﺜﺔ ﻋﻨﺎﺼﺭ ﺘﺤﺭﻴﺭ ‪ Edit‬ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺴﺎﺒﻕ ﻭﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; ‪Table1.Edit‬‬
‫; ‪Table1.Fieldbyname('Pname').Value := Edit1.Text‬‬
‫; ‪Table1.FieldByName('Nationalty').Value := Edit2.Text‬‬
‫; ‪Table1.FieldByName('PassNo').AsString := Edit3.Text‬‬
‫; ‪Table1.Post‬‬
‫ﻴﻤﻜﻥ ﺍﺴﺘﺒﺩﺍل ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺭﺍﺒﻌﺔ ; ‪ table1.FieldByName('PassNo').AsString := edit3.Text‬ﺒﺎﻟﺘﻌﻠﻴﻤﺔ‬
‫; )‪Table1.FieldByName('PassNo').Value := strtoint( Edit3.Text‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺃﺩﺨل ﻗﻴﻡ ﻓﻲ ﻋﻨﺎﺼﺭ ﺍﻟﺘﺤﺭﻴﺭ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﻭﻻﺤﻅ ﺘﻐﻴﺭ ﻗﻴﻡ ﺍﻟﺴﺠل ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻭﺠﺩﻨﺎ ﺃﻨﻪ ﻴﻤﻜﻥ ﺘﻌﺩﻴل ﺍﻟﺠﺩﻭل ﻤﻥ ﺨﻼل ﺍﻟﻌﻨﺼﺭ ‪ DBGrid‬ﺩﻭﻥ ﺃﻥ ﻨﻘﻭﻡ ﺒﻭﻀﻊ ﺍﻟﺠـﺩﻭل ﻓـﻲ ﻭﻀـﻊ‬
‫ﺍﻟﺘﺤﺭﻴﺭ ﻭﻫﺫﺍ ﻴﻌﻭﺩ ﻟﻠﺨﺎﺼﺔ ‪ AutoEdit‬ﻟﻠﻌﻨﺼﺭ ‪ DataSource‬ﺤﻴﺙ ﻴﻘﻭﻡ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﺒﻭﻀﻊ ﺍﻟﺠﺩﻭل ﻓﻲ ﻭﻀـﻊ‬
‫ﺍﻟﺘﺤﺭﻴﺭ ﺒﺸﻜل ﺘﻠﻘﺎﺌﻲ ﻭﺒﺈﻋﻁﺎﺀ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﻟﻘﻴﻤﺔ ‪ False‬ﻨﻔﻘﺩ ﺍﻟﻘﺩﺭﺓ ﻋﻠﻰ ﺘﻐﻴﺭ ﻗﻴﻤﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﺠﺩﻭل ‪.‬‬
‫ﻤﻥ ﺍﻟﻤﻔﻴﺩ ﺃﻥ ﺘﻼﺤﻅ ﺃﻨﻨﺎ ﺍﺴﺘﻁﻌﻨﺎ ﺃﻥ ﻨﺼل ﻟﻠﻤﻌﻁﻴﺎﺕ ﻓﻲ ﺍﻟﺠﺩﻭل ﺒﺩﻭﻥ ﺍﻟﻤﺭﻭﺭ ﻋﻠﻰ ﺍﻟﻌﻨﺼﺭ ‪ ) DataSoucre‬ﺴﻭﺍﺀ‬
‫ﻓﻲ ﺍﻟﻘﺭﺍﺀﺓ ﺃﻭ ﺍﻟﻜﺘﺎﺒﺔ ( ﺤﻴﺙ ﺃﻥ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺘﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻌﻨﺼﺭ ‪ Table1‬ﻤﺒﺎﺸﺭﺓ ‪.‬‬
‫‪102‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ 2‬ـ ﺇﻀﺎﻓﺔ ﺴﺠل ‪:‬‬
‫; ‪Table1.insert‬‬
‫; ‪Table1.Fieldbyname('Pname').Value := Edit1.Text‬‬
‫; ‪Table1.FieldByName('Nationalty').Value := Edit2.Text‬‬
‫; ‪Table1.FieldByName('PassNo').AsString := Edit3.Text‬‬
‫; ‪Table1.Post‬‬
‫ﺘﻘﻭﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ Table1.insert‬ﺒﻭﻀﻊ ﺍﻟﺠﺩﻭل ﻓﻲ ﻭﻀﻊ ﺍﻟﺘﺤﺭﻴﺭ ﻭﺘﻀﻴﻑ ﺴﺠل ﺠﺩﻴﺩ ﻓﺎﺭﻍ ﺇﻟﻰ ﺍﻟﺠـﺩﻭل ﻭﺘﺠﻌﻠـﻪ‬
‫ﺍﻟﺴﺠل ﺍﻟﺤﺎﻟﻲ ‪ ،‬ﺜﻡ ﺘﻘﻭﻡ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﺒﺈﻟﺤﺎﻕ ﻗﻴﻡ ﻓﻲ ﻫﺫﺍ ﺍﻟﺴﺠل ﻭﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻷﺨﻴﺭﺓ ﺘﻘﻭﻡ ﺒﺘﺜﺒﻴﺕ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﻓﻲ ﻫﺫﺍ‬
‫ﺍﻟﺠﺩﻭل ‪.‬‬
‫ﻴﻤﻜﻥ ﺍﺴﺘﺨﺩﺍﻡ ﻁﺭﻕ ﺍﻟﻘﺭﺍﺀﺓ ﺍﻟﺴﺎﺒﻘﺔ ﻓﻲ ﺍﻟﻜﺘﺎﺒﺔ ﺃﻱ ﻴﻤﻜﻥ ﺍﺴﺘﺒﺩﺍل ﺍﻟﺘﻌﻠﻴﻤﺔ‬
‫; ‪Table1.Fieldbyname('Pname').Value := Edit1.Text‬‬
‫‪Table1.Field[0].Value‬‬ ‫ـﺔ =‪:‬‬‫]'‪Table1['Pname‬ﺃﻭ ﺒﺎﻟﺘﻌﻠﻴﻤـ‬ ‫ـﺔ ; ‪:= Edit1.Text‬‬ ‫ﺒﺎﻟﺘﻌﻠﻴﻤـ‬
‫; ‪Edit1.Text‬‬
‫ﺃﻭ ﺒﺎﻟﺘﻌﻠﻴﻤﺔ ‪.... Table1Pname.Value := Edit1.Text‬‬
‫ﺍﻟﺘﻌﺭﻑ ﻋﻠﻰ ﻋﻨﺎﺼﺭ ﺍﻟﺼﻔﺤﺔ ‪: Data Control‬‬
‫‪ 1‬ـ ﺍﻟﻌﻨﺼﺭ ‪: DBGrid‬‬
‫ﺘﻌﺭﻓﻨﺎ ﻋﻠﻰ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﺴﺎﺒﻘﹰﺎ ﻭﺴﻨﺸﺭﺡ ﺍﻵﻥ ﺒﻌﺽ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﻤﻬﻤﺔ ﻟﻪ ‪:‬‬
‫ﺍﻟﻌﻤل‬ ‫ﺍﻟﻘﻴﻤﺔ‬ ‫ﺍﻟﺨﺎﺼﺔ‬
‫ﺘﺤﻭل ﺍﺘﺠﺎﻩ ﺍﻟﺠﺩﻭل ﺒﺤﻴﺙ ﻴﺼﺒﺢ ﻤﻥ ﺍﻟﻴﻤـﻴﻥ ﺇﻟـﻰ‬ ‫‪bdRightToLeft‬‬ ‫‪BiDiMode‬‬
‫ﺍﻟﻴﺴﺎﺭ‬
‫ﺇﻋﻁﺎﺀ ﻟﻭﻥ ﻟﺼﻔﺤﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﺍﻟﻌﻨﺼﺭ‬ ‫ﺃﻱ ﻟﻭﻥ‬ ‫‪Color‬‬
‫ﺇﻋﻁﺎﺀ ﻟﻭﻥ ﻟﺤﻭﺍﻑ ﺍﻟﺠﺩﻭل‬ ‫ﺃﻱ ﻟﻭﻥ‬ ‫‪FixedColor‬‬
‫ﺘﻐﻴﺭ ﻨﻤﻁ ﺍﻟﺨﻁ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻓﻲ ﺼﻔﺤﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬ ‫‪Font‬‬
‫ﺘﻐﻴﺭ ﻨﻤﻁ ﺍﻟﺨﻁ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻓﻲ ﺃﺴﻤﺎﺀ ﺍﻷﻋﻤﺩﺓ‬ ‫‪TitleFont‬‬
‫ﻜﻤﺎ ﻴﻭﺠﺩ ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ Option‬ﺍﻟﻌﺩﻴﺩ ﻤﻥ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﻔﺭﻋﻴﺔ ﺍﻟﻬﺎﻤﺔ‪:‬‬
‫ﺍﻟﻌﻤل‬ ‫ﺍﻟﻘﻴﻤﺔ‬ ‫ﺍﻟﺨﺎﺼﺔ‬
‫ﺍﻟﺘﺤﻜﻡ ﺒﺈﻤﻜﺎﻨﻴﺔ ﺍﻟﺘﺤﺭﻴﺭ ﺃﻭ ﻋﺩﻤﻪ ﻓﻲ ﺍﻟﻌﻨﺼﺭ‬ ‫‪True or False‬‬ ‫‪dgEditing‬‬
‫ﺇﻅﻬﺎﺭ ﺃﻭ ﻋﺩﻡ ﺇﻅﻬﺎﺭ ﺃﺴﻤﺎﺀ ﺍﻷﻋﻤﺩﺓ‬ ‫‪True or False‬‬ ‫‪dgTitle‬‬
‫ﺇﻅﻬﺎﺭ ﺃﻭ ﺇﺨﻔﺎﺀ ﻤﺅﺸﺭ ﺍﻟﺴﺠل ﺍﻟﺤﺎﻟﻲ‬ ‫‪True or False‬‬ ‫‪dgIndicator‬‬
‫ﺇﻅﻬﺎﺭ ﺃﻭ ﺇﺨﻔﺎﺀ ﺨﻁﻭﻁ ﺒﻴﻥ ﺍﻷﻋﻤﺩﺓ‬ ‫‪True or False‬‬ ‫‪dgColLines‬‬
‫ﻤﻨﻊ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺯﺭ ‪ Tab‬ﻟﻠﺘﻨﻘل ﺒﻴﻥ ﺍﻟﺤﻘﻭل‬ ‫‪True or False‬‬ ‫‪dgTabs‬‬
‫ﺇﻤﻜﺎﻨﻴﺔ ﺍﺨﺘﻴﺎﺭ ﺍﻟﺴﺠل ﺒﺎﻟﻜﺎﻤل‬ ‫‪True or False‬‬ ‫‪dgRowSelect‬‬
‫ﺍﻟﺘﺤﻜﻡ ﺒﺈﻅﻬﺎﺭ ﺭﺴﺎﻟﺔ ﺘﺄﻜﻴﺩ ﺤﺫﻑ ﺴﺠل‬ ‫‪True or False‬‬ ‫‪dgConfirmDelete‬‬

‫‪103‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺇﻤﻜﺎﻨﻴﺔ ﺍﺨﺘﻴﺎﺭ ﺃﻜﺜﺭ ﻤﻥ ﺴﺠل ﺒﻨﻔﺱ ﺍﻟﻭﻗﺕ‬ ‫‪True or False‬‬ ‫‪dgMutiSelect‬‬
‫ﺒﻘﻲ ﺃﻥ ﻨﺸﺭﺡ ﺍﻟﺨﺎﺼﺔ ‪ Columns‬ﻟﻬﺫﺍ ﺍﻟﻌﻨﺼﺭ ‪:‬‬
‫ﺒﺎﺨﺘﻴﺎﺭ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺃﻭ ﺒﺎﻟﻀﻐﻁ ﻤﺭﺘﻴﻥ ﻋﻠﻰ ﺍﻟﻌﻨﺼﺭ ‪ DBGrid‬ﺘﻅﻬﺭ‬
‫ﻨﺎﻓﺫﺓ ﻤﺤﺭﺭ ﺍﻷﻋﻤﺩﺓ ﻜﻤﺎ ﻓﻲ ﺍﻟﺸﻜل ﺍﻟﻤﺠﺎﻭﺭ ‪:‬‬
‫ﺤﻴﺙ ﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ﻓﻲ ﺍﻟﺒﺩﺍﻴﺔ ﻓﺎﺭﻏﺔ ‪ ،‬ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻷﻴﻘﻭﻨـﺔ ﺍﻟﺜﺎﻟﺜـﺔ )‬
‫‪( Add All Field‬‬
‫ﻓﺘﻅﻬﺭ ﺠﻤﻴﻊ ﺃﺴﻤﺎﺀ ﺤﻘﻭل ﺍﻟﺠﺩﻭل ﺩﺍﺨل ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ‪:‬‬
‫ﻓﻲ ﺤﺎل ﺤﺫﻑ ﺃﺤﺩ ﻫﺫﻩ ﺍﻟﺤﻘﻭل ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ﻓﻠﻥ ﻴﻅﻬﺭ ﻓـﻲ ﺍﻟﻌﻨـﺼﺭ‬
‫‪ DBGrid‬ﻭﻟﻠﻘﻴﺎﻡ ﺒﺫﻟﻙ ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺜﺎﻨﻲ ‪ Delete‬ﺒﻌﺩ ﺍﺨﺘﻴـﺎﺭ‬
‫ﺍﻟﺤﻘل ﺍﻟﻤﺭﺍﺩ ﺤﺫﻓﻪ ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪:‬ﻴﺨﺘﻠﻑ ﺍﻷﻤﺭ ﻫﻨﺎ ﻋﻥ ﺤﺫﻑ ﺍﻟﺤﻘل ﻤﻥ ﻤﺤﺭﺭ ﺍﻟﺤﻘﻭل ﻭﺫﻟﻙ ﻷﻨﻪ ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ ﺍﻟﺤﻘل ﺍﻟﻤﺤﺫﻭﻑ ﻤﻥ ﻤﺤﺭﺭ‬
‫ﺍﻷﻋﻤﺩﺓ ﻴﻤﻜﻥ ﺍﻟﻭﺼﻭل ﺇﻟﻴﻪ ﺒﻁﺭﻴﻘﺔ ﺃﺨﺭﻯ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﻌﻨﺼﺭ ‪ Table‬ﻤﺒﺎﺸﺭﺓ ﺃﻭ ﻋﻥ ﻁﺭﻴﻕ ﺭﺒﻁﻪ ﺒﺄﺤﺩ ﻋﻨﺎﺼـﺭ‬
‫‪ ، Data Control‬ﺃﻤﺎ ﻓﻲ ﺤﺎل ﺤﺫﻑ ﺍﻟﻌﻨﺼﺭ ﻤﻥ ﻤﺤﺭﺭ ﺍﻟﺤﻘﻭل ﻓﻠﻥ ﻨﺴﺘﻁﻴﻊ ﺍﻟﺤﺼﻭل ﻋﻠﻰ ﻗﻴﻡ ﻫﺫﺍ ﺍﻟﺤﻘل ) ﻋﻤﻠﻴﹰﺎ‬
‫ﺍﻟﻌﻨﺼﺭ ‪ Table‬ﻟﻥ ﻴﺘﺼل ﻤﻊ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻹﺤﻀﺎﺭ ﻗﻴﻡ ﻫﺫﺍ ﺍﻟﺤﻘل ( ‪.‬‬
‫ﺒﺎﺨﺘﻴﺎﺭ ﺃﺤﺩ ﻫﺫﻩ ﺍﻟﺤﻘﻭل ﺘﻅﻬﺭ ﺨﺼﺎﺌﺹ ﺍﻟﺤﻘل ﻓﻲ ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ﻭﺍﻟﺘﻲ ﻴﻤﻜﻥ ﺍﻻﺴﺘﻔﺎﺩﺓ ﻤﻨﻬﺎ ﻜﻤﺎﻴﻠﻲ ‪:‬‬

‫ﺍﻟﻌﻤل‬ ‫ﺍﻟﻘﻴﻤﺔ‬ ‫ﺍﻟﺨﺎﺼﺔ‬

‫ﺍﻟﺘﺤﻜﻡ ﺒﻤﻜﺎﻥ ﻅﻬﻭﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺩﺍﺨل ﺍﻟﻌﻤﻭﺩ‬ ‫‪Alignment‬‬
‫ﺇﻋﻁﺎﺀ ﻟﻭﻥ ﻤﺤﺩﺩ ﻟﻌﻤﻭﺩ‬ ‫‪Color‬‬
‫ﻼ‬
‫ﺇﻋﻁﺎﺀ ﻨﻤﻁ ﺨﻁ ﻤﺤﺩﺩ ﻟﻌﻤﻭﺩ ) ﺇﻅﻬﺎﺭ ﺃﺤﺩ ﺍﻷﻋﻤﺩﺓ ﺒﻠﻭﻥ ﺨﻁ ﺁﺨﺭ ﻤﺜ ﹰ‬ ‫‪Font‬‬
‫(‬
‫ﺍﻟﺘﺤﻜﻡ ﺒﻤﻜﺎﻥ ﻅﻬﻭﺭ ﻋﻨﻭﺍﻥ ﺍﻟﻌﻤﻭﺩ‬ ‫‪Title-Alignment‬‬
‫ﺇﻋﻁﺎﺀ ﻋﻨﻭﺍﻥ ﻟﻌﻤﻭﺩ ) ﺃﻋﻁ ﺇﺴﻡ ﺍﻟﻌﻤﻭﺩ ﺒﺎﻟﻠﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ (‬ ‫‪Title-Caption‬‬
‫ﺇﻋﻁﺎﺀ ﻨﻤﻁ ﺨﻁ ﻤﺎ ﻟﻌﻨﻭﺍﻥ ﺍﻟﻌﻤﻭﺩ‬ ‫‪Title-Font‬‬
‫ﺴﻨﺸﺭﺡ ﺍﻟﺨﺎﺼﺔ ﺍﻷﺨﻴﺭﺓ ‪ PickList‬ﺒﻤﺜﺎل ‪:‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺒﺈﻅﻬﺎﺭ ﻻﺌﺤﺔ ﻤﻥ ﺍﻟﻘﻴﻡ ﻻﺨﺘﻴﺎﺭ ﺇﺤﺩﺍﻫﺎ ‪:‬‬
‫ﺍﺨﺘﺭ ﺍﻟﻌﻤﻭﺩ ‪ Nationality‬ﺍﺨﺘﺭ ﺍﻟﺨﺎﺼﺔ ‪ PickList‬ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ ، ...‬ﺴـﺘﻅﻬﺭ ﺍﻟﻨﺎﻓـﺫﺓ ‪String List‬‬
‫‪ Editor‬ﺃﻜﺘﺏ ﻓﻴﻬﺎ ﺍﻟﻘﻴﻡ ﺍﻟﺘﺎﻟﻴﺔ ‪ :‬ﺤﻠﺏ ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻷﻭل ‪ ،‬ﺩﻤﺸﻕ ﻓﻲ ﺍﻟﺜﺎﻨﻲ ﺜﻡ ﺍﻟﻘﺎﻫﺭﺓ ﺜﻡ ﻋﻤﺎﻥ ﺜـﻡ ﺍﻟﺭﻴـﺎﺽ ﺜـﻡ‬
‫ﺍﻟﺒﺤﺭﻴﻥ ‪........‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺤﻘل ‪ Nationality‬ﺴﻴﻅﻬﺭ ﺴﻬﻡ ﺍﻟﻘﺎﺌﻤﺔ ﺒﺠﻭﺍﺭﻩ ﺇﻀﻐﻁ ﻋﻠﻰ ﻫﺫﺍ ﺍﻟﺴﻬﻡ ﻭﺍﺨﺘﺭ ﻗﻴﻤـﺔ‬
‫ﻤﻥ ﺍﻟﻘﻴﻡ ﺍﻟﻤﺩﺨﻠﺔ ‪.‬‬

‫‪104‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻜﻤﺎ ﺃﻨﻪ ﻴﻤﻜﻨﻙ ﺃﻥ ﺘﺩﺨل ﻗﻴﻤﻪ ﻤﻥ ﺨﺎﺭﺝ ﻫﺫﻩ ﺍﻟﻼﺌﺤﺔ ﻴﺩﻭﻴﹰﺎ ‪.‬‬
‫ﻴﻤﻜﻥ ﺃﻴﻀﹰﺎ ﺇﻀﺎﻓﺔ ﻋﻤﻭﺩ ﺠﺩﻴﺩ ﺇﻟﻰ ﻤﺤﺭﺭ ﺍﻷﻋﻤﺩﺓ ﻋﻥ ﻁﺭﻴﻕ ﺍﺨﺘﻴﺎﺭ ﺍﻟﺯﺭ ﺍﻷﻭل ) ‪ ( Add New‬ﻭﺭﺒﻁ ﻫﺫﺍ ﺍﻟﻌﻤﻭﺩ‬
‫ﻼ ﺃﻥ ﺘﻌﺭﺽ ﻋﻤﻭﺩ ﻤﺎ ﻤﺭﺘﻴﻥ ) ﺴﻨﺘﻌﺭﻑ ﻻﺤﻘـﹰﺎ ﻋﻠـﻰ‬
‫ﻤﻊ ﺤﻘل ﻤﺎ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﺨﺎﺼﺔ ‪ ، FieldName‬ﻗﺩ ﺘﺭﻴﺩ ﻤﺜ ﹰ‬
‫ﻤﻴﺯﺓ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ( ‪.‬‬
‫ﻴﻤﻜﻥ ﺃﻴﻀﹰﺎ ﺘﻐﻴﺭ ﺘﺭﺘﻴﺏ ﺍﻷﻋﻤﺩﺓ ﻓﻲ ‪ DBGrid‬ﺒﺘﻐﻴﺭ ﺘﺭﺘﻴﺒﻬﺎ ﻓﻲ ﻤﺤﺭﺭ ﺍﻷﻋﻤﺩﺓ ‪....‬‬
‫‪ 2‬ـ ﺍﻟﻌﻨﺼﺭ ‪ : DBNavigator‬ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺴﺎﺒﻘﺔ ﻴﻤﻠﻙ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﻤﻬﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ : Flat‬ﺘﺠﻌل ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺃﺯﺭﺍﺭ ﺍﻟﻌﻨﺼﺭ ﻤﻨﺒﺴﻁﻪ ) ﻤﺴﻁﺤﺔ ( ‪.‬‬
‫ﺍﻟﺨﺎﺼﺔ ‪ : Hints‬ﺘﻤﻜﻥ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﻤﻥ ﻜﺘﺎﺒﺔ ﺘﻠﻤﻴﺢ ﻟﻙ ﺯﺭ ﻤﻥ ﺃﺯﺭﺍﺭ ﺍﻟﻌﻨﺼﺭ ‪.‬‬
‫ﺍﻟﺨﺎﺼﺔ ‪ : VisibleButton‬ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﻹﺨﻔﺎﺀ ﺃﻭ ﺇﻅﻬﺎﺭ ﺒﻌﺽ ﺃﺯﺭﺍﺭ ﺍﻟﻌﻨﺼﺭ ‪.‬‬
‫‪ 3‬ـ ﺍﻟﻌﻨﺼﺭ ‪ : DBtext‬ﻴﺸﺒﻪ ﺍﻟﻌﻨﺼﺭ ‪ Label‬ﻭﻟﻜﻨﻪ ﻴﻤﻜﻥ ﺭﺒﻁﻪ ﻤﻊ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪.‬‬
‫‪ 4‬ـ ﺍﻟﻌﻨﺼﺭ ‪ : DBEdit‬ﺘﻡ ﺸﺭﺤﻪ ﻤﺴﺒﻘﹰﺎ ‪.‬‬
‫‪ 5‬ـ ﺍﻟﻌﻨﺼﺭ ‪ : DBMemo‬ﻴﺘﻡ ﺭﺒﻁ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻤﻊ ﺤﻘل ﻤﻥ ﺍﻟﻨﻭﻉ ‪.Memo‬‬
‫‪ 6‬ـ ﺍﻟﻌﻨﺼﺭ ‪ : DBImage‬ﻴﺘﻡ ﺭﺒﻁ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻤﻊ ﺤﻘل ﻤﻥ ﺍﻟﻨﻭﻉ ﺼﻭﺭﺓ ‪.‬‬

‫‪105‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ﺍﻟﺴﺎﺒﻌﺔ ﻋﺸﺭ‬
‫ﺴﻨﺘﺎﺒﻊ ﺍﻵﻥ ﻤﻊ ﺍﻟﻌﻨﺎﺼﺭ ﻓﻲ ﺍﻟﺼﻔﺤﺔ ‪: Data Control‬‬
‫‪ 6‬ـ ﺍﻟﻌﻨﺼﺭ ‪ : DBImage‬ﻴﺴﺘﺨﺩﻡ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻟﻌﺭﺽ ﻭﺇﻀﺎﻓﺔ ﺍﻟﺼﻭﺭ ﺇﻟﻰ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪.‬‬
‫ﻤﺜﺎل ‪ ) :‬ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻌﻨﺼﺭﻴﻥ ‪ DBMemo‬ﻭ ‪: ( DBImage‬‬
‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﺘﺎﻟﻴﺔ ‪ Table :‬ﻭ ‪ Datasource‬ﻭ ‪ DBGrid‬ﻭ ‪ DBImage‬ﻭ‬
‫‪ DBMemo‬ﻭ ‪DBNavigator‬‬
‫ﺍﺭﺒﻁ ﺍﻟﻌﻨﺼﺭ ‪ Table1‬ﻤﻊ ﺍﻟﻘﺎﻋﺩﺓ ‪ DBDemos‬ﻭﻤﻊ ﺍﻟﺠﺩﻭل ‪ ) biolife.db‬ﻭﻫﻭ ﺠﺩﻭل ﻴﺤﻭﻱ ﻤﻌﻠﻭﻤـﺎﺕ ﻋـﻥ‬
‫ﺒﻌﺽ ﺍﻷﺴﻤﺎﻙ ( ﻭﺃﻋﻁﻪ ﺍﻟﺨﺎﺼﺔ ‪ Active‬ﺍﻟﻘﻴﻤﺔ ‪ ،True‬ﻭﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ DataSet‬ﻟﻠﻌﻨﺼﺭ ‪ DataSource‬ﺍﻟﻘﻴﻤﺔ‬
‫‪ Table1‬ﻭﺃﻋﻁ ﺒﻘﻴﺔ ﺍﻟﻌﻨﺎﺼـﺭ ﻓـﻲ ﺍﻟﺨﺎﺼـﺔ ‪ DataSource‬ﺍﻟﻘﻴﻤـﺔ ‪ ، .. DataSource1‬ﻭﺍﺭﺒـﻁ ﺍﻟﻌﻨـﺼﺭ‬
‫‪ DBMemo1‬ﻤﻊ ﺍﻟﺤﻘل ‪ Notes‬ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ ، Datafield‬ﻭﺍﻟﻌﻨﺼﺭ ‪ DBImage1‬ﻤﻊ ﺍﻟﺤﻘل ‪... Graphic‬‬

‫ﻻ ﺃﻥ ﻗﻴﻤﺔ ﺍﻟﺤﻘﻠﻴﻥ ‪ Notes‬ﻭ ‪ Graphic‬ﻏﻴﺭ ﻅﺎﻫﺭﺘﻴﻥ ﻓﻲ ﺍﻟﻌﻨﺼﺭ ‪ DBGrid‬ﻭﺫﻟﻙ ﻷﻥ ﻫﺫﺍ ﺍﻟﻌﻨـﺼﺭ ﻻ‬

‫ﻻﺤﻅ ﺃﻭ ﹰ‬
‫ﻴﺴﺘﻁﻴﻊ ﻋﺭﺽ ﺍﻟﺤﻘﻭل ﺫﺍﺕ ﺍﻟﺤﺠﻡ ﺍﻟﻜﺒﻴﺭ ﻭﺒﺎﻟﺘﺎﻟﻲ ﻻ ﻴﺴﺘﻁﻴﻊ ﺘﺤﺭﻴﺭﻫﺎ ﻟﺫﻟﻙ ﺇﺫﺍ ﺃﺭﺩﻨﺎ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻫﺫﻩ ﺍﻟﺤﻘﻭل ﻻ ﺒﺩ‬
‫ﻟﻨﺎ ﻤﻥ ﺍﺴﺘﺨﺩﺍﻡ ﻋﻨﺎﺼﺭ ﺍﻟﺘﺤﻜﻡ ﺍﻟﺘﻲ ﺘﺴﺘﻁﻴﻊ ﺇﻅﻬﺎﺭ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﺤﻘﻭل ﻟﺫﻟﻙ ﺍﺴﺘﺨﺩﻤﻨﺎ ﺍﻟﻌﻨﺼﺭﻴﻥ ‪ DBMemo‬ﻭ‬
‫‪: DBImage‬‬
‫ﺘﺤﺭﻴﺭ ) ﺇﻀﺎﻓﺔ ( ﺤﻘل ﻤﻥ ﻨﻭﻉ ‪: Graphic‬‬
‫ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Edit‬ﺃﻭ ﺍﻟﺯﺭ ‪ Insert‬ﻴﻤﻜﻨﻙ ﺘﺤﺭﻴﺭ ﺍﻟﺠﺩﻭل ﻤﻥ ﺨـﻼل ﺍﻟﻌﻨـﺼﺭ ‪ DBGrid‬ﻭ ﺍﻟﻌﻨـﺼﺭ‬
‫‪ DBMemo‬ﻭﺘﺒﻘﻰ ﺍﻟﻤﺸﻜﻠﺔ ﻓﻲ ﻜﻴﻔﻴﺔ ﺘﺤﺭﻴﺭ ﻋﻨﺼﺭ ﺍﻟﺼﻭﺭﺓ ‪.‬‬
‫ﻴﺘﻡ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻌﻨﺼﺭ ‪ DBImage‬ﻋﻥ ﻁﺭﻴﻕ ﺤﺎﻓﻅﺔ ﺍﻟﻭﻴﻨﺩﻭﺯ ‪ ClipBoard‬ﻭﻴﻜﻭﻥ ﺫﻟﻙ ﺒﺈﺤﺩﻯ ﺍﻟﻁﺭﻴﻘﻴﻥ‬
‫‪ 1‬ـ ﻨﺴﺦ ﺍﻟﺼﻭﺭﺓ ﺍﻟﻤﻁﻠﻭﺒﺔ ﺇﻟﻰ ﺍﻟﺤﺎﻓﻅﺔ ﻋﻥ ﻁﺭﻴﻕ ﺃﺤﺩ ﺒﺭﺍﻤﺞ ﺍﻟﺭﺴﻡ ﻭﻤﻥ ﺜﻡ ﺍﺨﺘﻴﺎﺭ ﺍﻟﻌﻨﺼﺭ ‪ DbImage‬ﺇﺜﻨـﺎﺀ‬
‫ﺍﻟﺘﻨﻔﻴﺫ ﻭﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭﻴﻥ ‪ Ctrl+v‬ﺃﻭ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻷﻤـﺭ ‪ DBImage1.PasteFromClipboard‬ﻓـﻲ ﺤـﺩﺙ‬
‫ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ‪.‬‬

‫‪106‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ 2‬ـ ﺘﺤﻤﻴل ﺍﻟﺼﻭﺭﺓ ﻤﻥ ﻤﻠﻑ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻌﻨﺼﺭ ‪ OpenPictureDialog‬ﻭﻤﻥ ﺜﻡ ﻨﺴﺦ ﺍﻟـﺼﻭﺭﺓ ﺇﻟـﻰ ﺍﻟﺤﺎﻓﻅـﺔ‬
‫ﻭﻟﺼﻘﻬﺎ ﻭﻟﺘﻨﻔﻴﺫ ﺫﻟﻙ ﺃﻀﻑ ﻋﻨﺼﺭ ﺯﺭ ﻭﻋﻨﺼﺭ ‪ OpenPictureDialog‬ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺴﺎﺒﻕ ) ﻻ ﺘﻨﺴﻰ ﺍﺴـﺘﺨﺩﺍﻡ‬
‫ﺍﻟﻭﺤﺩﺓ ‪ Jpeg‬ﻓﻲ ﺤﺎل ﺃﺭﺩﺕ ﺍﺴﺘﺨﺩﺍﻡ ﺼﻭﺭ ‪ ( Jpg‬ﻭﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪If OpenPictureDialog1.Execute then Begin‬‬
‫;) ‪DBImage1.Picture.LoadFromFile(OpenPictureDialog1.FileName‬‬
‫; ‪DBImage1.CopyToClipboard‬‬
‫; ‪DBImage1.PasteFromClipboard‬‬
‫;‪end‬‬
‫ﻨﻘﻭﻡ ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ ﺒﺘﺤﻤﻴل ﺍﻟﺼﻭﺭﺓ ﺇﻟﻰ ﺍﻟﻌﻨﺼﺭ ‪ DBImage1‬ﻭﻤﻥ ﺜﻡ ﻨﺴﺨﻬﺎ ﺇﻟﻰ ﺍﻟﺤﺎﻓﻅﺔ ﻭﺇﻋـﺎﺩﺓ ﻟـﺼﻘﻬﺎ ﻓـﻲ‬
‫ﺍﻟﻌﻨﺼﺭ ‪.‬‬
‫ﻋﻠﻰ ﻜل ﺤﺎل ﻫﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﻟﻴﺴﺕ ﻁﺭﻴﻘﺔ ﺠﻴﺩﺓ ﻟﻠﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺤﺎﻓﻅﺔ ﻭﻟﻜﻨﻬﺎ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻷﺴﻬل ﻭﺴﻭﻑ ﻨﺘﻌﻠﻡ ﻗﺭﻴﺒﹰﺎ ﺃﺴﻠﻭﺏ‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺤﺎﻓﻅﺔ ﻋﻨﺩ ﺩﺭﺍﺴﺔ ﺍﻟﺭﺴﻡ ﻓﻲ ﺩﻟﻔﻲ ‪.‬‬
‫‪ 3‬ـ ﻴﻤﻜﻥ ﺘﺤﺭﻴﺭ ﺤﻘل ﻤﻥ ﻨﻭﻉ ﺼﻭﺭﺓ ﻤﺒﺎﺸﺭﺓ ﺩﻭﻥ ﺍﻟﻌﻭﺩﺓ ﺇﻟﻰ ﺍﻟﻌﻨﺼﺭ ‪ DBImage‬ﺃﻭ ‪ DataSource‬ﻜﻤﺎ ﻭﺠﺩﻨﺎ‬
‫ﻓﻲ ﺍﻟﺠﻠﺴﺔ ﺍﻟﻤﺎﻀﻴﺔ ﻭﻴﻜﻭﻥ ﺫﻟﻙ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪Table1.edit‬‬
‫‪If OpenPictureDialog1.Execute then‬‬
‫;)‪Table1Graphic.LoadFromFile(OpenPictureDialog1.FileName‬‬
‫; ‪Table1.Post‬‬
‫ﻤﻼﺤﻅﺔ ‪:‬‬
‫‪ 1‬ـ ﻻ ﻴﻤﻜﻥ ﻓﻲ ﻫﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﺍﺴﺘﺨﺩﺍﻡ ﺼﻭﺭ ﻤﻥ ﻨﻭﻉ ‪ Jpg‬ﻷﻥ ﺍﻟﺤﻘل ﻤﻥ ﻨﻭﻉ ﺼﻭﺭﺓ ﻻ ﻴﺨﺯﻥ ﺇﻻ ﺼﻭﺭ ﻤﻥ ﻨﻭﻉ‬
‫‪ ، Bmp‬ﺃﻤﺎ ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﻓﺘﻘﻭﻡ ﺍﻟﺤﺎﻓﻅﺔ ﺒﺘﺤﻭﻴل ﺍﻟﻤﻠﻑ ﻤﻥ ﻨﻭﻉ ‪ Jpg‬ﺇﻟﻰ ﻤﻠﻑ ‪ Bmp‬ﺘﻠﻘﺎﺌﻴﹰﺎ ‪.‬‬
‫‪ 2‬ـ ﺘﺨﺯﻴﻥ ﺍﻟﺼﻭﺭ ﻤﻥ ﻨﻭﻉ ‪ Bmp‬ﻓﻲ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺴﻴﺤﺘﺎﺝ ﺇﻟﻰ ﻤﺴﺎﺤﺔ ﺘﺨﺯﻴﻥ ﻜﺒﻴـﺭﺓ ﻟـﺫﻟﻙ ﻴﻔـﻀل ﺒﻌـﺽ‬
‫ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺤﻘل ﻤﻥ ﻨﻭﻉ ‪ Binary‬ﻭﺘﺨﺯﻴﻥ ﻤﻠﻑ ﺍﻟﺼﻭﺭﺓ ‪ Jpg‬ﺜﻨﺎﺌﻴﹰﺎ ﻭﻤﻥ ﺜﻡ ﺇﻋﺎﺩﺓ ﻫﺫﺍ ﺍﻟﺤﻘل ﺇﻟﻰ ﻤﻠـﻑ‬
‫ﻹﻅﻬﺎﺭﻩ ‪...‬‬
‫‪ 7‬ـ ﺍﻟﻌﻨﺼﺭ ‪: DBListBox‬‬
‫ﻴﻌﺭﺽ ﻗﺎﺌﻤﺔ ﻤﻥ ﺍﻟﻘﻴﻡ ﺍﻟﺠﺎﻫﺯﺓ ﻟﺘﻤﻜﻴﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻤﻥ ﺍﺨﺘﻴﺎﺭ ﺇﺤﺩﺍﻫﺎ ﻹﺩﺨﺎﻟﻬﺎ ﻀﻤﻥ ﺴﺠل ﻤﺎ ﻓﻲ ﺤﻘل ﻤﻌﻴﻥ ﻭﻻ ﻴﻤﻜﻥ‬
‫ﻟﻠﻤﺴﺘﺨﺩﻡ ﺇﻀﺎﻓﺔ ﻗﻴﻡ ﺠﺩﻴﺩﺓ ﻓﻲ ﻫﺫﻩ ﺍﻟﻘﺎﺌﻤﺔ ‪.‬‬
‫‪ 8‬ـ ﺍﻟﻌﻨﺼﺭ ‪: DBComboBox‬‬
‫ﻴﻅﻬﺭ ﻗﺎﺌﻤﺔ ﻤﻨﺴﺩﻟﺔ ﻤﻥ ﺍﻟﻘﻴﻡ ﺒﺤﻴﺙ ﻴﺴﺘﻁﻴﻊ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺍﺨﺘﻴﺎﺭ ﺇﺤﺩﺍﻫﺎ ﻹﺩﺨﺎﻟﻬﺎ ﻟﺤﻘل ﻤﺎ‪ ،‬ﻭﻴﻤﻜﻥ ﻟﻠﻤﺴﺘﺨﺩﻡ ﺃﻴـﻀﹰﺎ ﺃﻥ‬
‫ﻴﻘﻭﻡ ﺒﺈﺩﺨﺎل ﻗﻴﻡ ﺃﺨﺭﻯ ﻀﻤﻨﻬﺎ ﻏﻴﺭ ﻤﻭﺠﻭﺩﺓ ﻤﺴﺒﻘﹰﺎ ﻹﻟﺤﺎﻗﻬﺎ ﺒﻘﻴﻤﺔ ﺤﻘل ﻀﻤﻥ ﺴﺠل ‪.‬‬
‫‪ 9‬ـ ﺍﻟﻌﻨﺼﺭ ‪: DBDateTimePiker‬‬
‫ﻴﺭﺘﺒﻁ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻤﻊ ﺤﻘﻭل ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Date‬ﺃﻭ ‪ Time‬ﺃﻭ ‪ TimeStamp‬ﻭﺒﺎﻟﻨﺴﺒﺔ ﻟﻠﻨﻭﻉ ﺍﻟﺤﻘل ﺘﺤـﺩﺩ ﺍﻟﺨﺎﺼـﺔ‬
‫‪ Kind‬ﺇﺫﺍ ﻜﻨﺎ ﻨﺭﻴﺩ ﺇﻅﻬﺎﺭ ﺍﻟﻭﻗﺕ ﺃﻭ ﺍﻟﺘﺎﺭﻴﺦ ‪.‬‬

‫‪107‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻤﺜﺎل ‪ ) :‬ﺍﻟﻌﻨﺼﺭﻴﻥ ‪ DBlistBox‬ﻭ ‪: ( DBcomboBox‬‬
‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﺃﻀﻑ ﺇﻟـﻰ ﺍﻟﻨﻤـﻭﺫﺝ ﺍﻟﻌﻨﺎﺼـﺭ ‪ Table‬ﻭ ‪ DataSource‬ﻭﻋﻨـﺼﺭﻱ ‪ DBedit‬ﻭﻋﻨـﺼﺭ‬
‫‪ DBListBox‬ﻭ ‪ DBComboBox‬ﻭ ﻋﻨﺼﺭﻱ ‪ DBDateTimePiker‬ﻭ ﻋﻨﺼﺭ ‪. DBNavigator‬‬
‫ﺭﺘﺏ ﺍﻟﻌﻨﺎﺼﺭ ﻜﻤﺎ ﻓﻲ ﺍﻟﺸﻜل‬
‫ﺍﺭﺒﻁ ﺍﻟﻌﻨﺼﺭ ‪ Table1‬ﻤـﻊ ﺍﻟﻘﺎﻋـﺩﺓ ‪ Travel‬ﻭﺍﻟﺠـﺩﻭل ‪ Trips‬ﻭﺍﻋـﻁ‬
‫ﺍﻟﺨﺎﺼﺔ ‪ Active‬ﺍﻟﻘﻴﻤﺔ ‪. True‬‬
‫ﺍﺭﺒﻁ ﺍﻟﻌﻨﺼﺭ ‪ DataSouce1‬ﻤﻊ ﺍﻟﻌﻨﺼﺭ ‪، Table1‬‬
‫ﺤﺩﺩ ﺒﺎﻗﻲ ﺍﻟﻌﻨﺎﺼـﺭ ﻭﺃﻋﻁﻬـﺎ ﺍﻟﻘﻴﻤـﺔ ‪ Datasoucrce1‬ﻓـﻲ ﺍﻟﺨﺎﺼـﺔ‬
‫‪. DataSource‬‬
‫ﺍﺭﺒﻁ ﺍﻟﻌﻨﺼﺭ ‪ DBedit1‬ﻤﻊ ﺍﻟﺤﻘل ‪ TripNo‬ﻓـﻲ ﺍﻟﺨﺎﺼـﺔ ‪Datafield‬‬
‫ﻭﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ ReadOnly‬ﺍﻟﻘﻴﻤﺔ ‪ ) True‬ﻷﻥ ﺍﻟﺤﻘل ﺤﻘل ﺘﺭﻗﻴﻡ ﺘﻠﻘـﺎﺌﻲ‬
‫ﻭﻻ ﺤﺎﺠﺔ ﺇﻟﻰ ﺘﺤﺭﻴﺭﻩ (‬
‫ﺍﺭﺒﻁ ﺍﻟﻌﻨﺼﺭ ‪ DBedit2‬ﻤﻊ ﺍﻟﺤﻘل ‪............. Company‬‬
‫ﺍﺭﺒﻁ ﺍﻟﻌﻨﺼﺭ ‪ DBListBox1‬ﻤﻊ ﺍﻟﺤﻘل ‪ GoFrom‬ﻭﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ Items‬ﺍﻟﻘﻴﻡ ﺍﻟﺘﺎﻟﻴﺔ ‪ :‬ﺤﻠﺏ ‪ ،‬ﻋﻤﺎﻥ ‪،‬ﺩﻤـﺸﻕ ‪،‬‬
‫ﺍﻟﻼﺫﻗﻴﺔ ‪ ،‬ﺃﺜﻴﻨﺎ ‪..‬‬
‫ﺍﺭﺒﻁ ﺍﻟﻌﻨﺼﺭ ‪ ComboBox1‬ﻤﻊ ﺍﻟﺤﻘل ‪ ArriveTo‬ﻭﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ Items‬ﺍﻟﻘﻴﻡ ﺍﻟﺘﺎﻟﻴﺔ ‪ :‬ﺍﻟﻘﺎﻫﺭﺓ ‪ ،‬ﺍﻟﺭﻴﺎﺽ ‪ ،‬ﺠﺩﺓ‬
‫‪ ،‬ﻋﻤﺎﻥ ‪ ،‬ﻫﺎﻤﺒﻭﺭﻍ ‪...‬‬
‫ﺍﺭﺒﻁ ﺍﻟﻌﻨﺼﺭ ‪ DBDateTimePiker1‬ﻤﻊ ﺍﻟﺤﻘل ‪ GoTime‬ﻭﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ Kind‬ﺍﻟﻘﻴﻤﺔ ‪ ) dtkTime‬ﺘـﺫﻜﺭ ﺃﻥ‬
‫ﺍﻟﺤﻘل ‪ GoTime‬ﻤﻥ ﺍﻟﻨﻭﻉ ‪. ( Timestamp‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻻﺤﻅ ﻤﺎ ﻴﻠﻲ ‪:‬‬
‫‪ 1‬ـ ﺘﻨﻘل ﺒﻴﻥ ﺍﻟﺴﺠﻼﺕ ﻭﻻﺤﻅ ﺍﻟﺘﻐﻴﺭ ﻓﻲ ﺍﻟﻌﻨﺎﺼﺭ ‪ ComboBox1‬ﻭ ‪. DbListBox1‬‬
‫‪ 2‬ـ ﻴﻤﻜﻥ ﺍﻹﻀﺎﻓﺔ ﻓﻲ ﺍﻟﺤﻘل ‪ GoFrom‬ﻤﻥ ﺨﻼل ﺍﺨﺘﻴﺎﺭ ﺃﺤﺩ ﻋﻨﺎﺼﺭ ﺍﻟﻘﺎﺌﻤﺔ ‪. DBListBox1‬‬
‫‪ 3‬ـ ﻴﻤﻜﻥ ﺍﻹﻀﺎﻓﺔ ﻓﻲ ﺍﻟﺤﻘل ‪ ArriveTo‬ﻤﻥ ﺨﻼل ﺍﺨﺘﻴﺎﺭ ﺃﺤﺩ ﻋﻨﺎﺼﺭ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﻤﻨﺴﺩﻟﺔ ‪ DBComboBox1‬ﺃﻭ‬
‫ﻜﺘﺎﺒﺔ ﻗﻴﻤﺔ ﻤﺎ ﺩﺍﺨل ﺍﻟﻌﻨﺼﺭ ‪.‬‬
‫‪ 4‬ـ ﺃﻀﻑ ﺇﻟﻰ ﺍﻟﺸﻜل ﻋﻨﺼﺭ ‪ DbGrid‬ﻭﺤﺎﻭل ﺍﻹﻀﺎﻓﺔ ﻭﺍﻟﺤﺫﻑ ﻭﺍﻟﺘﻌﺩﻴل ‪...‬‬
‫‪ 10‬ـ ﺍﻟﻌﻨﺼﺭ ‪ : DBCheckBox‬ﻴﺭﺘﺒﻁ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻤﻊ ﺤﻘل ﻤﻥ ﻨﻭﻉ ‪. Logical‬‬
‫‪ 11‬ـ ﺍﻟﻌﻨﺼﺭ ‪ : DBRadioGroup‬ﻴﺴﺘﺨﺩﻡ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻹﺩﺨﺎل ﺃﻭ ﺇﻅﻬﺎﺭ ﻗﻴﻤﺔ ﻤﺎ ﺇﻟﻰ ﺤﻘل ﻴﺄﺨﺫ ﻋﺩﺩ ﻤﺤﺩﺩ ﻤﻥ‬
‫ﺍﻟﻘﻴﻡ ‪:‬‬
‫ﻤﺜﺎل ‪:‬‬
‫ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﺍﺴﺘﺒﺩل ﺍﻟﻌﻨﺼﺭ ‪ DBListBox‬ﺒﺎﻟﻌﻨﺼﺭ ‪ ، DBRadioGroup‬ﺍﻋـﻁ ﺍﻟﺨﺎﺼـﺔ ‪DataSource‬‬
‫ﺍﻟﻘﻴﻤﺔ ‪ Datasource1‬ﻭ ﺍﻟﺨﺎﺼﺔ ‪ DataField‬ﺍﻟﻘﻴﻤﺔ ‪ GoFrom‬ﻭﺍﻟﺨﺎﺼﺔ ‪ Items‬ﺍﻟﻘﻴﻡ ﺍﻟﺘﺎﻟﻴﺔ ‪ :‬ﺤﻠـﺏ ‪ ،‬ﻋﻤـﺎﻥ‬
‫‪،‬ﺩﻤﺸﻕ ‪ ،‬ﺍﻟﻼﺫﻗﻴﺔ ‪ ،‬ﺃﺜﻴﻨﺎ ‪..‬‬
‫‪108‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻭﺍﻟﺨﺎﺼﺔ ‪ Values‬ﺍﻟﻘﻴﻡ ‪ :‬ﺤﻠﺏ ‪ ،‬ﻋﻤﺎﻥ ‪،‬ﺩﻤﺸﻕ ‪ ،‬ﺍﻟﻼﺫﻗﻴﺔ ‪ ،‬ﺃﺜﻴﻨﺎ ‪. ..‬‬
‫ﺤﻴﺙ ﺘﺴﺘﺨﺩﻡ ﺍﻟﺨﺎﺼﺔ ‪ Items‬ﻹﻅﻬﺎﺭ ﻋﻨﺎﻭﻴﻥ ﻷﺯﺭﺍﺭ ﺍﻟﺭﺍﺩﻴﻭ ‪ ،‬ﺃﻤﺎ ‪ Values‬ﻓﺘﺴﺘﺨﺩﻡ ﻹﻋﻁﺎﺀ ﻗﻴﻤﺔ ﻟﻠﺤﻘل ﻓﻲ ﺤﺎل‬
‫ﻀﻐﻁ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻠﻰ ﺯﺭ ﺍﻟﺭﺍﺩﻴﻭ ‪..‬‬
‫‪ _ 12‬ﺍﻟﻌﻨﺼﺭ ‪ : DBLookUpListBox‬ﻴﺸﺒﻪ ﺍﻟﻌﻨﺼﺭ ‪ DBListBox‬ﻭﻟﻜﻥ ﺒـﺩ ﹰﻻ ﻤـﻥ ﺍﻟﺨﺎﺼـﺔ ‪ Item‬ﻴـﺘﻡ‬
‫ﺍﻟﺤﺼﻭل ﻋﻠﻰ ﻗﻴﻡ ﺍﻟﻘﺎﺌﻤﺔ ﻤﻥ ﺨﻼل ﺠﺩﻭل ﺁﺨﺭ ‪.‬‬
‫‪ 13‬ـ ﺍﻟﻌﻨﺼﺭ ‪ : DBLookUpComboBox‬ﻴﺸﺒﻪ ﺍﻟﻌﻨﺼﺭ ‪ DBComboBox‬ﻭﻟﻜﻥ ﺒﺩ ﹰﻻ ﻤﻥ ﺍﻟﺨﺎﺼـﺔ ‪Item‬‬
‫ﻴﺘﻡ ﺍﻟﺤﺼﻭل ﻋﻠﻰ ﻗﻴﻡ ﺍﻟﻘﺎﺌﻤﺔ ﻤﻥ ﺨﻼل ﺠﺩﻭل ﺁﺨﺭ ‪.‬‬
‫ﻤﺜﺎل ‪:‬‬
‫ﺴﻭﻑ ﻨﻘﻭﻡ ﺍﻵﻥ ﺒﺈﻨﺸﺎﺀ ﻨﻤﻭﺫﺝ ﻟﻺﺩﺨﺎل ﺇﻟﻰ ﺠﺩﻭل " ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻭﺍﻟﺭﺤﻼﺕ " ‪ PassAndTrip‬ﺤﻴﺙ ﺴﻴﺘﻡ ﺇﺩﺨﺎل ﺭﻗﻡ‬
‫ﺍﻟﻤﺴﺎﻓﺭ ﻤﻥ ﺨﻼل ﺍﻟﻌﻨﺼﺭ ‪ DBLookUpListBox‬ﺍﻟﺫﻱ ﺴﻴﺭﺘﺒﻁ ﻤﻊ ﺠﺩﻭل ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻹﺤﻀﺎﺭ ﺍﺴـﻡ ﺍﻟﻤـﺴﺎﻓﺭ ‪،‬‬
‫ﻭﺴﻴﺘﻡ ﺇﺩﺨﺎل ﺭﻗﻡ ﺍﻟﺭﺤﻠﺔ ﻤﻥ ﺨﻼل ﺍﻟﻌﻨﺼﺭ ‪ DBLookUpComboBox‬ﺍﻟﺫﻱ ﺴﻴﺭﺘﺒﻁ ﻤـﻊ ﺠـﺩﻭل ﺍﻟﻤـﺴﺎﻓﺭﻴﻥ‬
‫ﻹﺤﻀﺎﺭ ﺍﺴﻡ ﺸﺭﻜﺔ ﺍﻟﻁﻴﺭﺍﻥ ‪.‬‬
‫ﺍﺒﺩِﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﺜﻼﺜﺔ ﻋﻨﺎﺼﺭ ‪ Table‬ﻭﺜﻼﺜﺔ ﻋﻨﺎﺼﺭ ‪ DataSource‬ﻭﻋﻨﺼﺭﻱ ‪ DBedit‬ﻭﻋﻨﺼﺭ‬
‫‪ DBNavigator‬ﻭﻋﻨﺼﺭ ‪ DBLookupListBox‬ﻭﻋﻨﺼﺭ ‪ DBLookUpComboBox‬ﻭﺍﻟﻌﻨﺼﺭ ‪. DBGrid‬‬
‫ﺍﺭﺒﻁ ﺍﻟﻌﻨﺼﺭ ‪ Table1‬ﻤﻊ ﺍﻟﺠﺩﻭل ‪ PassAndTrip‬ﻓﻲ ﺍﻟﻘﺎﻋﺩﺓ ‪ Travel‬ﻭﺍﺭﺒﻁ ﺍﻟﻌﻨﺼﺭ ‪ DataSource1‬ﻤﻌﻪ ‪.‬‬
‫ﺍﺭﺒﻁ ﺍﻟﻌﻨﺼﺭ ‪ Table2‬ﻤﻊ ﺍﻟﺠﺩﻭل ‪ Passengers‬ﻓﻲ ﺍﻟﻘﺎﻋﺩﺓ ‪ Travel‬ﻭﺍﺭﺒﻁ ﺍﻟﻌﻨﺼﺭ ‪ DataSource2‬ﻤﻌﻪ ‪.‬‬
‫ﺍﺭﺒﻁ ﺍﻟﻌﻨﺼﺭ ‪ Table1‬ﻤﻊ ﺍﻟﺠﺩﻭل ‪ Trips‬ﻓﻲ ﺍﻟﻘﺎﻋﺩﺓ ‪ Travel‬ﻭﺍﺭﺒﻁ ﺍﻟﻌﻨﺼﺭ ‪ DataSource3‬ﻤﻌﻪ ‪.‬‬
‫ﺃﻋﻁ ﺠﻤﻴﻊ ﺍﻟﺠﺩﺍﻭل ﺍﻟﺨﺎﺼﺔ ‪ Active‬ﺍﻟﻘﻴﻤﺔ ‪. True‬‬
‫ﺃﻋﻁ ﺒﻘﻴﺔ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﺨﺎﺼﺔ ‪ Datasource‬ﺍﻟﻘﻴﻤﺔ ‪. DataSource1‬‬
‫ﺃﻋﻁ ‪ DBLookupListbox1‬ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﺍﻟﺨﺎﺼﺔ ‪ DataField‬ﺍﻟﻘﻴﻤﺔ "‪ : "PNo‬ﺴﻴﺭﺘﺒﻁ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻤﻊ ﺍﻟﺤﻘل ‪ Pno‬ﻓﻲ ﺠﺩﻭل " ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻭﺍﻟﺭﺤﻼﺕ " ‪.‬‬
‫ﺍﻟﺨﺎﺼﺔ ‪ Listsource‬ﺍﻟﻘﻴﻤﺔ ‪ : DataSource2‬ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﺘﻲ ﺴﻴﻅﻬﺭﻫﺎ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﺴﺘﺄﺘﻲ ﻋـﻥ ﻁﺭﻴـﻕ ﺍﻟﺠـﺩﻭل‬
‫‪. Passengers‬‬
‫ﺍﻟﺨﺎﺼﺔ ‪ ListField‬ﺍﻟﻘﻴﻤﺔ ‪ : Pname‬ﺴﻴﻅﻬﺭ ﻓﻲ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻗﺎﺌﻤﺔ ﺒﺠﻤﻴـﻊ ﺃﺴـﻤﺎﺀ ﺍﻟﻤـﺴﺎﻓﺭﻴﻥ ﻓـﻲ ﺍﻟﺠـﺩﻭل‬
‫‪. Passengers‬‬
‫ﺍﻟﺨﺎﺼﺔ ‪ KeyField‬ﺍﻟﻘﻴﻤﺔ ‪ : PNo‬ﺘﺤﺩﺩ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺘﻲ ﺴﻴﺘﻡ ﺇﺩﺨﺎﻟﻬﺎ ﺇﻟﻰ ﺠـﺩﻭل ‪ PassAndTrip‬ﻋﻨـﺩ‬
‫ﺍﺨﺘﻴﺎﺭ ﺍﺴﻡ ﺍﻟﻤﺴﺎﻓﺭ ﻋﻤﻠﻴﹰﺎ ﻴﺘﻡ ﻓﻲ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺘﺤﺩﻴﺩ ﺍﻟﻤﻔﺘﺎﺡ ﺍﻟﺭﺌﻴﺴﻲ ‪ KeyField‬ﺍﻟﻤﺭﺘﺒﻁ ﻤﻌﻪ ﺍﻟﻤﻔﺘـﺎﺡ ﺍﻟﺜـﺎﻨﻭﻱ‬
‫‪. DataFields‬‬
‫ﺍﻋﻁ ﺍﻟﻌﻨﺼﺭ ‪ DBLookupComboBox1‬ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﺍﻟﺨﺎﺼﺔ ‪ DataField‬ﺍﻟﻘﻴﻤﺔ "‪ : "TripNo‬ﺴﻴﺭﺘﺒﻁ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻤﻊ ﺍﻟﺤﻘـل ‪ TripNo‬ﻓـﻲ ﺠـﺩﻭل " ﺍﻟﻤـﺴﺎﻓﺭﻴﻥ‬
‫ﻭﺍﻟﺭﺤﻼﺕ " ‪.‬‬

‫‪109‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺨﺎﺼﺔ ‪ Listsource‬ﺍﻟﻘﻴﻤﺔ ‪ : DataSource3‬ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﺘﻲ ﺴﻴﻅﻬﺭﻫﺎ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﺴﺘﺄﺘﻲ ﻋـﻥ ﻁﺭﻴـﻕ ﺍﻟﺠـﺩﻭل‬
‫‪.Trips‬‬
‫ﺍﻟﺨﺎﺼﺔ ‪ ListField‬ﺍﻟﻘﻴﻤﺔ ‪ : Company‬ﺴﻴﻅﻬﺭ ﻓﻲ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻗﺎﺌﻤﺔ ﺒﺠﻤﻴﻊ ﺃﺴﻤﺎﺀ ﺸﺭﻜﺎﺕ ﺍﻟﻁﻴﺭﺍﻥ ﻓﻲ ﺍﻟﺠﺩﻭل‬
‫‪. Trips‬‬
‫ﺍﻟﺨﺎﺼﺔ ‪ KeyField‬ﺍﻟﻘﻴﻤﺔ ‪ :TripNo‬ﺘﺤﺩﺩ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺘﻲ ﺴﻴﺘﻡ ﺇﺩﺨﺎﻟﻬﺎ ﺇﻟﻰ ﺠﺩﻭل ‪ PassAndTrip‬ﻋﻨﺩ‬
‫ﺍﺨﺘﻴﺎﺭ ﺍﺴﻡ ﺍﻟﺸﺭﻜﺔ ‪.‬‬
‫ﺍﺭﺒﻁ ﺍﻟﻌﻨﺼﺭ ‪ Dbedit1‬ﻤﻊ ﺍﻟﺤﻘل ‪ SeatNo‬ﻭﺍﻟﻌﻨﺼﺭ ‪ DBEdit2‬ﻤﻊ ﺍﻟﺤﻘل ‪. ClassNo‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺘﻨﻘل ﺒﻴﻥ ﺍﻟﺴﺠﻼﺕ ﻭﻻﺤﻅ ﺘﻐﻴﺭ ﺍﻟﻘﻴﻡ ﻓﻲ ﺍﻟﻌﻨﺎﺼﺭ ‪.‬‬
‫ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ +‬ﺇﻀﺎﻓﺔ ﻭﺃﺩﺨل ﻗﻴﻡ ﻋﻥ ﻁﺭﻴﻕ ﺍﺨﺘﻴﺎﺭ ﺍﺴﻡ ﺃﺤﺩ ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻭ ﺍﺴﻡ ﺍﻟﺸﺭﻜﺔ ‪....‬‬
‫ﺃﻀﻑ ﻋﺩﺩ ﻤﻥ ﺍﻟﺴﺠﻼﺕ ﻟﻠﺘﺂﻟﻑ ﻤﻊ ﺍﻟﻌﻨﺎﺼﺭ ‪...‬‬
‫‪ 14‬ـ ﺍﻟﻌﻨﺼﺭ ‪ : DBRichEdit‬ﻴﻤﻜﻥ ﺭﺒﻁ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻤـﻊ ﺤﻘـل ﻤـﻥ ﻨـﻭﻉ ‪ Memo‬ﺃﻭ ﺤﻘـل ﻤـﻥ ﻨـﻭﻉ‬
‫‪Formatted Memo‬‬
‫‪ 15‬ـ ﺍﻟﻌﻨﺼﺭ ‪ : DBCtrlGrid‬ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻴﻘﻭﻡ ﺒﺈﻅﻬﺎﺭ ﺼﻔﺤﺔ ﻤﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺤﻴﺙ ﻴﻘﻭﻡ ﻫـﺫﺍ ﺍﻟﻌﻨـﺼﺭ ﻴﺘﻭﻟﻴـﺩ‬
‫ﺴﻁﻭﺭ ﺒﻌﺩﺩ ﺴﺠﻼﺕ ﺍﻟﺠﺩﻭل ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ‪.‬‬
‫ﻤﺜﺎل ‪:‬‬
‫ﺃﻀﻑ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺴﺎﺒﻕ ﻭﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ DataSource‬ﺍﻟﻘﻴﻤﺔ ‪ DataSource2‬ﻭﻀﻊ ﺩﺍﺨﻠﻪ ﻋﻨـﺼﺭ‬
‫‪ DBedit‬ﻭﺍﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ DataField‬ﺍﻟﻘﻴﻤﺔ ‪ ، Pname‬ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻻﺤﻅ ﺍﻟﻨﺘﺎﺌﺞ ‪.‬‬
‫‪ 16‬ـ ﺍﻟﻌﻨﺼﺭ ‪ : DBChart‬ﻹﻅﻬﺎﺭ ﻤﺨﻁﻁﺎﺕ ﺒﻴﺎﻨﻴﺔ ﻤﻥ ﻟﻠﻘﻴﻡ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺠﺩﻭل ‪.‬‬

‫‪110‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ﺍﻟﺜﺎﻤﻨﺔ ﻋﺸﺭ‬
‫ﺍﻟﺒﺤﺙ ﻓﻲ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪:‬‬
‫ﺘﻌﺘﺒﺭ ﻋﻤﻠﻴﺔ ﺍﻟﺒﺤﺙ ﻋﻥ ﺴﺠل ﻤﻌﻴﻥ ﺃﻭ ﻗﻴﻤﺔ ﻤﻌﻴﻨﺔ ﻟﺤﻘل ﻤﺎ ﻓﻲ ﺴﺠل ﻤﻥ ﺃﻫﻡ ﺘﻁﺒﻴﻘﺎﺕ ﻗﻭﺍﻋـﺩ ﺍﻟﺒﻴﺎﻨـﺎﺕ ‪ ،‬ﻭﻨﻅـﺭﹰﺍ‬
‫ﻟﻀﺨﺎﻤﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ) ﺒﻨﻭﻙ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ( ﻓﺈﻨﻨﺎ ﻨﺤﺘﺎﺝ ﺇﻟﻰ ﺘﻘﻨﻴﺎﺕ ﺒﺤﺙ ﺴﺭﻴﻌﺔ ﺘﻭﺼﻠﻨﺎ ﺇﻟﻰ‬
‫ﺍﻟﻤﻌﻠﻭﻤﺔ ﺍﻟﻤﺤﺩﺩﺓ ﻭﺒﺩﻭﻥ ﻋﻨﺎﺀ ﺍﻟﺒﺤﺙ ﻀﻤﻥ ﺠﻤﻴﻊ ﺒﻴﺎﻨﺎﺕ ﺍﻟﺠﺩﻭل ‪ ،‬ﻭﺴﻨﺴﺘﻌﺭﺽ ﺍﻵﻥ ﺃﻫﻡ ﻁﺭﻕ ﺍﻟﺒﺤﺙ ﺍﻟﺘﻲ ﺯﻭﺩﺘﻨﺎ‬
‫ﺒﻬﺎ ﻟﻐﺔ ﺩﻟﻔﻲ ‪.‬‬
‫ﺍﻟﻤﻨﻬﺞ ‪: Locate‬‬
‫ﻴﻘﻭﻡ ﻫﺫﺍ ﺍﻟﻤﻨﻬﺞ ﺒﻭﻀﻊ ﻤﺅﺸﺭ ﺍﻟﺴﺠل ﺍﻟﺤﺎﻟﻲ ﻋﻨﺩ ﺃﻭل ﺴﺠل ﻴﻁﺎﺒﻕ ﺸﺭﻭﻁ ﺍﻟﺒﺤﺙ‪ ،‬ﺒﺎﺴﺘﺨﺩﺍﻡ ﻫﺫﻩ ﺍﻟﻁﺭﻴﻘـﺔ ﻴﻤﻜﻨﻨـﺎ‬
‫ﺍﻟﺒﺤﺙ ﻋﻥ ﻗﻴﻤﺔ ﻟﺤﻘل ﻤﺎ ﺤﻴﺙ ﻴﺄﺨﺫ ﻫﺫﻩ ﺍﻟﻤﻨﻬﺞ ﺍﻟﺸﻜل ‪:‬‬
‫; ) ‪Locate ( 'FieldName',SearchValue,Option‬‬
‫ﺤﻴﺙ ‪ : FieldName‬ﺍﺴﻡ ﺍﻟﺤﻘل ﺍﻟﺫﻱ ﺴﻴﺘﻡ ﺍﻟﺒﺤﺙ ﻓﻴﻪ ‪.‬‬
‫‪ : SearchValue‬ﺍﻟﻘﻴﻤﺔ ﺍﻟﺘﻲ ﺴﻴﺘﻡ ﺍﻟﺒﺤﺙ ﻋﻨﻬﺎ‪.‬‬
‫‪: Option‬ﺘﺤﺩﺩ ﺨﻴﺎﺭﺍﺕ ﺍﻟﺒﺤﺙ ﻭﺘﺄﺨﺫ ﺍﻟﻘﻴﻡ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻋﺩﻡ ﺍﻟﺘﻤﻴﺯ ﺒﻴﻥ ﺍﻷﺤﺭﻑ ﺍﻟﻜﺒﻴﺭﺓ ﻭﺍﻟﺼﻐﻴﺭﺓ ‪Option = [loCaseInsensitive ] ,‬‬
‫ﺍﻟﺒﺤﺙ ﻓﻲ ﺠﺯﺀ ﻤﻥ ﺍﻟﻜﻠﻤﺔ ﺃﻱ ﺃﻥ ﺍﻟﺒﺤﺙ ﻋﻥ ﻗﻴﻤﺔ " ﻤﺤﻡ " ﻴﻤﻜﻥ ﺃﻥ ﻴﻌﻴﺩ " ﻤﺤﻤﺩ " ; ] ‪Option = [ loPartiaKey‬‬
‫ﺃﻭ " ﻤﺤﻤﻭﺩ"‬
‫ﺩﻤﺞ ﺍﻟﺨﻴﺎﺭﻴﻥ ﺍﻟﺴﺎﺒﻘﻴﻥ ;] ‪Option = [ loCaseInsensitive , loPartiaKey‬‬
‫ﻻ ﻨﺭﻴﺩ ﺍﺴﺘﺨﺩﺍﻡ ﺃﻱ ﻤﻥ ﺍﻟﺨﻴﺎﺭﻴﻥ ﺍﻟﺴﺎﺒﻘﻴﻥ ;] [ = ‪Option‬‬
‫ﻴﻌﻴﺩ ﻫﺫﺍ ﺍﻟﻤﻨﻬﺞ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻓﻲ ﺤﺎل ﺍﺴﺘﻁﺎﻉ ﺇﻴﺠﺎﺩ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﻁﻠﻭﺒﺔ ﻓﻲ ﺠﺩﻭل ﺍﻟﺒﺤﺙ ﻭﺍﻟﻘﻴﻤﺔ ‪ False‬ﻓـﻲ ﺍﻟﺤﺎﻟـﺔ‬
‫ﺍﻟﻤﻌﺎﻜﺴﺔ ‪.‬‬
‫ﻤﺜﺎل ‪:‬‬
‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﻋﻨﺼﺭ ‪ Table‬ﻭ ‪ DataSorce‬ﻭ ‪ DbGrid‬ﻭ ‪ Button‬ﻭ ‪Edit‬‬
‫ﺃﺭﺒﻁ ﺍﻟﺠﺩﻭل ﻤﻊ ﺠﺩﻭل ‪ Passengers‬ﻓﻲ ﺍﻟﻘﺎﻋﺩﺓ ‪ Travel‬ﻭﺃﻅﻬﺭ ﻤﺤﺘﻭﻴﺎﺕ ﺍﻟﺠﺩﻭل ﻀﻤﻥ ‪: DBGrid‬‬
‫ﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪If Table1.Locate('Pname',Edit1.Text , [locaseinsensitive,lopartialkey]) Then‬‬
‫‪Showmessage(' The record is found ') Else‬‬
‫;) ' ‪Showmessage ( ' There is no match , Try Another Value‬‬
‫ﻴﻘﻭﻡ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﺴﺎﺒﻕ ﺒﺎﻟﺒﺤﺙ ﻋﻥ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﺩﺨﻠﺔ ﻓﻲ ﺍﻟﻌﻨﺼﺭ ‪ Edit1‬ﻀﻤﻥ ﺍﻟﺤﻘل ‪ PName‬ﻓﻲ ﺠﺩﻭل ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ‪.‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﺒﺤﺙ ﻋﻥ ﻗﻴﻤﺔ ﺤﻘل ﻤﺎ ﻓﻲ ﺍﻟﺠﺩﻭل ﻭﻻﺤﻅ ﺍﻨﺘﻘﺎل ﻤﺅﺸﺭ ﺍﻟﺤﻘل ﺍﻟﺤﺎﻟﻲ ﺇﻟﻴﻬﺎ ﻋﻨﺩ ﻭﺠﻭﺩﻫﺎ ‪ ،‬ﺜﻡ ﺍﺒﺤـﺙ‬
‫ﻋﻥ ﺠﺯﺀ ﻤﻥ ﺍﺴﻡ ﺃﺤﺩ ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ) ﺍﺒﺤﺙ ﻋﻥ ﺍﻟﺤﺭﻑ " ﻡ " ﻓﻘﻁ ﻭﻻﺤﻅ ﺘﻭﻀﻊ ﻤﺅﺸﺭ ﺍﻟﺴﺠل ﺍﻟﺤﺎﻟﻲ ﻋﻨﺩ ﺍﺴﻡ ﺃﻭل‬
‫ﻤﺴﺎﻓﺭ ﻴﺒﺩﺃ ﺒﺤﺭﻑ " ﻡ " ( ﺜﻡ ﺍﺤﺫﻑ ﺍﻟﺨﻴﺎﺭ ‪ loPartialKey‬ﻤﻥ ﺘﻌﻠﻴﻤﺔ ﺍﻟﺒﺤﺙ ﻭﻻﺤﻅ ﻋﺩﻡ ﻗﺩﺭﺓ ﺍﻟﻤﻨﻬﺞ ﻤﻥ ﺇﻴﺠـﺎﺩ‬
‫ﺍﻟﺤﻘل ﺇﻻ ﻓﻲ ﺤﺎل ﻜﺎﻨﺕ ﺍﻟﻘﻴﻤﺔ ﻤﻁﺎﺒﻘﺔ ‪.‬‬

‫‪111‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻼ ‪ Ahmed‬ﻭ ‪ ( ahmed‬ﻭﺍﺒﺤﺙ ﻋﻥ ﺍﻟﻘﻴﻤﺘﻴﻥ ﺜﻡ ﺍﺤـﺫﻑ ﺍﻟﺨﺎﺼـﺔ‬
‫ﺜﻡ ﺃﻀﻑ ﺃﺴﻤﺎﺀ ﻤﺴﺎﻓﺭﻴﻥ ﺒﺎﻟﻠﻐﺔ ﺍﻹﻨﻜﻠﻴﺯﻴﺔ ) ﻤﺜ ﹰ‬
‫‪ loCaseInsensitive‬ﻭﺃﻋﺩ ﺍﻟﺒﺤﺙ ‪....‬‬
‫ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﻨﻬﺞ ‪ Locate‬ﻟﻠﺒﺤﺙ ﻋﻥ ﺃﻜﺜﺭ ﻤﻥ ﺤﻘل ﺒﻨﻔﺱ ﺍﻟﻭﻗﺕ ‪:‬‬
‫ﻼ ( ﻨﺴﺘﺨﺩﻡ ﻋﻨـﺩﻫﺎ‬
‫ﺒﻔﺭﺽ ﺃﻨﻨﺎ ﻨﺭﻴﺩ ﺍﻟﺒﺤﺙ ﻋﻥ ﺍﺴﻡ ﺍﻟﻤﺴﺎﻓﺭ ﻭﺍﻟﺠﻨﺴﻴﺔ ﺒﻨﻔﺱ ﺍﻟﻭﻗﺕ ) ﺍﻟﻤﺴﺎﻓﺭ ﻤﺤﻤﺩ ﻤﻥ ﺴﻭﺭﻴﺔ ﻤﺜ ﹰ‬
‫ﺍﻟﻤﻨﻬﺞ ‪ Locate‬ﺒﺎﻟﺸﻜل ‪:‬‬
‫‪Locate ( 'FieldName1; FieldName2; FieldName3',VarArrayOf ( [SearchValue1,‬‬
‫; ) ‪SearchValue2, SearchValue3]),Option‬‬

‫ﻤﺜﺎل ‪ :‬ﺃﻀﻑ ﻋﻨﺼﺭ ‪ Edit2‬ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺴﺎﺒﻕ ﻭﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫[ ‪if table1.Locate('pname;Nationalty',vararrayof([ edit1.Text,Edit2.text]) ,‬‬

‫‪locaseinsensitive , lopartialkey ] ) then‬‬
‫‪Showmessage('the record is found') else‬‬
‫;) '‪Showmessage ( 'there is no match , Try Anther Value‬‬
‫ﺍﻟﺘﺎﺒﻊ ‪ VarArrayOf‬ﻴﻨﺸﺊ ﻤﺼﻔﻭﻓﺔ ﻋﻨﺎﺼﺭﻫﺎ ﻤﻥ ﺍﻟﻨﻭﻉ ‪. Variant‬‬
‫ﻤﻼﺤﻅﺔ ‪:‬‬
‫ﺇﺫﺍ ﻜﺎﻥ ﺍﻟﺤﻘل ﻤﻥ ﻨﻭﻉ ﻋﺩﺩ ﺼﺤﻴﺢ ‪ Short‬ﺃﻭ ‪ Long Integer‬ﻴﺠﺏ ﺃﻥ ﺘﻜﻭﻥ ‪ SearchValue‬ﻤﻥ ﺍﻟﻨﻭﻉ ﻋـﺩﺩ‬
‫ﻻ ﻤﻥ ﺍﺴﻤﻪ ﻨﺴﺘﺒﺩل ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺴﺎﺒﻘﺔ ﺒﻤﺎ ﻴﻠﻲ ‪:‬‬
‫ﺼﺤﻴﺢ ﺃﻴﻀﹰﺎ ﻭﻟﺫﻟﻙ ﺇﺫﺍ ﺃﺭﺩﻨﺎ ﺃﻥ ﻨﺒﺤﺙ ﻋﻥ ﺭﻗﻡ ﺍﻟﻤﺴﺎﻓﺭ ﺒﺩ ﹰ‬
‫)]‪if table1.Locate('PNo;Nationalty',vararrayof([ strtoint(edit1.Text),Edit2.text‬‬
‫‪,[locaseinsensitive,lopartialkey]) then‬‬
‫‪Showmessage('the record is found') else‬‬
‫;) '‪Showmessage ( 'there is no match , Try Anther Value‬‬
‫‪ 2‬ـ ﺍﻟﻤﻨﻬﺞ ‪: Lookup‬‬
‫ﻴﻌﻴﺩ ﻫﺫﺍ ﺍﻟﻤﻨﻬﺞ ﻤﺼﻔﻭﻓﺔ ﻤﻥ ﺍﻟﻘﻴﻡ ﻟﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺤﻘﻭل ﺍﻟﺠﺩﻭل ﺩﻭﻥ ﺃﻥ ﺘﻐﻴﺭ ﻤﻭﻀﻊ ﺍﻟﺴﺠل ﺍﻟﺤﺎﻟﻲ ﻭﺍﻟﻤﺜﺎل ﺍﻟﺘـﺎﻟﻲ‬
‫ﻴﻭﻀﺢ ﻫﺫﺍ ﺍﻟﻤﻨﻬﺞ ‪:‬‬
‫ﻤﺜﺎل ‪ :‬ﺴﻨﺒﺤﺙ ﻋﻥ ﺭﻗﻡ ﺍﻟﻤﺴﺎﻓﺭ ﻭﺴﻨﻁﻠﺏ ﻤﻥ ﺍﻟﺘﺎﺒﻊ ﺍﻥ ﻴﻌﻴﺩ ﺍﺴﻡ ﺍﻟﻤﺴﺎﻓﺭ ﻭﺠﻨﺴﻴﺘﻪ ‪ :‬ﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠـﻰ‬
‫ﺯﺭ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ‬
‫;‪var LookupResult : Variant‬‬
‫‪begin‬‬
‫;)'‪lookupResult := Table1.Lookup('Pno',strtoint(edit1.Text ),'Pname;Nationalty‬‬
‫‪if Not VarIsnull( lookupResult) then‬‬
‫;) ) ]‪Showmessage(vartostr(lookupresult[0]) + ' ' + vartostr(lookupresult[1‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻷﻭﻟﻰ ﻟﻠﺒﺤﺙ ﻋﻥ ﺭﻗﻡ ﺍﻟﻤﺴﺎﻓﺭ ﺍﻟﻤﻜﺘﻭﺏ ﻓﻲ ﺍﻟﻌﻨﺼﺭ ‪ Edit1‬ﻭﻭﻀﻊ ﺍﻟﻨﺘﻴﺠﺔ ﻓﻲ ﻤﺘﺤﻭل ﻤﻥ ﺍﻟﻨﻭﻉ ‪Variant‬‬
‫ﻴﻌﻴﺩ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ‪ Lookup‬ﺍﻟﻘﻴﻤﺔ ‪ Null‬ﻓﻲ ﺍﻟﻤﺘﺤﻭل ﺇﺫﺍ ﻟﻡ ﻴﺠﺩ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﻁﻠﻭﺏ ﺍﻟﺒﺤﺙ ﻋﻨﻬـﺎ ﻭﺍﻟﺘـﺎﺒﻊ ‪VarIsNull‬‬
‫ﻴﺴﺘﺨﺩﻡ ﻟﻤﻌﺭﻓﺔ ﺇﺫﺍ ﻜﺎﻥ ﺍﻟﻤﺘﺤﻭل ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Variant‬ﻴﺤﻭﻱ ﻗﻴﻤﺔ ﺃﻡ ﻻ ‪.‬‬

‫‪112‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺘﺎﺒﻊ ‪ VarToStr‬ﻴﺤﻭل ﻗﻴﻤﺔ ﺍﻟﻤﺘﺤﻭل ‪ variant‬ﺇﻟﻰ ﻨﺹ ‪.‬‬
‫ﻤﻼﺤﻅﺎﺕ ‪:‬‬
‫‪ 1‬ـ ﻴﻤﻜﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺘﺎﺒﻊ ‪ Lookup‬ﻟﻠﺒﺤﺙ ﻓﻲ ﺃﻜﺜﺭ ﻤﻥ ﺤﻘل ﻓﻲ ﻨﻔﺱ ﺍﻟﻭﻗﺕ ﻤﺜﺎل ﺍﺴﺘﺒﺩل ﺍﻟﺘﻌﻠﻴﻤـﺔ ﺍﻷﻭﻟـﻰ ﻓـﻲ‬
‫ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﺒﺎﻟﺘﻌﻠﻴﻤﺔ ‪:‬‬
‫‪lookupResult := Table1.Lookup('Pno;Pname',VarArrayof‬‬
‫;)'‪([strtoint(edit1.Text),Edit2.text]),'PName;Nationalty‬‬
‫‪ 2‬ـ ﻤﻥ ﺃﻫﻡ ﻤﺯﺍﻴﺎ ﺍﻟﻤﻨﻬﺠﻴﻥ ‪ Locate‬ﻭ ‪ lookup‬ﺃﻨﻬﻤﺎ ﻴﺴﺘﻁﻴﻌﺎﻥ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺤﻘﻭل ﻤﻔﻬﺭﺴﺔ ﻭﻏﻴﺭ ﻤﻔﻬﺭﺴﺔ ‪،‬‬
‫ﻭﻴﺴﺘﺨﺩﻤﺎﻥ ﺃﻴﻀﹰﺎ ﺨﻭﺍﺭﺯﻤﻴﺎﺕ ﻤﺘﻘﺩﻤﺔ ﻟﻠﺒﺤﺙ ﺤﻴﺙ ﻴﺴﺘﻔﻴﺩﺍﻥ ﻤﻥ ﺍﻟﺤﻘل ﺇﺫﺍ ﻜﺎﻥ ﻤﻔﻬﺭﺴﹰﺎ ﻭ ﻴﻁﺒﻘﺎﻥ ﻋﻤﻠﻴﺎﺕ ﺍﻟﻔﺭﺯ )‬
‫ﺍﻟﻔﻠﺘﺭﺓ ( ﻓﻲ ﺤﺎل ﻜﺎﻥ ﻏﻴﺭ ﻤﻔﻬﺭﺱ ‪.‬‬
‫ﺍﻟﻤﻨﻬﺞ ‪: FindKey‬‬
‫ﻫﺫﺍ ﺍﻟﻤﻨﻬﺞ ﺨﺎﺹ ﺒﺎﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺤﻘﻭل ﺍﻟﻤﻔﻬﺭﺴﺔ ﺤﻴﺙ ﺘﻜﻭﻥ ﻋﻤﻠﻴﺎﺕ ﺍﻟﺒﺤﺙ ﺃﺴﻬل ﺤﻴﺙ ﻴﺄﺨﺫ ﺍﻟﻤﻨﻬﺞ ‪Findkey‬‬
‫ﻗﻴﻤﺔ ﺍﻟﺤﻘل ﺍﻟﺘﻲ ﺴﻴﺒﺤﺙ ﻋﻨﻬﺎ ﻭﻴﻌﻴﺩ ﻗﻴﻤﺔ ﺒﻭﻟﻴﺎﻨﻴﺔ ﺘﺩل ﻋﻠﻰ ﻋﺜﻭﺭ ﻫﺫﺍ ﺍﻟﻤﻨﻬﺞ ﻋﻠﻰ ﺍﻟﺴﺠل ﺍﻟﻤﻁﻠﻭﺏ ﻭﻴﻘﻭﻡ ﺒﻨﻘل‬
‫ﻤﺅﺸﺭ ﺍﻟﺴﺠل ﺍﻟﺤﺎﻟﻲ ﺇﻟﻰ ﺍﻟﺴﺠل ﺍﻟﻤﻁﺎﺒﻕ ﻟﺸﺭﻭﻁ ﺍﻟﺒﺤﺙ‬
‫ﻤﺜﺎل ‪ :‬ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﻋﻠﻰ ﺯﺭ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪If not Table1.FindKey( [ Strtoint ( edit1.text)]) Then‬‬
‫;)'‪Showmessage ( 'the Record is not Found‬‬

‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺎﻟﺒﺤﺙ ﻓﻲ ﺍﻟﻔﻬﺭﺱ ﺍﻻﻓﺘﺭﺍﻀﻲ ‪ ) PNo‬ﻷﻨﻪ ﺍﻟﻤﻔﺘﺎﺡ ﺍﻟﺭﺌﻴﺴﻲ ( ﻋﻥ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﻜﺘﻭﺒﺔ ﻓﻲ ﺍﻟﻌﻨـﺼﺭ‬
‫‪ Edit‬ﻭﻓﻲ ﺤﺎل ﺘﻡ ﺇﻴﺠﺎﺩﻫﺎ ﻴﻨﺘﻘل ﻤﺅﺸﺭ ﺍﻟﺴﺠل ﺍﻟﺤﺎﻟﻲ ﻟﻠﺴﺠل ﺍﻟﻤﻁﺎﺒﻕ ﻟﻨﺘﻴﺠﺔ ﺍﻟﺒﺤﺙ ﻭﻴﻌﻴﺩ ﺍﻟﻤﻨﻬﺞ ﺍﻟﻘﻴﻤﺔ ‪ ،True‬ﺃﻤﺎ‬
‫ﻓﻲ ﺤﺎل ﻟﻡ ﺘﻭﺠﺩ ﺍﻟﻨﺘﻴﺠﺔ ﻓﻴﻌﻴﺩ ﺍﻟﺘﺎﺒﻊ ﺍﻟﻘﻴﻤﺔ ‪False‬‬
‫ـ ﻟﻠﺒﺤﺙ ﻓﻲ ﺍﻟﻔﻬﺎﺭﺱ ﺍﻟﺜﺎﻨﻭﻴﺔ ﻴﺠﺏ ﺘﺤﺩﻴﺩ ﺍﻟﻔﻬﺭﺱ ﺍﻟﺜﺎﻨﻭﻱ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﺨﺎﺼـﺔ ‪ IndexName‬ﻟﻠﻌﻨـﺼﺭ ‪Table‬‬
‫ﻭﻴﻤﻜﻥ ﺘﺤﺩﻴﺩﻫﺎ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ﺃﻭ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ‪.‬‬
‫ﻤﺜﺎل ‪ :‬ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﺃﻋﻁ ﺍﻟﻌﻨﺼﺭ ‪ Table1‬ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ IndexName‬ﺍﻟﻘﻴﻤﺔ ‪ ) PNameIndex‬ﺘـﺫﻜﺭ ﺃﻨﻨـﺎ‬
‫ﻋﺭﻓﻨﺎ ﻫﺫﺍ ﺍﻟﻔﻬﺭﺱ ﻓﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪ ( Database Desktop‬ﻭﻻﺤﻅ ﺘﻐﻴﺭ ﺘﺭﺘﻴﺏ ﺍﻟﺴﺠﻼﺕ ﻓـﻲ ﺍﻟﻌﻨـﺼﺭ ‪DbGrid‬‬
‫ﻤﺒﺎﺸﺭﺓ ﺤﻴﺙ ﺴﻴﺼﺒﺢ ﺘﺭﺘﻴﺏ ﺍﻟﺴﺠﻼﺕ ﺍﻋﺘﻤﺎﺩﹰﺍ ﻋﻠﻰ ﺍﻟﺘﺭﺘﻴﺏ ﺍﻷﺒﺠﺩﻱ ﻓﻲ ﺍﻟﺤﻘل ‪. PName‬‬
‫ﻋﺩل ﺍﻟﺘﻌﻠﻴﻤﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺒﺎﻟﺸﻜل ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫‪If not Table1.FindKey([edit1.text]) then‬‬
‫;)'‪Showmessage ( 'the Record is not Found‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﺒﺤﺙ ﻋﻥ ﺍﺴﻡ ﻤﺴﺎﻓﺭ ﻤﺎ ‪.....‬‬
‫ـ ﻭﺠﺩﻨﺎ ﺃﻴﻀﹰﺎ ﺃﻨﻪ ﻴﻤﻜﻥ ﺃﻥ ﺘﻜﻭﻥ ﺍﻟﻤﻔﺎﺘﻴﺢ ﺍﻟﺭﺌﻴﺴﻴﺔ ﻋﺒﺎﺭﺓ ﻋﻥ ﺤﻘﻠﻴﻥ ﺃﻭ ﺃﻜﺜﺭ ـ ﻜﺫﻟﻙ ﺍﻷﻤـﺭ ﺒﺎﻟﻨـﺴﺒﺔ ﻟﻠﻔﻬـﺎﺭﺱ‬
‫ﺍﻟﺜﺎﻨﻭﻴﺔ ﻭﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ ﻨﺴﺘﺨﺩﻡ ﺍﻟﻤﻨﻬﺞ ‪ FindKey‬ﺒﺎﻟﺸﻜل ‪:‬‬
‫; )]‪TableName.FindKey ( [ SearchValue1,SearchValue2 ,…,SearchValue3‬‬
‫ﻤﺜﺎل ‪ :‬ﻴﻤﻜﻥ ﺍﻟﺒﺤﺙ ﻓﻲ ﺠﺩﻭل " ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻭﺍﻟﺭﺤﻼﺕ" ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ Table1.FindKey( [2,3]) :‬ﺤﻴﺙ ﺴﻴﺘﻡ‬
‫ﺍﻟﺒﺤﺙ ﻋﻥ ﺍﻟﻤﺴﺎﻓﺭ ﺭﻗﻡ ‪ 2‬ﻓﻲ ﺍﻟﺭﺤﻠﺔ ‪. 4‬‬

‫‪113‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ 4‬ـ ﺍﻟﻤﻨﻬﺞ ‪: FindNearest‬‬
‫ﻴﺸﺒﻪ ﺍﻟﻤﻨﻬﺞ ﺍﻟﺴﺎﺒﻕ ﺇﻻ ﺃﻨﻪ ﻴﻨﺘﻘل ﺇﻟﻰ ﺴﺠل ﻤﻁﺎﺒﻕ ﺃﻭ ﺇﻟﻰ ﺃﻗﺭﺏ ﺴﺠل ﻤﻁﺎﺒﻕ ﺃﻭ ﺇﻟﻰ ﺃﻗﺭﺏ ﺴـﺠل ﻤﻁـﺎﺒﻕ ﻟﻠﻘﻴﻤـﺔ‬
‫ﺍﻟﻤﺭﺍﺩ ﺍﻟﺒﺤﺙ ﻋﻨﻬﺎ ‪ ،‬ﻜﻤﺎ ﺃﻨﻪ ﻻ ﻴﻌﻴﺩ ﻗﻴﻤﺔ ) ﻻ ﻴﻌﻴﺩ ‪ True‬ﺃﻭ ‪( False‬‬
‫ﻤﺜﺎل ‪:‬‬
‫ﻋﺩل ﺍﻟﺘﻌﻠﻴﻤﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺴﺎﺒﻕ ﻟﺘﺼﺒﺢ ﺒﺎﻟﺸﻜل ‪:‬‬
‫;)]‪Table1.FindNearest ([edit1.text‬‬
‫ﻼ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺴﺘﻘﻭﻡ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺒﻭﻀﻊ ﻤﺅﺸﺭ ﺍﻟﺴﺠل‬
‫ﺍﺩﺨل ﻓﻲ ﺍﻟﻌﻨﺼﺭ ‪ Edit1‬ﺠﺯﺀ ﻤﻥ ﺍﺴﻡ ﻤﺴﺎﻓﺭ " ﻤﺢ" ﻤﺜ ﹰ‬
‫ﺍﻟﺤﺎﻟﻲ ﻋﻨﺩ ﺃﻭل ﻤﺴﺎﻓﺭ ﺃﺴﻤﻪ " ﻤﺢ " ﺃﻭ ﺃﺴﻤﻪ ﻗﺭﻴﺏ ﺇﻟﻰ "ﻤﺢ " ﻤﺜل "ﻤﺤﻤﺩ" ﺃﻭ "ﻤﺤﻤﻭﺩ"‪.‬‬
‫ﺍﻟﺘﺼﻔﻴﺔ ) ﺍﻟﻔﻠﺘﺭﺓ ( ‪: Filter‬‬
‫ﻼ ﻨﺭﻴﺩ ﻤﻥ ﺍﻟﺠﺩﻭل ﺃﻥ ﻴﻌﺭﺽ ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻤـﻥ‬
‫ﺘﺴﺘﺨﺩﻡ ﺍﻟﺘﺼﻔﻴﺔ ﻹﻅﻬﺎﺭ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﺤﻘﻭل ﺘﺤﻘﻕ ﻤﻌﺎﻴﻴﺭ ﻤﺤﺩﺩﺓ ﻤﺜ ﹰ‬
‫ﺍﻟﺠﻨﺴﻴﺔ ﺍﻟﺴﻭﺭﻴﺔ ﻓﻘﻁ ﻓﻲ ﺠﺩﻭل ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ‪ ،‬ﺃﻭ ﺃﻥ ﻨﻅﻬﺭ ﺠﻤﻴﻊ ﺍﻟﺭﺤﻼﺕ ﺍﻟﺘﻲ ﺨﺭﺠﺕ ﻤﻥ ﻤﻁﺎﺭ ﺤﻠﺏ ﻓﻲ ﺠـﺩﻭل‬
‫ﺍﻟﺭﺤﻼﺕ ‪.‬‬
‫ﺘﺴﺘﺨﺩﻡ ﻟﻬﺫﻩ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﺨﺎﺼﺔ ‪ Filter‬ﻟﻠﻌﻨﺼﺭ ‪ Table‬ﻭﻴﺠﺏ ﺃﻥ ﺘﺄﺨﺫ ﺍﻟﺨﺎﺼﺔ ‪ Filter‬ﺍﻟﻘﻴﻤﺔ ‪. True‬‬
‫ﺍﻟﺘﺼﻔﻴﺔ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ‪:‬‬
‫ﻤﺜﺎل ‪ :‬ﺴﻨﻅﻬﺭ ﻓﻲ ﺠﺩﻭل ﺍﻟﺭﺤﻼﺕ ﺍﻟﺨﺎﺭﺠﺔ ﻤﻥ ﻤﺩﻴﻨﺔ ﺤﻠﺏ ‪...‬‬
‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺍﻀﻑ ﺇﻟﻴـﺔ ﺍﻟﻌﻨﺎﺼـﺭ ﺍﻟﺘﺎﻟﻴـﺔ ‪ Table‬ﻭ ‪ DataSource‬ﻭ ‪ DBGrid‬ﻭ ‪ ، Button‬ﺍﺭﺒـﻁ‬
‫ﺍﻟﻌﻨﺎﺼﺭ ﻤﻊ ﺒﻌﻀﻬﺎ ﺒﺤﻴﺙ ﻴﻅﻬﺭ ﺠﺩﻭل ﺍﻟﺭﺤﻼﺕ ‪ Trips‬ﻓﻲ ﺍﻟﻌﻨﺼﺭ ‪ DBGrid1‬ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ‪.‬‬
‫ﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ Filtered‬ﻟﻠﻌﻨﺼﺭ ‪ Table1‬ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻭﺍﻜﺘﺏ ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ Filter‬ﺍﻟﻘﻴﻤﺔ ‪:‬‬
‫'ﺤﻠﺏ' = ‪GoFrom‬‬
‫ﺴﻴﺘﻡ ﺘﻁﺒﻴﻕ ﺍﻟﺘﺼﻔﻴﺔ ﻤﺒﺎﺸﺭﺓ ﻭﺴﻴﻅﻬﺭ ﺍﻟﺠﺩﻭل ﺠﻤﻴﻊ ﺍﻟﺭﺤﻼﺕ ﺍﻟﻤﻐﺎﺩﺭﺓ ﻤﻥ ﻤﻁـﺎﺭ ﺤﻠـﺏ ‪ ،‬ﻨـﺴﺘﻁﻴﻊ ﺍﻵﻥ ﺇﺯﺍﻟـﺔ‬
‫ﺍﻟﺘﺼﻔﻴﺔ ﺒﺈﻋﻁﺎﺀ ﺍﻟﺨﺎﺼﺔ ‪ Filtered‬ﺍﻟﻘﻴﻤﺔ ‪. False‬‬
‫ﺍﻵﻥ ﻋﻠﻰ ﻓﺭﺽ ﺃﻨﻨﺎ ﻨﺭﻴﺩ ﺃﻥ ﻨﻌﺭﻑ ﺠﻤﻴﻊ ﺍﻟﺭﺤﻼﺕ ﺍﻟﻤﻐﺎﺩﺭﺓ ﻤﻥ ﻤﺩﻴﻨﺔ ﺤﻠﺏ ﺇﻟﻰ ﺍﻟﻘﺎﻫﺭﺓ ‪ ،‬ﻟﺘﺤﻘﻴﻕ ﺫﻟﻙ ﻨﻜﺘﺏ ﻓـﻲ‬
‫ﺍﻟﺨﺎﺼﺔ ‪ Filter‬ﺍﻟﻘﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ‬
‫'ﺍﻟﻘﺎﻫﺭﺓ' = ‪' and Arriveto‬ﺤﻠﺏ' = ‪Gofrom‬‬
‫) ﺍﻟﺨﺎﺼﺔ ‪ Filter‬ﻴﺠﺏ ﺃﻥ ﺘﺄﺨﺫ ﺍﻟﻘﻴﻤﺔ ‪( True‬‬
‫ﻜﻤﺎ ﻴﻤﻜﻥ ﺃﻥ ﻨﺒﺤﺙ ﻋﻥ ﺠﻤﻴﻊ ﺍﻟﺭﺤل ﺍﻟﻤﻐﺎﺩﺭﺓ ﻤﻥ ﺤﻠﺏ ﺃﻭ ﺩﻤﺸﻕ ﺇﻟﻰ ﺍﻟﻘﺎﻫﺭﺓ ‪: ...‬‬
‫'ﺍﻟﻘﺎﻫﺭﺓ' = ‪') and Arriveto‬ﺩﻤﺸﻕ' = ‪' Or GoFrom‬ﺤﻠﺏ' = ‪(Gofrom‬‬
‫ﻜﻤﺎ ﻴﻤﻜﻥ ﺃﻥ ﻨﻭﺠﺩ ﺠﻤﻴﻊ ﺍﻟﺭﺤل ﺍﻟﻤﻐﺎﺩﺭﺓ ﻤﻥ ﺒﻠﺩ ﻴﺒﺩﺃ ﺃﺴﻤﻪ ﺒﺤﺭﻑ " ﺡ "‬
‫'*ﺡ'= ‪Gofrom‬‬
‫ﻜﻤﺎ ﻴﻤﻜﻥ ﻨﻌﺭﻑ ﺍﻟﺭﺤل ﺍﻟﺘﻲ ﺒﻘﻲ ﻓﻴﻬﺎ ﺃﻜﺜﺭ ﻤﻥ ‪ 10‬ﺒﻁﺎﻗﺎﺕ ‪ :‬ﺍﻜﺘﺏ ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ Filter‬ﺍﻟﻘﻴﻤﺔ ‪:‬‬
‫‪CardCount > 10‬‬

‫‪114‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺘﺼﻔﻴﺔ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﺫ ‪:‬‬
‫ﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ Filtered‬ﺍﻟﻘﻴﻤﺔ ‪ True‬ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ﻭﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻟﻤﻌﺭﻓﺔ ﺍﻟﺭﺤل‬
‫ﺍﻟﺘﻲ ﺒﻘﻲ ﻓﻴﻬﺎ ﺃﻜﺜﺭ ﻤﻥ ‪ 10‬ﺒﻁﺎﻗﺎﺕ ‪:‬‬
‫' ‪Table1.Filter := ' CardCount > 10‬‬
‫ﻭﻟﻤﻌﺭﻓﺔ ﺍﻟﺭﺤل ﺍﻟﺘﻲ ﺒﻘﻲ ﻓﻴﻬﺎ ﺃﻜﺜﺭ ﻤﻥ ﻋﺩﺩ ﻤﺤﺩﺩ ﻤﻥ ﺍﻟﺒﻁﺎﻗﺎﺕ ﺃﻀﻑ ﻋﻨﺼﺭ ‪ Edit‬ﺍﻟﻨﻤﻭﺫﺝ ‪:‬‬
‫; ‪Table1.Filter := ' CardCount > '+ edit1.Text‬‬
‫ﺃﺩﺨل ﺭﻗﻤﹰﺎ ﻓﻲ ﺍﻟﻌﻨﺼﺭ ‪ Edit1‬ﺤﺘﻰ ﻻ ﻴﺤﺩﺙ ﺃﺨﻁﺎﺀ ‪...‬‬
‫ﻟﻤﻌﺭﻓﺔ ﺍﻟﺭﺤل ﺍﻟﻤﻐﺎﺩﺭﺓ ﻤﻥ ﻤﺩﻴﻨﺔ ﻤﺎ ﻨﺴﺘﺨﺩﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; )‪Table1.Filter := 'GoFrom = '+ Quotedstr(edit1.Text‬‬
‫ﻼ 'ﺤﻠـﺏ ' = ) ﺤﻠـﺏ‬ ‫ﻴﻌﻴﺩ ﺍﻟﺘﺎﺒﻊ ‪ Quotedstr‬ﺍﻟﻨﺹ ﺍﻟﻤﻌﻁﻰ ﻓﻲ ﻭﺴﻴﻁﻪ ﺇﻟﻴﻪ ﻤﻀﺎﻑ ﺇﻟﻴﻪ ﺇﺸﺎﺭﺘﻲ ﺤﺼﺭ ﻤـﺜ ﹰ‬
‫( ‪Quotedstr‬‬
‫ﻭﻫﻜﺫﺍ ﺃﻋﺩ ﺘﻨﻔﻴﺫ ﺍﻷﻤﺜﻠﻪ ﺍﻟﺴﺎﺒﻘﺔ ‪...‬‬
‫ﺨﻭﺍﺹ ﺍﻟﻌﻨﺼﺭ ‪: Table‬‬
‫ﻴﻤﻠﻙ ﺍﻟﻌﻨﺼﺭ ‪ Table‬ﻋﺩﺩ ﻤﻥ ﺍﻟﺨﻭﺍﺹ ﻟﻠﺘﺤﻜﻡ ﺒﻪ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ﻭﻫﻲ ‪:‬‬
‫‪ 1‬ـ ﺍﻟﻤﻨﻬﺞ ‪: Open‬ﺘﺴﺨﺩﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ Table1.open‬ﻟﻔﺘﺢ ﺍﻟﺠﺩﻭل ﻭﺘﻜﺎﻓﺊ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪Table1.Active := true‬‬
‫‪.‬‬
‫‪ 2‬ـ ﺍﻟﻤﻨﻬﺞ ‪ : Close‬ﺘﺴﺘﺨﺩﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ Table1.Close‬ﻹﻏﻼﻕ ﺍﻟﺠﺩﻭل ﻭﺘﻜﺎﻓﺊ ﺍﻟﺘﻌﻠﻴﻤﺔ =‪Table1.Active :‬‬
‫‪. False‬‬
‫‪ 3‬ـ ﺍﻟﻤﻨﻬﺞ ‪: First‬ﺍﺴﺘﺨﺩﻡ ‪ Table1.First‬ﻟﻭﻀﻊ ﻤﺅﺸﺭ ﺍﻟﺴﺠل ﺍﻟﺤﺎﻟﻲ ﻋﻨﺩ ﺃﻭل ﺴﺠل ﻓﻲ ﺍﻟﺠﺩﻭل ‪.‬‬
‫‪ 4‬ـ ﺍﻟﻤﻨﻬﺞ ‪ : Last‬ﺍﺴﺘﺨﺩﻡ ‪ Table1.Last‬ﻟﻭﻀﻊ ﻤﺅﺸﺭ ﺍﻟﺴﺠل ﺍﻟﺤﺎﻟﻲ ﻓﻲ ﺁﺨﺭ ﺍﻟﺠﺩﻭل ‪.‬‬
‫‪ 5‬ـ ﺍﻟﻤﻨﻬﺞ ‪ : Next‬ﺍﺴﺘﺨﺩﻡ ‪ Table1.Next‬ﻟﻼﻨﺘﻘﺎل ﺇﻟﻰ ﺍﻟﺴﺠل ﺍﻟﺘﺎﻟﻲ ﻓﻲ ﺍﻟﺠﺩﻭل ‪.‬‬
‫‪ 6‬ـ ﺍﻟﻤﻨﻬﺞ ‪ : Prior‬ﺍﺴﺘﺨﺩﻡ ‪ Table1.Prior‬ﻟﻼﻨﺘﻘﺎل ﺇﻟﻰ ﺍﻟﺴﺠل ﺍﻟﺴﺎﺒﻕ ﻓﻲ ﺍﻟﺠﺩﻭل ‪.‬‬
‫‪ 7‬ـ ﺍﻟﻤﻨﻬﺞ )‪ : MoveBy( x‬ﺍﺴﺘﺨﺩﻡ ) ‪ Table1.MoveBy( 5‬ﻟﻼﻨﺘﻘﺎل ﺨﻤﺱ ﺴﺠﻼﺕ ﺇﻟﻰ ﺍﻷﻤﺎﻡ ) ﻴﻤﻜـﻥ ﺃﻥ‬
‫ﺘﻜﻭﻥ ﻗﻴﻤﺔ ‪ X‬ﺴﺎﻟﺒﺔ (‪.‬‬
‫‪ 8‬ـ ﺍﻟﻤﻨﻬﺞ ‪ : Bof‬ﺘﻌﻴﺩ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﺇﺫﺍ ﻜﺎﻥ ﺍﻟﺴﺠل ﺍﻟﺤﺎﻟﻲ ﻓﻲ ﺒﺩﺍﻴﺔ ﺍﻟﺠﺩﻭل ‪.‬‬
‫‪ 9‬ـ ﺍﻟﻤﻨﻬﺞ ‪ : Eof‬ﺘﻌﻴﺩ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﺇﺫﺍ ﻜﺎﻥ ﺍﻟﺴﺠل ﺍﻟﺤﺎﻟﻲ ﻓﻲ ﻨﻬﺎﻴﺔ ﺍﻟﺠﺩﻭل ‪.‬‬
‫‪ 10‬ـ ﺍﻟﻤﻨﻬﺞ ‪ : RecordCount‬ﻴﻌﻴﺩ ﻫﺫﻩ ﺍﻟﻤﻨﻬﺞ ﻋﺩﺩ ﺴﺠﻼﺕ ﺍﻟﺠﺩﻭل ‪.‬‬
‫‪ 11‬ـ ﺍﻟﻤﻨﻬﺞ ‪ : RecNo‬ﻴﻌﻴﺩ ﻫﺫﺍ ﺍﻟﻤﻨﻬﺞ ﺭﻗﻡ ﺍﻟﺴﺠل ﺍﻟﺤﺎﻟﻲ ‪.‬‬
‫‪ 12‬ـ ﺍﻟﻤﻨﻬﺞ ‪ : Delete‬ﻴﻘﻭﻡ ﻫﺫﺍ ﺍﻟﻤﻨﻬﺞ ﺒﺤﺙ ﺍﻟﺴﺠل ﺍﻟﺤﺎﻟﻲ ﻭﻴﻀﻊ ﻤﺅﺸﺭ ﺍﻟﺴﺠل ﻋﻠﻰ ﺍﻟﺴﺠل ﺍﻟﺘﺎﻟﻲ ‪..‬‬
‫ﺍﻟﺤﻘﻭل ﺍﻟﺤﺴﺎﺒﻴﺔ ‪:‬‬

‫‪115‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬

‫ﺍﻟﻭﻅﻴﻔﺔ ‪:‬‬
‫ً‪ 1‬ـﺄﻨﺸﺊ ﺍﻟﺠﺩﺍﻭل ﺍﻟﺘﺎﻟﻴﺔ ﺒﺎﺴﺘﺨﺩﻡ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪:DataBase Desktop‬‬
‫‪ 1‬ـ ﺠﺩﻭل ﺍﻟﻤﺅﻟﻔﻴﻥ ‪: Writer‬‬
‫ﻋﻨﻭﺍﻥ ﺍﻟﻤﺅﻟﻑ ‪Wadress‬‬ ‫ﺭﻗﻡ ﺍﻟﻤﺅﻟﻑ ‪ * Wno‬ﺍﺴﻡ ﺍﻟﻤﺅﻟﻑ ‪WName‬‬
‫‪1‬‬
‫‪2‬‬
‫‪ 2‬ـ ﺠﺩﻭل ﺩﻭﺭ ﺍﻟﻨﺸﺭ ‪: Publisher‬‬
‫ﺍﻟﻌﻨﻭﺍﻥ ‪PubAdr‬‬ ‫ﺍﺴﻡ ﺍﻟﺩﺍﺭ ‪PubName‬‬ ‫ﺭﻗﻡ ﺍﻟﺩﺍﺭ ‪* PubNo‬‬

‫‪ 3‬ـ ﺠﺩﻭل ﺍﻟﻜﺘﺏ ‪:‬‬

‫ﺘــﺎﺭﻴﺦ ﺍﻹﺼــﺩﺍﺭ‬ ‫ﺭﻗﻡ ﺍﻟﺩﺍﺭ ‪PubNo‬‬ ‫ﺭﻗﻡ ﺍﻟﻤﺅﻟﻑ ‪WNo‬‬ ‫ﺭﻗـــﻡ ﺍﻟﻜﺘـــﺎﺏ ﺍﺴﻡ ﺍﻟﻜﺘﺎﺏ ‪Book‬‬
‫‪Edate‬‬ ‫‪BookNo‬‬

‫‪ ً 2‬ـ ﺍﺭﺒﻁ ﺒﻴﻥ ﺍﻟﺠﺩﺍﻭل ﺒﺎﻟﺸﻜل ﺍﻟﺫﻱ ﺘﺭﺍﻩ ﻤﻨﺴﺎﺒﹰﺎ ‪.‬‬

‫‪ ً 3‬ـ ﻋﺭﻑ ﻓﻬﺭﺱ ﺜﺎﻨﻭﻱ ﻋﻠﻰ ﺍﻟﺤﻘل ﺍﺴﻡ ﺍﻟﻤﺅﻟﻑ ﻭ ﺍﻟﺤﻘل ﺍﺴﻡ ﺍﻟﺩﺍﺭ ﻭﺍﻟﺤﻘل ﺍﺴﻡ ﺍﻟﻜﺘﺎﺏ ‪.‬‬
‫‪ ً 4‬ـ ﺍﻋﺭﺽ ﺠﺩﻭل ﺍﻟﻤﺅﻟﻔﻴﻥ ﻭﺠﺩﻭل ﺍﻟﻜﺘﺏ ﻋﻠﻰ ﻨﻤﻭﺫﺝ ﻭﺍﺤﺩ ﺒﺤﻴﺙ ﻴﻜﻭﻥ ﺍﻷﻭل ﺘﻔﺼﻴﻠﻲ ﻭﺍﻟﺜﺎﻨﻲ ﺜﺎﻨﻭﻱ ‪.‬‬
‫‪ ً 5‬ـ ﻀﻊ ﻋﺩﺩ ﻤﻥ ﺍﻷﺯﺭﺍﺭ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﻟﻠﺒﺤﺙ ﻋﻥ ﺍﺴﻡ ﺍﻟﻤﺅﻟﻑ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺃﺴﺎﻟﻴﺏ ﺍﻟﺒﺤﺙ ﺍﻟﻤﺨﺘﻠﻔﺔ‬
‫‪ ً 6‬ـ ﺃﻋﺭﺽ ﻓﻲ ﻨﻤﻭﺫﺝ ﺠﺩﻴﺩ ﺠﻤﻴﻊ ﺍﻟﻜﺘﺏ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻭﺍﻟﺘﻲ ﻤﻥ ﺇﺼﺩﺍﺭ ﺩﺍﺭ ﺸﻌﺎﻉ‪.‬‬

‫‪116‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ‪19‬‬
‫ﺍﻟﺤﻘﻭل ﺍﻟﺤﺴﺎﺒﻴﺔ ‪:‬‬
‫ﺘﺴﺘﺨﺩﻡ ﺍﻟﺤﻘﻭل ﺍﻟﺤﺴﺎﺒﻴﺔ ﻋﺎﺩﺓ ﻹﻋﻁﺎﺀ ﻨﺘﻴﺠﺔ ﺤﺴﺎﺒﻴﺔ ﺃﺠﺭﻴﺕ ﻋﻠﻰ ﻋﺩﺩ ﻤﻥ ﺤﻘﻭل ﺍﻟﺠﺩﻭل ﻭﻫﺫﻩ ﺍﻟﺤﻘﻭل ﻻ ﺘﺨﺯﻥ ﻓﻲ‬
‫ﻼ ﻟﺘﺨﺯﻴﻥ ﻫﺫﻩ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻷﻨﻬﺎ ﻤﻌﺘﻤﺩﺓ ﻋﻠﻰ ﺤﻘﻭل ﺃﺨـﺭﻯ‬
‫ﺍﻟﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻟﻜﻥ ﺘﻅﻬﺭ ﻟﻠﻤﺴﺘﺨﺩﻡ ﻓﻘﻁ ) ﻻ ﺤﺎﺠﺔ ﺃﺼ ﹰ‬
‫ﻓﻲ ﺍﻟﺠﺩﻭل ( ‪....‬‬
‫ﻤﺜﺎل ‪ :‬ﻋﻠﻰ ﻓﺭﺽ ﺃﻥ ﺠﻤﻴﻊ ﺍﻟﺭﺤﻼﺕ ﻗﺎﺩﺭﺓ ﻋﻠﻰ ﺤﻤل ‪ 350‬ﻤﺴﺎﻓﺭ ﻨﺭﻴﺩ ﺃﻥ ﻨﻨﺸﺊ ﺤﻘل ﺤـﺴﺎﺒﻲ ﻴﻌـﺭﺽ ﻋـﺩﺩ‬
‫‪= 350 -‬‬ ‫ﺍﻟﺒﻁﺎﻗﺎﺕ ﺍﻟﻤﺤﺠﻭﺯﺓ ﻋﻠﻰ ﺭﺤﻠﺔ ﻤﺎ ﺒﺎﻻﻋﺘﻤﺎﺩ ﻋﻠـﻰ ﺍﻟﻌﻼﻗـﺔ‬
‫‪ CardCount‬ﻋﺩﺩ ﺍﻟﺒﻁﺎﻗﺎﺕ ﺍﻟﻤﺤﺠﻭﺯﺓ‬

‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﺃﻀﻑ ﺇﻟﻴﻪ ﺍﻟﻌﻨﺎﺼﺭ ‪ Table‬ﻭ ‪ DataSource‬ﻭ ‪ : DBGrid‬ﺍﺭﺒﻁ ﺍﻟﻌﻨﺎﺼﺭ ﻤﻊ ﺒﻌﻀﻬﺎ ﻭﻤﻊ‬
‫ﺍﻟﺠﺩﻭل ‪ Trips‬ﺒﺤﻴﺙ ﻴﻅﻬﺭ ﺍﻟﺠﺩﻭل ﻓﻲ ‪ DBGrid‬ﺃﺜﻨﺎﺀ‬
‫ﺍﻟﺘﺼﻤﻴﻡ ‪...‬‬
‫ﺍﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ Active‬ﻟﻠﻌﻨﺼﺭ ‪ Table1‬ﺍﻟﻘﻴﻤﺔ ‪. False‬‬
‫ﺍﻀﻐﻁ ﻤﺭﺘﻴﻥ ﻋﻠﻰ ﺍﻟﻌﻨـﺼﺭ ‪ Table‬ﻟﻴﻅﻬـﺭ ﻤﺤـﺭﺭ‬
‫ﺍﻟﺤﻘﻭل‪ ،‬ﺜﻡ ﺍﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﻤﻴﻨـﻲ ﻭﺃﻀـﻑ ﺠﻤﻴـﻊ‬
‫ﺍﻟﺤﻘﻭل‪ ،‬ﺍﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﻤﻴﻨﻲ ﻤﺭﺓ ﺃﺨـﺭﻯ ﻭﺍﺨﺘـﺭ‬
‫‪ New field‬ﺴﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺍﻟﻨﺎﻓﺫﺓ ﺤﻘل ﺠﺩﻴﺩ‬
‫ﺍﻜﺘﺏ ‪ CapCard‬ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Name‬ﻭﻓﻲ ﺍﻟﻘـﺴﻡ ‪Type‬‬
‫ﺍﺨﺘﺭ ‪ Integer‬ﻭﺍﺨﺘﺭ ‪ Calculated‬ﻓﻲ ﺍﻟﻘﺴﻡ ‪Field type‬‬
‫ﺍﻀﻐﻁ ﻋﻠﻰ ‪. Ok‬‬
‫ﺃﻏﻠﻕ ﻤﺤﺭﺭ ﺍﻟﺤﻘﻭل ﻭﺍﺨﺘﺭ ﺍﻟﻌﻨﺼﺭ ‪ Table1‬ﻭﺍﻨﺘﻘل ﺇﻟﻰ ﺍﻟﺼﻔﺤﺔ ‪ Event‬ﻓﻲ ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ﻭﺍﻨﺘﻘل ﺇﻟﻰ ﺍﻟﺤـﺩﺙ‬
‫‪ OnClacFields‬ﻭﺍﻜﺘﺏ ﻓﻴﻪ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; ‪Table1CapCard.Value := 350 - table1Cardcount.value‬‬
‫ﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ Active‬ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻟﻠﻌﻨﺼﺭ ‪ Table1‬ﻭﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ‪ ،‬ﻭﺍﺴﺘﻌﺭﺽ ﺍﻟﺤﻘل ﺍﻟﺠﺩﻴﺩ ‪ ، CapCard‬ﻋﺩل‬
‫ﻓﻲ ﺃﺤﺩ ﺤﻘﻭل ‪ CardCount‬ﻭﻻﺤﻅ ﺍﻟﺘﻐﻴﺭ ﺍﻟﻤﺒﺎﺸﺭ ﻓﻲ ﺍﻟﺤﻘل ‪... CapCard‬‬
‫ﻤﺜﺎل ‪ : 2‬ﻨﺭﻴﺩ ﺃﻥ ﻨﻀﻴﻑ ﺤﻘل ﺠﺩﻴﺩ ﺇﻟﻰ ﺍﻟﺠﺩﻭل ﺍﻟﺴﺎﺒﻕ ﻴﻌﻁﻲ ﺍﺴﻡ ﺍﻟﻴﻭﻡ ﺍﻟﺫﻱ ﺴﺘﻨﻁﻠﻕ ﻤﻨﻪ ﺍﻟﺭﺤﻠﺔ ) ﺃﻱ ﺍﺫﺍ ﻜﺎﻨﺕ‬
‫ﺍﻟﺭﺤﻠﺔ ﺴﺘﻨﻁﻠﻕ ﺒﺘﺎﺭﻴﺦ ‪ 15/9/2003‬ﻓﺈﻥ ﻗﻴﻤﻪ ﻫﺫﺍ ﺍﻟﺤﻘل ﺴﺘﻜﻭﻥ " ﺍﻻﺜﻨﻴﻥ " ( ‪ ،‬ﺴﻴﻌﺘﻤﺩ ﻫﺫﺍ ﺍﻟﺤﻘل ﻓﻲ ﻗﻴﻤﺘﻪ ﻋﻠـﻰ‬
‫ﺍﻟﺤﻘل ‪ GoTime‬ﻭﻟﺘﺤﻘﻴﻕ ﺫﻟﻙ ﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ Active‬ﻟﻠﻌﻨﺼﺭ ‪ Table1‬ﺍﻟﻘﻴﻤﺔ ‪ False‬ﻭﺍﻓﺘﺢ ﻤﺤﺭﺭ ﺍﻟﺤﻘﻭل ﻭﻓـﻲ‬
‫ﺍﻟﻘﺴﻡ ‪ Name‬ﺃﻜﺘﺏ ‪ TheDay‬ﻭﻓﻲ ﺍﻟﻘﺴﻡ ‪ Type‬ﺍﺨﺘـﺭ ‪ ، String‬ﺍﻀـﻐﻁ ﻋﻠـﻰ ‪ OK‬ﻭﺍﻨﺘﻘـل ﺇﻟـﻰ ﺍﻟﺤـﺩﺙ‬
‫‪ OnClacFields‬ﻭﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪Case DayOfWeek ( Table1GoTime.AsDateTime ) of‬‬
‫ﻣﻼﺣﻈ ﺔ ‪ :‬ﻻ ﺗﺆﺛﺮ ﺍﳊﻘﻮﻝ ﺍﳊﺴﺎﺑﻴﺔ ﻋﻠﻰ ﺑﻨﻴﺔ ﻗﺎﻋﺪ ﺍﻟﺒﻴﺎﻧﺎﺕ‬
‫;'ﺍﻷﺤﺩ'=‪1: Table1Theday.Value :‬‬ ‫‪ ،‬ﻭﺇﺫﺍ ﺃﺭﺩﻧﺎ ﺍﺳﺘﺨﺪﺍﻡ ﻫﺬﻩ ﺍﳊﻘﻮﻝ ﰲ ﺃﻛﺜﺮ ﻣﻦ ﳕﻮﺫﺝ ﻋﻠﻴﻨـﺎ‬
‫ﺗﻌﺮﻳﻔﻬﺎ ﻣﻦ ﺟﺪﻳﺪ ﰲ ﻛﻞ ﻋﻨﺼﺮ ‪ Table‬ﺟﺪﻳﺪ ‪.‬‬
‫‪117‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫;'ﺍﻻﺜﻨﻴﻥ'=‪2: Table1Theday.Value :‬‬
‫;'ﺍﻟﺜﻼﺜﺎﺀ'=‪3: Table1Theday.Value :‬‬
‫;'ﺍﻷﺭﺒﻌﺎﺀ'=‪4: Table1Theday.Value :‬‬
‫;'ﺍﻟﺨﻤﻴﺱ'=‪5: Table1Theday.Value :‬‬
‫;'ﺍﻟﺠﻤﻌﺔ'=‪6: Table1Theday.Value :‬‬
‫;'ﺍﻟﺴﺒﺕ' =‪7: Table1Theday.Value :‬‬
‫;‪end‬‬
‫ﻴﻌﻴﺩ ﺍﻟﺘﺎﺒﻊ ‪ DayOfWeek‬ﺭﻗﻡ ﺍﻟﻴﻭﻡ ﻓﻲ ﺍﻷﺴﺒﻭﻉ ﺤﻴﺙ ﺃﻥ ﺍﻟﻴﻭﻡ ﺍﻷﻭل ﺍﻷﺤﺩ ﻭﺍﻟﺜﺎﻨﻲ ﺍﻻﺜﻨﻴﻥ ‪....‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻋﺩل ﻓﻲ ﻗﻴﻡ ﺍﻟﺤﻘل ‪ GoTime‬ﻭﻻﺤﻅ ﺍﻟﻨﺘﺎﺌﺞ ‪..........‬‬
‫) ‪SQL ( Structured Query Language‬‬ ‫ﻟﻐﺔ ﺍﻻﺴﺘﻔﺴﺎﺭﺍﺕ ﺍﻟﺒﻨﻴﻭﻴﺔ ‪:‬‬
‫ﺘﻌﺭﻴﻑ ‪ :‬ﻟﻐﺔ ‪ SQL‬ﻫﻲ ﻟﻐﺔ ﺒﺭﻤﺠﺔ ﺨﺎﺼﺔ ﻟﻠﺘﻌﺎﻤل ﻤﻊ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﺘﻌﺘﺒﺭ ﻟﻐﺔ ﺒﺭﻤﺠﺔ ﻋﺎﻟﻴﺔ ﺍﻟﻤـﺴﺘﻭﻯ‪ ،‬ﺤﻴـﺙ‬
‫ﻴﻤﻜﻨﻬﺎ ﻓﻲ ﺴﻁﺭ ﻭﺍﺤﺩ ﺇﺠﺭﺍﺀ ﻋﻤﻠﻴ‪‬ﺎﺕ ﺒﺎﻟﻐﺔ ﺍﻟﺘﻌﻘﻴﺩ ﻋﻠﻰ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫ﺘﺴﺘﺨﺩﻡ ‪ SQL‬ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻟﻠﺘﻌﺎﻤل ﻤﻊ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺴﻨﺘﻌﺭﻑ ﻋﻠﻰ ﺒﻌﺽ ﻤﻨﻬﺎ ﺍﻵﻥ ‪:‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ : Select‬ﻤﻬﻤﺔ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺇﺤﻀﺎﺭ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﻤﻥ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻟﻬﺎ ﺍﻟﺸﻜل ﺍﻟﻌﺎﻡ ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫‪Select FieldName1 , FieldName2 , FieldName13….‬‬
‫… ‪From TableName1,TableName2‬‬
‫] ‪[ Where Condition‬‬
‫]…‪[ Group By FieldName1,‬‬
‫] ‪[ Order By FieldName‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺒﻴﻥ ] [ ﺍﺨﺘﻴﺎﺭﻴﺔ ‪.‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺈﺤﻀﺎﺭ ﺍﻟﺤﻘﻭل ﺍﻟﻤﺤﺩﺩﺓ ﺍﻟﻘﺴﻡ ‪ Select‬ﻤﻥ ﺍﻟﺠﺩﻭل ﺍﻟﻤﺫﻜﻭﺭ ﺍﺴﻤﻪ ﻓﻲ ﺍﻟﻘﺴﻡ ‪From‬‬
‫ﻼ ﺇﺫﺍ ﺃﺭﺩﻨﺎ ﺇﺤﻀﺎﺭ ﺤﻘل ﺍﺴﻡ ﺍﻟﻤﺴﺎﻓﺭ ﻭ ﺍﻟﺠﻨﺴﻴﺔ ﻤﻥ ﺠﺩﻭل ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻨﺴﺘﺨﺩﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻤﺜ ﹰ‬
‫‪Select PName , Nationality‬‬
‫‪From Passengers‬‬
‫ﻴﺘﻡ ﺍﻟﺘﻌﺎﻤل ﻓﻲ ﺩﻟﻔﻲ ﻤﻊ ‪ SQL‬ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻌﻨﺼﺭ ‪ Query‬ﺍﻟﻤﻭﺠﻭﺩ ﻓﻲ ﺍﻟﺼﻔﺤﺔ ‪ BDE‬ﻭﻫﻭ ﻋﻨﺼﺭ ﻴﺸﺎﺒﻪ ﺍﻟﻌﻨﺼﺭ‬
‫‪ Table‬ﺒﺸﻜل ﻜﺒﻴﺭ ﻭﻟﻜﻨﻪ ﻻ ﻴﻤﻠﻙ ﺍﻟﺨﺎﺼﺔ ‪ TableName‬ﺤﻴﺙ ﻴﺘﻡ ﺘﺤﺩﻴﺩ ﺍﻟﺠﺩﺍﻭل ﺍﻟﺘﻲ ﺴﺘﺘﻌﺎﻤل ﻤﻊ ﻫﺫﺍ ﺍﻟﻌﻨـﺼﺭ‬
‫ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﺨﺎﺼﺔ ‪ SQL‬ﺍﻟﺘﻲ ﻴﺘﻡ ﻜﺘﺎﺒﺔ ﺘﻌﻠﻴﻤﺎﺕ ‪ SQL‬ﻓﻴﻬﺎ ‪.‬‬
‫ﻤﺜﺎل ‪ :‬ﺘﺤﻘﻴﻕ ﻤﺜﺎل ﺘﻌﻠﻴﻤﺔ ‪ SQL‬ﺍﻟﺴﺎﺒﻕ‬
‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﺘﺎﻟﻴﺔ ‪ Query‬ﻭ ‪ DataSource‬ﻭ ‪ DBGrid‬ﻭ‪DBNavigator‬‬
‫‪.‬‬
‫ﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ DataBaseName‬ﻟﻠﻌﻨﺼﺭ ‪ Query1‬ﺍﻟﻘﻴﻤﺔ ‪، Travel‬ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ‪ ...‬ﻓـﻲ ﺍﻟﺨﺎﺼـﺔ ‪SQL‬‬
‫ﺘﻅﻬﺭ ﻨﺎﻓﺫﺓ ﺍﻜﺘﺏ ﻓﻴﻬﺎ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪Select PName , Nationality‬‬
‫‪From Passengers‬‬

‫‪118‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ Active‬ﺍﻟﻘﻴﻤﺔ ‪ ) True‬ﻓﻲ ﺤﺎل ﻅﻬﻭﺭ ﺭﺴﺎﻟﺔ ﺨﻁﺄ ﺘﺄﻜﺩ ﻤﻥ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻭﻤﻥ ﻜﺘﺎﺒﺘﻙ ﻷﺴﻤﺎﺀ ﺍﻟﺤﻘـﻭل‬
‫ﻭﺍﻟﺠﺩﻭل ﺒﺸﻜل ﺼﺤﻴﺢ(‬
‫ﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ DataSet‬ﻟﻠﻌﻨﺼﺭ ‪ DataSource1‬ﺍﻟﻘﻴﻤﺔ ‪ Query1‬ﻭﺍﺭﺒﻁ ‪ DBGrid1‬ﻭ ‪ DBNavigator1‬ﻤـﻊ‬
‫‪. DataSource1‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻻﺤﻅ ﻅﻬﻭﺭ ﺍﻷﻋﻤﺩﺓ ﺍﻟﻤﻁﻠﻭﺒﺔ ﻓﻲ ﻋﺒﺎﺭﺓ ‪ Select‬ﺩﺍﺨل ﺍﻟﻌﻨﺼﺭ ‪ ، DBGrid‬ﻻﺤﻅ ﺃﻴـﻀﹰﺎ ﺃﻥ ﺃﺯﺭﺍﺭ‬
‫ﺘﻌﺩﻴل ﻭﺇﻀﺎﻓﺔ ﺍﻟﺴﺠﻼﺕ ﻓﻲ ﺍﻟﻌﻨﺼﺭ ‪ DBNavigator1‬ﻏﻴﺭ ﻓﻌﺎﻟﺔ ‪ ،‬ﻜﻤﺎ ﺃﻨﻪ ﻻ ﻴﻤﻜﻥ ﺍﻟﺘﻌﺩﻴل ﻓﻲ ﺍﻟﺒﻴﺎﻨـﺎﺕ ﻤـﻥ‬
‫ﺨﻼل ﺍﻟﻌﻨﺼﺭ ‪ DBGrid1‬ﻤﺒﺎﺸﺭﺓ ﻭﺫﻟﻙ ﻴﻌﻭﺩ ﺇﻟﻰ ﺃﻥ ﻋﺒﺎﺭﺓ ‪ Select‬ﺘﺴﺘﺨﺩﻡ ﻟﺠﻠﺏ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨـﺎﺕ ‪،‬‬
‫ﺃﻤﺎ ﺇﺫﺍ ﺃﺭﺩﻨﺎ ﺍﻟﺘﻌﺩﻴل ﺃﻭ ﺍﻹﻀﺎﻓﺔ ﺃﻭ ﺍﻟﺤﺫﻑ ﻓﻬﻨﺎﻙ ﺘﻌﻠﻴﻤﺎﺕ ‪ SQL‬ﺨﺎﺼﺔ ﺒﺫﻟﻙ‪ ،‬ﻭﻟﻜﻥ ﺍﻟﻌﻨﺼﺭ ‪ Query‬ﻴﻤﻠﻙ ﺨﺎﺼﺔ‬
‫‪ ، RequestLive‬ﻓﻌﻨﺩ ﺇﻋﻁﺎﺀ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻴﻤﻜﻥ ﺍﻟﺘﻌﺎﻤل‬ ‫ﺘﺠﻌل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻗﺎﺒﻠﺔ ﻟﻠﺘﺤﺭﻴﺭ ﻭﻫﻲ ﺍﻟﺨﺎﺼﺔ‬
‫ﻤﻊ ﺍﻟﻌﻨﺼﺭ ‪ Query‬ﻜﻤﺎ ﻜﻨﺎ ﻨﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻌﻨﺼﺭ ‪ Table‬ﺘﻤﺎﻤﹰﺎ ‪.‬‬
‫ﻻ ﻤﻥ ﺫﻜﺭ ﺃﺴﻤﺎﺀ ﺍﻷﻋﻤـﺩﺓ ‪ ،‬ﻋـﺩل‬
‫ﻤﺜﺎل ‪: 2‬ﺇﺫﺍ ﺃﺭﺩﻨﺎ ﺇﺤﻀﺎﺭ ﺤﻘﻭل ﺍﻟﺠﺩﻭل ﺒﺎﻟﻜﺎﻤل ﻨﺴﺘﺨﺩﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ * ‪ Select‬ﺒﺩ ﹰ‬
‫ﺍﻟﻌﺒﺎﺭﺓ ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ) ﺩﺍﺨل ﺍﻟﺨﺎﺼﺔ ‪ SQL‬ﻟﺘﺼﺒﺢ ﺒﺎﻟﺸﻜل ‪:‬‬
‫* ‪Select‬‬
‫‪From Passengers‬‬
‫ﺒﻌﺩ ﺃﻱ ﺘﻌﺩﻴل ﻋﻠﻰ ﺍﻟﺨﺎﺼﺔ ‪ SQL‬ﺴﺘﻌﻭﺩ ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﺔ ‪ Active‬ﻟﻠﻌﻨﺼﺭ ‪ Query‬ﺇﻟﻰ ‪False‬‬
‫ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺸﺭﻁ ‪ : Where‬ﺘﺴﺘﺨﺩﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ Where‬ﺩﺍﺨل ﻋﺒﺎﺭﺓ ‪ Select‬ﻟﺘﺤﻘﻴﻕ ﺸﺭﻭﻁ ﻤﻌﻴﻨﺔ ﻋﻠﻰ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘـﻲ‬
‫ﺴﻴﺤﻀﺭﻫﺎ ﺍﻻﺴﺘﻌﻼﻡ ‪.‬‬
‫ﻤﺜﺎل ‪ : 3‬ﻨﺭﻴﺩ ﻋﺭﺽ ﺠﻤﻴﻊ ﺤﻘﻭل ﺠﺩﻭل ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻭﺍﻟﺫﻴﻥ ﺃﺭﻗﺎﻤﻬﻡ ﺃﻜﺒﺭ ﻤﻥ ‪. 5‬‬
‫ﻋﺩل ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺴﺎﺒﻘﺔ ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ SQL‬ﻟﺘﺼﺒﺢ ﺒﺎﻟﺸﻜل ‪:‬‬
‫* ‪Select‬‬
‫‪From Passengers‬‬
‫‪Where PNo > 5‬‬
‫ﻤﺜﺎل ‪ : 4‬ﻨﺭﻴﺩ ﻋﺭﺽ ﺍﺴﻡ ﺍﻟﻤﺴﺎﻓﺭ ﺍﻟﺫﻱ ﺭﻗﻤﻪ ‪: 3‬‬
‫* ‪Select‬‬
‫‪From Passengers‬‬
‫‪Where PNo = 3‬‬
‫ﻤﺜﺎل ‪ : 5‬ﻨﺭﻴﺩ ﻋﺭﺽ ﺠﻤﻴﻊ ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﺍﻟﺫﻴﻥ ﺃﺭﻗﺎﻤﻬﻡ ﺒﻴﻥ ‪ 2‬ﻭ ‪: 5‬‬
‫* ‪Select‬‬
‫‪From Passengers‬‬
‫; ‪Where PNo Between 2 and 5‬‬
‫ﻤﺜﺎل ‪ : 6‬ﻨﺭﻴﺩ ﻋﺭﺽ ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﺍﻟﺫﻴﻥ ﺃﺭﻗﺎﻤﻬﻡ ﺨﺎﺭﺝ ﺍﻟﻤﺠﺎل ‪: 5 – 2‬‬
‫* ‪Select‬‬
‫‪From Passengers‬‬
‫; ‪Where PNo Not Between 2 and 5‬‬
‫ﻤﺜﺎل ‪ : 7‬ﻨﺭﻴﺩ ﻋﺭﺽ ﺠﻤﻴﻊ ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﺍﻟﺫﻴﻥ ﺍﺴﻤﻬﻡ ﻤﺤﻤﺩ ‪:‬‬
‫* ‪Select‬‬

‫‪119‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪From Passengers‬‬
‫'ﻤﺤﻤﺩ' = ‪Where PName‬‬
‫ﻤﺜﺎل ‪ : 8‬ﻨﺭﻴﺩ ﻋﺭﺽ ﺠﻤﻴﻊ ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﺍﻟﺫﻴﻥ ﻴﺒﺩﺃ ﺍﺴﻤﻬﻡ ﺒﺤﺭﻑ ﻡ‬
‫* ‪Select‬‬
‫‪From Passengers‬‬
‫'‪%‬ﻡ' ‪Where Pname Like‬‬
‫ﻤﺜﺎل ‪ : 9‬ﻨﺭﻴﺩ ﻋﺭﺽ ﺠﻤﻴﻊ ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﺍﻟﺫﻴﻥ ﻴﺒﺩﺃ ﺍﺴﻤﻬﻡ ﺒﺤﺭﻑ ﻡ ﻭﻁﻭل ﺍﺴﻤﻬﻡ ﺃﺭﺒﻊ ﺃﺤﺭﻑ ‪:‬‬
‫* ‪Select‬‬
‫‪From Passengers‬‬
‫'ﻡ____' ‪Where Pname Like‬‬
‫ﺘﺴﺘﺨﺩﻡ ‪ %‬ﻓﻲ ﺘﻌﻠﻴﻤﺔ ‪ Like‬ﻟﻺﺸﺎﺭﺓ ﺇﻟﻰ ﻋﺩﺩ ﻤﻥ ﺍﻷﺤﺭﻑ ‪.‬‬
‫ﺘﺴﺘﺨﺩﻡ _ ﻓﻲ ﺘﻌﻠﻴﻤﺔ ‪ Like‬ﻟﻺﺸﺎﺭﺓ ﺇﻟﻰ ﺤﺭﻑ ﻭﺤﻴﺩ ‪.‬‬
‫ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺘﺭﺘﻴﺏ ‪: Order By‬‬
‫ﺘﺴﺘﺨﺩﻡ ﺘﻌﻠﻴﻤﺔ ‪ Order by‬ﻟﺘﺭﺘﻴﺏ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺤﺴﺏ ﺤﻘل ﻤﺤﺩﺩ ‪:‬‬
‫ﻤﺜﺎل ‪ :10‬ﻨﺭﻴﺩ ﻋﺭﺽ ﺠﻤﻴﻊ ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻭﺍﻟﺫﻴﻥ ﺃﺭﻗﺎﻤﻬﻡ ﺃﻜﺒﺭ ﻤﻥ ‪ 5‬ﺒﺤﻴﺙ ﻴﻅﻬﺭ ﺘﺭﺘﻴﺏ ﺍﻷﺴﻤﺎﺀ ﺘﺼﺎﻋﺩﻴﹰﺎ‬
‫‪Select * From Passengers‬‬
‫‪Where PNo > 5‬‬
‫‪Order By PName‬‬
‫ﻤﺜﺎل ‪ :10‬ﻨﺭﻴﺩ ﻋﺭﺽ ﺠﻤﻴﻊ ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻭﺍﻟﺫﻴﻥ ﺃﺭﻗﺎﻤﻬﻡ ﺃﻜﺒﺭ ﻤﻥ ‪ 5‬ﺒﺤﻴﺙ ﻴﻅﻬﺭ ﺘﺭﺘﻴﺏ ﺍﻷﺴﻤﺎﺀ ﺘﺼﺎﻋﺩﻴﹰﺎ‬
‫‪Select * From Passengers‬‬
‫‪Where PNo > 5‬‬
‫‪Order By PName desc‬‬
‫ﻻ‬
‫ﻤﺜﺎل ‪: 11‬ﻨﺭﻴﺩ ﻋﺭﺽ ﺠﻤﻴﻊ ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻭﺍﻟﺫﻴﻥ ﺃﺭﻗﺎﻤﻬﻡ ﺃﻜﺒﺭ ﻤﻥ ‪ 5‬ﺒﺤﻴﺙ ﻴﺘﻡ ﺘﺭﺘﻴﺏ ﺍﻟﺠﺩﻭل ﺒﺎﻟﻨﺴﺒﺔ ﻟﻸﺴـﻤﺎﺀ ﺃﻭ ﹰ‬
‫ﻭﻤﻥ ﺜﻡ ﻷ ﻟﻠﺠﻨﺴﻴﺔ ) ﺃﻱ ﺇﺫﺍ ﺘﻁﺎﺒﻕ ﺍﺴﻤﻲ ﻤﺴﺎﻓﺭﻴﻥ ﺴﻴﻭﻀﻊ ﺘﺭﺘﻴﺒﻬﺎ ﻓﻲ ﺍﻟﺠﺩﻭل ﺤﺴﺏ ﺘﺭﺘﻴﺏ ﺍﻟﺠﻨﺴﻴﺔ ﺃﺒﺠﺩﻴﹰﺎ ( ‪.‬‬
‫‪Select * From Passengers‬‬
‫‪Where PNo > 5‬‬
‫‪Order By PName ,Nationality‬‬

‫ﺍﻟﺘﻭﺍﺒﻊ ﺍﻟﺠﺎﻤﻌﺔ ﻓﻲ ‪: SQL‬‬

‫‪ 1‬ـ ﺍﻟﺘﺎﺒﻊ ‪ : Count‬ﻴﻌﻴﺩ ﻋﺩﺩ ﺍﻟﺴﺠﻼﺕ ﺍﻟﺘﻲ ﺘﻌﻴﺩﻫﺎ ﻋﺒﺎﺭﺓ ‪: Select‬‬
‫ﻤﺜﺎل ‪ :12‬ﻟﻤﻌﺭﻓﺔ ﻋﺩﺩ ﺍﻟﺭﺤﻼﺕ ﺍﻟﻤﻐﺎﺩﺭﺓ ﻤﻥ ﻤﺩﻴﻨﺔ ﺤﻠﺏ ﻓﻲ ﺠﺩﻭل ﺍﻟﺭﺤﻼﺕ‬
‫) * (‪Select Count‬‬
‫‪From Trips‬‬
‫'ﺤﻠﺏ' = ‪Where GoFrom‬‬
‫ﺴﻴﻅﻬﺭ ﻓﻲ ﺍﻟﺠﺩﻭل ﺤﻘل ﻭﺤﻴﺩ ﻓﻴﻪ ﻋﺩﺩ ﺍﻟﺴﺠﻼﺕ ﺍﻟﻤﻐﺎﺩﺭﺓ ﻤﻥ ﻤﺩﻴﻨﺔ ﺤﻠﺏ ‪،‬ﻋﻨﻭﺍﻥ ﻫﺫﺍ ﺍﻟﺤﻘل )*(‪ ، Count‬ﻴﻤﻜـﻥ‬
‫ﺘﻐﻴﺭ ﻫﺫﺍ ﺍﻟﻌﻨﻭﺍﻥ ﺒﺘﻌﺩﻴل ﺘﻌﻠﻴﻤﺔ ‪ Select‬ﺇﻟﻰ‬
‫‪Select Count( * ) as Total ….‬‬
‫‪120‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ 2‬ـ ﺍﻟﺘﺎﺒﻊ ‪ : Sum‬ﻴﻌﻴﺩ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﻤﺠﻤﻭﻉ ﺴﺠﻼﺕ ﺤﻘل ﻤﺎ ‪.‬‬
‫ﻤﺜﺎل ‪ : 13‬ﻟﻤﻌﺭﻓﺔ ﻤﺠﻤﻭﻉ ﺒﻁﺎﻗﺎﺕ ﺍﻟﺭﺤﻼﺕ ﺍﻟﻤﻐﺎﺩﺭﺓ ﻤﻥ ﺤﻠﺏ ﻨﺴﺘﺨﺩﻡ ﻋﺒﺎﺭﺓ ‪ SQL‬ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫)‪Select Sum(CardCount‬‬
‫‪From Trips‬‬
‫'ﺤﻠﺏ' = ‪Where GoFrom‬‬
‫‪ 3‬ـ ﺍﻟﺘﺎﺒﻊ ‪: Avg‬ﻴﻌﻴﺩ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﺍﻟﻤﻌﺩل ﺍﻟﻭﺴﻁﻲ ﻟﻤﻌﻁﻴﺎﺕ ﺴﺠﻼﺕ ﺤﻘل ﻤﺎ‬
‫ﻤﺜﺎل ‪ : 14‬ﻟﻤﻌﺭﻓﺔ ﺍﻟﻤﻌﺩل ﺍﻟﻭﺴﻁﻲ ﻟﻌﺩﺩ ﺍﻟﺒﻁﺎﻗﺎﺕ ﺍﻟﻤﻭﺠﻭﺩﺓ ﺒﺎﻟﻨﺴﺒﺔ ﻟﻌﺩﺩ ﺍﻟﺭﺤﻼﺕ‬
‫)‪Select Avg(CardCount‬‬
‫‪Form Trips‬‬
‫‪ 4‬ـ ﺍﻟﺘﺎﺒﻊ ‪ : Max‬ﻴﻌﻴﺩ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﺃﻜﺒﺭ ﻗﻴﻤﺔ ﻓﻲ ﺍﻟﺤﻘل ‪:‬‬
‫ﻤﺜﺎل ‪ : 15‬ﻟﻤﻌﺭﻓﺔ ﺃﻜﺒﺭ ﻋﺩﺩ ﻟﻠﺒﻁﺎﻗﺎﺕ ﻓﻲ ﺤﻘل ‪CardCount‬‬
‫)‪Select Max(CardCount‬‬
‫‪From Trips‬‬
‫‪ 5‬ـ ﺍﻟﺘﺎﺒﻊ ‪ : Min‬ﻴﻌﻴﺩ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﺃﺼﻐﺭ ﻗﻴﻤﺔ ﻓﻲ ﺤﻘل ﻤﺎ ‪.‬‬
‫ﻋﺒﺎﺭﺓ ‪: Group By‬‬
‫ﺘﺴﺘﺨﺩﻡ ﻀﻤﻥ ﺘﻌﻠﻴﻤﺔ ‪ Select‬ﻹﺠﺭﺍﺀ ﻋﻤﻠﻴﺎﺕ ﻋﻠﻰ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻓﺭﺯﻫﺎ ﻀﻤﻥ ﻤﺠﻤﻭﻋﺎﺕ ﻭﻫﻲ ﻤﺭﺘﺒﻁﺔ ﺒﺸﻜل ﻭﺜﻴﻕ ﻤﻊ‬
‫ﺍﻟﺘﻭﺍﺒﻊ ﺍﻟﺠﺎﻤﻌﺔ ‪:‬‬
‫ﻤﺜﺎل ‪ : 16‬ﻹﻅﻬﺎﺭ ﻋﺩﺩ ﺍﻟﺭﺤﻼﺕ ﺍﻟﻤﻐﺎﺩﺭﺓ ﻤﻥ ﻜل ﻤﻁﺎﺭ ‪:‬‬
‫)‪Select GoFrom ,Count(GoFrom‬‬
‫‪From Trips‬‬
‫‪Group by GoFrom‬‬
‫ﻤﺜﺎل ‪ : 17‬ﻟﻤﻌﺭﻓﺔ ﻋﺩﺩ ﺍﻟﺒﻁﺎﻗﺎﺕ ﻟﻠﺭﺤل ﺍﻟﻤﻐﺎﺩﺭﺓ ﻤﻥ ﻜل ﻤﻁﺎﺭ ‪:‬‬
‫)‪Select GoFrom ,Sum(CardCount‬‬
‫‪From Trips‬‬
‫‪Group by GoFrom‬‬

‫ﻤﻼﺤﻅﺔ ‪ :‬ﺠﻤﻴﻊ ﺍﻟﺤﻘﻭل ﺍﻟﻭﺍﺭﺩﺓ ﻓﻲ ﺘﻌﻠﻴﻤﺔ ‪ Select‬ﻴﺠﺏ ﺃﻥ ﺘﺭﺩ ﻓﻲ ﺘﻌﻠﻴﻤﺔ ‪ Group By‬ﻤﺎ ﻋﺩﺍ ﺍﻟﺤﻘـﻭل ﺍﻟﺘـﻲ‬
‫ﺘﺴﺘﺨﺩﻡ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺠﺎﻤﻌﺔ ‪.‬‬
‫ﻋﺒﺎﺭﺓ ‪: Having‬‬
‫ﺘﺴﺘﺨﺩﻡ ﺘﻌﻠﻴﻤﺔ ‪ Having‬ﺒﻌﺩ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ Group By‬ﻟﻭﻀﻊ ﺸﺭﻭﻁ ﻋﻠﻰ ﻋﻤﻠﻴﺔ ﻓﺭﺯ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪.‬‬
‫ﻤﺜﺎل ‪ : 18‬ﻟﻤﻌﺭﻓﺔ ﻋﺩﺩ ﺍﻟﺒﻁﺎﻗﺎﺕ ﻟﻠﺭﺤل ﺍﻟﻤﻐﺎﺩﺭﺓ ﻤﻥ ﻜل ﻤﻁﺎﺭ ﻭﺍﻟﺘﻲ ﻋﺩﺩ ﺒﻁﺎﻗﺎﺘﻬﺎ ﺃﻜﺒﺭ ﻤﻥ ‪. 10‬‬
‫)‪Select GoFrom ,Sum(CardCount‬‬
‫‪From Trips‬‬
‫‪Group by GoFrom‬‬
‫‪Having Sum( CardCount) > 10‬‬
‫ﻤﺜﺎل ‪ : 19‬ﻟﻤﻌﺭﻓﺔ ﻋﺩﺩ ﺍﻟﺒﻁﺎﻗﺎﺕ ﻟﻠﺭﺤل ﺍﻟﻤﻐﺎﺩﺭﺓ ﻤﻥ ﻜل ﻤﻁﺎﺭ ﻭﺍﻟﺘﻲ ﻋﺩﺩ ﺒﻁﺎﻗﺎﺘﻬﺎ ﻻ ﻴﺴﺎﻭﻱ ‪Null‬‬
‫)‪Select GoFrom ,Sum(CardCount‬‬
‫‪121‬‬
http://www.alshater.net ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
From Trips
Group by GoFrom
Having Sum( CardCount ) is not null

122
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ‪20‬‬
‫ﺭﺒﻁ ﺍﻟﺠﺩﺍﻭل ‪:‬‬
‫ﻴﻤﻜﻥ ﺍﺴﺘﺨﺩﺍﻡ ﻋﺒﺎﺭﺓ ‪ Select‬ﻹﺤﻀﺎﺭ ﺒﻴﺎﻨﺎﺕ ﻤﻥ ﺃﻜﺜﺭ ﻤﻥ ﺠﺩﻭل ﻭﺒﺘﻁﺒﻴﻕ ﺒﻌﺽ ﺍﻟﺸﺭﻭﻁ ﻓﻲ ﻋﺒﺎﺭﺓ ‪Where‬‬
‫ﻨﺤﺼل ﻋﻠﻰ ﺠﺩﺍﻭل ﻤﺭﺘﺒﺔ ﻭﺃﻜﺜﺭ ﻓﺎﻋﻠﻴﺔ ﻤﻥ ﺍﻟﺠﺩﺍﻭل ﺍﻟﺘﻲ ﻴﻅﻬﺭﻫﺎ ﺍﻟﻌﻨﺼﺭ ‪. Table‬‬
‫ﻻ ﻤﻥ ﺭﻗﻤﻪ ‪:‬‬
‫ﻤﺜﺎل ‪ :1‬ﺭﺒﻁ ﺍﻟﺠﺩﻭﻟﻴﻥ ‪ Passengers‬ﻭ ‪ PassAndTrips‬ﻹﻅﻬﺎﺭ ﺍﺴﻡ ﺍﻟﻤﺴﺎﻓﺭ ﺒﺩ ﹰ‬
‫‪SELECT Pname,TripNo,SeatNo,ClassNo‬‬
‫‪FROM PassAndtrips, Passengers‬‬
‫‪WHERE PassAndtrips.PNo = Passengers.PNo‬‬

‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺈﺤﻀﺎﺭ ﺃﺴﻤﺎﺀ ﺍﻷﻋﻤﺩﺓ ﺍﻟﻤﺨﺘﺎﺭﺓ ﻤﻥ ﺠﺩﻭﻟﻲ ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻭ " ﺍﻟﻤﺴﺎﻓﺭﻴﻥ ﻭﺍﻟﺭﺤﻼﺕ " ﺒﺘﻁﺒﻴﻕ ﺍﻟﺸﺭﻁ‬
‫ﺍﻷﺨﻴﺭ ﻭﺍﻟﺫﻱ ﻴﺴﻤﻰ ﺸﺭﻁ ﺭﺒﻁ ﺍﻟﺠﺩﺍﻭل ) ﻓﻲ ﺤﺎل ﺘﺸﺎﺒﻪ ﺍﺴﻡ ﺍﻟﺤﻘل ﻓﻲ ﺠﺩﻭﻟﻴﻥ ﻨﻜﺘﺏ ﺍﺴﻡ ﺍﻟﺠﺩﻭل ﻗﺒل ﺍﺴﻡ ﺍﻟﺤﻘل‬
‫ﻭﺒﻴﻨﻬﻤﺎ ﻨﻘﻁﺔ ‪Passengers.PNo‬‬
‫ﻤﺜﺎل ‪: 2‬ﺭﺒﻁ ﺍﻟﺠﺩﺍﻭل ‪ PassAndTrips‬ﻭ ‪ Passengers‬ﻭ ‪ : Trips‬ﺒﺤﻴﺙ ﻴﻅﻬﺭ ﺠﺩﻭل ﻓﻴﻪ ﺍﺴﻡ ﺍﻟﻤﺴﺎﻓﺭ ﻭ ﺍﺴﻡ‬
‫ﺍﻟﺸﺭﻜﺔ ﺍﻟﺘﻲ ﺴﻴﺴﺎﻓﺭ ﻤﻌﻬﺎ ﻭﺒﻠﺩ ﺍﻟﻤﻐﺎﺩﺭﺓ ﻭ ﺭﻗﻡ ﺍﻟﻤﻘﻌﺩ ﻭﺭﻗﻡ ﺍﻟﺼﻑ ‪:‬‬
‫‪SELECT Pname, Company, GoFrom, SeatNo, ClassNo‬‬
‫‪FROM Passandtrips, Passengers, Trips‬‬
‫)‪WHERE (PassAndtrips.PNo = Passengers.PNo‬‬
‫)‪AND (PassAndtrips.TripNo = Trips.TripNo‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ‪: Inner join‬‬
‫ﻫﻲ ﺘﻌﻠﻴﻤﺔ ﺘﺴﺘﺨﺩﻡ ﻟﻠﺭﺒﻁ ﺒﻴﻥ ﺍﻟﺠﺩﺍﻭل ﺤﻴﺙ ﻴﻤﻜﻥ ﻜﺘﺎﺒﺔ ﻋﺒﺎﺭﺓ ‪ SQL‬ﻟﻠﻤﺜﺎل ﺍﻷﻭل ﺒﺎﻟﺸﻜل ‪:‬‬
‫‪SELECT Pname, TripNo,SeatNo, ClassNo‬‬
‫‪FROM PassAndtrips‬‬
‫‪INNER JOIN Passengers‬‬
‫)‪ON (Passengers.PNo = PassAndtrips.PNo‬‬
‫ﻭﻴﻤﻜﻥ ﻜﺘﺎﺒﺔ ﻋﺒﺎﺭﺓ ‪ SQL‬ﻟﻠﻤﺜﺎل ﺍﻟﺜﺎﻨﻲ ﺒﺎﻟﺸﻜل ‪:‬‬
‫‪SELECT Pname, company, SeatNo, ClassNo‬‬
‫‪FROM Passandtrips‬‬
‫‪INNER JOIN Passengers‬‬
‫)‪ON (Passengers.PNo = Passandtrips.PNo‬‬
‫‪INNER JOIN Trips‬‬
‫)‪ON (Trips.TripNo = Passandtrips.TripNo‬‬
‫ﻤﻼﺤﻅﺎﺕ ‪:‬‬
‫‪ 1‬ـ ﻫﻨﺎﻙ ﻋﺒﺎﺭﺍﺕ ﺃﺨﺭﻯ ﻟﻠﺭﺒﻁ ﻤﺜل ‪ Outer Join‬ﻭ ‪ Left Join‬ﻭ ‪ Right Join‬ﻴﻤﻜﻨﻙ ﻤﺭﺍﺠﻌﺔ ﻜﺘﺏ ‪SQL‬‬
‫ﻟﻠﺘﻌﺭﻑ ﻋﻠﻴﻬﺎ‪.‬‬
‫‪ 1‬ـ ﺒﺎﻹﻀﺎﻓﺔ ﻟﻌﺒﺎﺭﺓ ‪ SELECT‬ﻴﻭﺠﺩ ﻋﺒﺎﺭﺍﺕ ﺃﺨﺭﻯ ﻓﻲ ‪ SQL‬ﻤﻨﻬﺎ ‪:‬‬
‫ﺍﻟﻌﻤل‬ ‫ﺍﻟﻌﺒﺎﺭﺓ‬
‫ﺇﻨﺸﺎﺀ ﺠﺩﻭل‬ ‫‪Create Table‬‬
‫‪123‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺇﺩﺨﺎل ﻗﻴﻡ ﺇﻟﻰ ﺠﺩﻭل‬ ‫‪Insert‬‬
‫ﺘﻌﺩﻴل ﻗﻴﻡ ﺠﺩﻭل‬ ‫‪Update‬‬
‫ﺤﺫﻑ ﺴﺠﻼﺕ ﻤﻥ ﺠﺩﻭل ‪.‬‬ ‫‪Delete From‬‬
‫ﻟﻠﺘﻌﺭﻑ ﻋﻠﻰ ﻫﺫﻩ ﺍﻷﻭﺍﻤﺭ ﺭﺍﺠﻊ ﻜﺘﺏ ‪ SQL‬ﺍﻟﻤﺨﺘﺼﺔ ‪....‬‬
‫ﺍﻟﺒﺭﻨﺎﻤﺞ ‪: SQL Builder‬‬
‫ﻴﺴﺘﺨﺩﻡ ﻫـﺫﺍ ﺍﻟﺒﺭﻨـﺎﻤﺞ ﻟﻜﺘﺎﺒـﺔ‬
‫ـﻲ‬
‫ـﺸﻜل ﻤﺭﺌـ‬
‫ـﺎﺕ ‪ SQL‬ﺒـ‬
‫ﺘﻌﻠﻴﻤـ‬
‫ﻭﺘﻔﺎﻋﻠﻲ ﻭﺒﻜﻼﻡ ﺁﺨﺭ ﻫﻭ ﻋﺒـﺎﺭﺓ‬
‫ﻋﻥ ﺃﺩﺍﺓ ﺘﺴﻬل ﻜﺘﺎﺒـﺔ ﺘﻌﻠﻴﻤـﺎﺕ‬
‫‪ SQL‬ﻜﻤﺎ ﺘﻤﻜﻨﻨﺎ ﻤﻥ ﺍﺴـﺘﻌﺭﺍﺽ‬
‫ﺍﻟﻨﺘﺎﺌﺞ ‪...‬‬
‫ﻟﺘﺸﻐﻴل ‪ SQL Builder‬ﻀـﻊ‬
‫ﻋﻨﺼﺭ ‪ Query‬ﻋﻠـﻰ ﺍﻟﻨﻤـﻭﺫﺝ‬
‫ﻭﺍﻀﻐﻁ ﻋﻠﻴﻪ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﻤﻨـﻲ‬
‫ـﻥ‬
‫ـﺭ ‪ SQL Builder‬ﻤـ‬
‫ﻭﺍﺨﺘـ‬
‫ﺍﻟﻘﺎﺌﻤﺔ ﺴﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻤﺠﺎﻭﺭﺓ‬

‫ﻤﺜﺎل ‪ : 1‬ﻹﻅﻬﺎﺭ ﺤﻘﻭل ﻤﻥ ﺠﺩﻭل ﺍﻟﺭﺤﻼﺕ ‪:‬‬

‫‪ 1‬ـ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﻤﻨﺴﺩﻟﺔ ‪ Database‬ﺍﺨﺘﺭ ﺍﺴﻡ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ ‪ Travel‬ﻋﻨﺩﻫﺎ ﺴﺘﻅﻬﺭ ﺠﻤﻴﻊ ﺍﻟﺠﺩﺍﻭل ﻀﻤﻥ ﻫﺫﻩ‬
‫ﺍﻟﻘﺎﻋﺩﺓ ﻓﻲ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻤﺠﺎﻭﺭﺓ ‪ Table‬ﺍﺨﺘﺭ ﻤﻨﻬﺎ ‪Trips.db‬‬
‫‪ 2‬ـ ﺴﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﻨﺎﻓﺫﺓ ﺼﻐﻴﺭﺓ ﺘﺤﻭﻱ ﺠﻤﻴﻊ ﺤﻘﻭل ﺠﺩﻭل ﺍﻟﺭﺤﻼﺕ ﻭﺒﺠﻭﺍﺭ ﻫﺫﻩ ﺍﻟﺤﻘﻭل ﺼﻨﺎﺩﻴﻕ ﺨﻴﺎﺭ ‪ ،‬ﺒﺘﺤﻔﻴـﺯ‬
‫ﻫﺫﻩ ﺍﻟﺼﻨﺎﺩﻴﻕ ﻴﻤﻜﻥ ﺍﺨﺘﻴﺎﺭ ﺍﻟﺤﻘﻭل ﺍﻟﺘﻲ ﺴﺘﻅﻬﺭ ﻓﻲ ﺍﻻﺴﺘﻌﻼﻡ ) ﺤﺩﺩ ﺒﻌﻀﹰﺎ ﻤﻥ ﻫﺫﻩ ﺍﻟﺤﻘﻭل ( ‪.‬‬
‫ﺴﺘﻼﺤﻅ ﻤﺒﺎﺸﺭﺓ ﻨﺘﺎﺌﺞ ﺍﻻﺴﺘﻌﻼﻡ ﻭﺍﻟﺫﻱ ﻴﻤﻜﻨـﻙ‬ ‫‪ 3‬ـ ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Execute SQL‬ﻤﻥ ﺇﺯﺍﺭﺍ ﺍﻟﺴﺭﻋﺔ‬
‫ﻗﺭﺍﺀﺓ ﺘﻌﻠﻴﻤﺎﺘﻪ ﺒﺎﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ SQL‬ﺍﻟﻤﺠﺎﻭﺭ ﻟﻠﺯﺭ ﺍﻟﺴﺎﺒﻕ ‪.‬‬
‫‪ 4‬ـ ﺃﻏﻠﻕ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪ SQL Builder‬ﺴﻴﺴﺄﻟﻙ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺇﺫﺍ ﻜﻨﺕ ﺘﺭﻴﺩ ﺤﻔﻅ ﺍﻟﺘﻐﻴﺭﺍﺕ ﺇﻟﻰ ﺍﻻﺴﺘﻌﻼﻡ ‪ ،‬ﺇﺫﺍ ﺍﺨﺘﺭﺕ ﻨﻌﻡ‬
‫ﺴﺘﺸﺎﻫﺩ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻀﻤﻥ ﺍﻟﺨﺎﺼﺔ ‪ SQL‬ﻟﻠﻌﻨﺼﺭ ‪ Query‬ﺒﺸﻜل ﺘﻠﻘﺎﺌﻲ ‪..‬‬

‫ﻤﺜﺎل ‪ : 2‬ﺘﻌﻠﻴﻤﺔ ‪ Where‬ﺒﺎﺴﺘﺨﺩﺍﻡ ‪ : SQL Builder‬ﻹﻅﻬﺎﺭ ﺠﻤﻴﻊ ﺍﻟﺭﺤﻼﺕ ﺍﻟﻤﻐﺎﺩﺭﺓ ﻤﻥ ﻤﻁﺎﺭ ﺤﻠﺏ ﻗﻡ ﺒﻤﺎ ﻴﻠﻲ‬
‫‪:‬‬

‫‪124‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ 1‬ـ ﺍﺩﺨل ﺇﻟﻰ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪ ... SQL Builder‬ﻜﻤﺎ ﻓﻲ ﺍﻟﺴﺎﺒﻕ ‪:‬‬
‫‪ 2‬ـ ﺤﺩﺩ ﺠﻤﻴﻊ ﺤﻘﻭل ﺍﻟﺠﺩﻭل ‪ Trips.db‬ﺒﺎﻟﻀﻐﻁ ﻋﻠﻰ ﺼﻨﺩﻭﻕ ﺍﻟﺨﻴﺎﺭ ﺍﻟﻤﺠﺎﻭﺭ ﻷﺴﻡ ﺍﻟﺠـﺩﻭل ) ﻀـﻤﻥ ﺍﻟﻨﺎﻓـﺫﺓ‬
‫ﺍﻟﺼﻐﻴﺭﺓ ( ‪.‬‬
‫‪ 3‬ـ ﻀﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪ ) Criteria‬ﻤﻌﺎﻴﻴﺭ ( ‪ :‬ﺍﺨﺘﺭ ‪ Trips.Gofrom‬ﻤﻥ ﺍﻟﻌﻤﻭﺩ ﺍﻷﻴﺴﺭ ‪ Field Value‬ﻭﺍﺨﺘـﺭ =‬
‫ﻤﻥ ﺍﻟﻌﻤﻭﺩ ‪ Compare‬ﻭﺍﻜﺘﺏ ﻓﻲ ﺍﻟﻌﻤﻭﺩ ﺍﻷﻴﻤﻥ ‪ Field Value‬ﺍﻟﻜﻠﻤﺔ ) ﺤﻠﺏ ( ‪.‬‬
‫‪ 4‬ـ ﺸﺎﻫﺩ ﻋﺒﺎﺭﺓ ‪ SQL‬ﺜﻡ ﻨﻔﺫﻫﺎ ‪...‬‬
‫ﻤﺜﺎل ‪ : 3‬ﺴﻨﻀﻴﻑ ﺸﺭﻁ ﺠﺩﻴﺩ ﻋﻠﻰ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﻭﻫﻭ ﺇﻅﻬﺎﺭ ﺍﻟﺭﺤﻼﺕ ﺍﻟﺘﻲ ﻏﺎﺩﺭﺕ ﺤﻠﺏ ﺒﺎﺘﺠﺎﻩ ﺍﻟﻘﺎﻫﺭﺓ ‪.‬‬
‫‪ 1‬ـ ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺘﺎﻟﻲ ﻟﻠﺸﺭﻁ ﺍﻟﺴﺎﺒﻕ ﺍﺨﺘﺭ ﻤﻥ ﺍﻟﻌﻤﻭﺩ ﺍﻷﻴﺴﺭ ‪ Trips.ArriveTo‬ﻭﺍﺨﺘﺭ = ﻤﻥ ﺍﻟﻌﻤﻭﺩ ‪Compare‬‬
‫ﻭﺍﻜﺘﺏ ﻓﻲ ﺍﻟﻌﻤﻭﺩ ﺍﻷﻴﻤﻥ ) ﺍﻟﻘﺎﻫﺭﺓ ( ‪.‬‬
‫ﺘﻐﻴﺭ ﻋﻨﺎﻭﻴﻥ ﺍﻟﺤﻘﻭل ‪:‬ﻗﻲ ‪ SQL Builder‬ﺍﺨﺘﺭ ﺍﻟﺼﻔﺤﺔ ‪ Selection‬ﺴﺘﺸﺎﻫﺩ ﻓﻴﻬﺎ ﺠﻤﻴـﻊ ﺍﻟﺤﻘـﻭل ﺍﻟﺘـﻲ ﻗﻤـﺕ‬
‫ﺒﺎﺨﺘﻴﺎﺭﻫﺎ ﻤﻥ ﺍﻟﺠﺩﻭل ‪ Trip‬ﻴﻤﻜﻨﻙ ﺤﻴﺙ ﻴﻅﻬﺭ ﻓﻲ ﺍﻟﻌﻤﻭﺩ ﺍﻷﻴﻤﻥ ) ‪ ( Field‬ﺍﺴﻡ ﺍﻟﺤﻘل ﻭﻴﻅﻬﺭ ﺍﻟﻌﻤﻭﺩ ﺍﻷﻴﺴﺭ )‬
‫‪ ( Output Name‬ﻋﻨﻭﺍﻥ ﺍﻟﺤﻘل ﻴﻤﻜﻨﻙ ﻓﻲ ﻫﺫﺍ ﺍﻟﻘﺴﻡ ﻜﺘﺎﺒﺔ ﻋﻨﻭﺍﻥ ﻟﻠﺤﻘل ) ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻠﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ ( ‪ )،‬ﻴﻅﻬﺭ‬
‫ﻋﻨﻭﺍﻥ ﺍﻟﺤﻘل ﻓﻲ ﺍﻟﻘﺴﻡ ﺍﺴﻡ ﺍﻟﺤﻘل ﻓﻲ ﺍﻟﻌﻨﺼﺭ ‪ DBGrid‬ﺍﻟﻤﺭﺘﺒﻁ ﻤﻊ ﺍﻟﻌﻨﺼﺭ ‪، ( Query‬‬
‫ﻨﻔﺫ ﻋﺒﺎﺭﺓ ‪ SQL‬ﻟﺘﻼﺤﻅ ﺍﻟﻨﺘﺎﺌﺞ ‪.‬‬
‫ﺘﺭﺘﻴﺏ ﺤﻘﻭل ﺍﻟﺠﺩﻭل ‪:‬‬
‫ﻭﺠﺩﻨﺎ ﺃﻥ ﺘﻌﻠﻴﻤﺔ ‪ Order By‬ﺘﺴﺘﺨﺩﻡ ﻟﺘﺭﺘﻴﺏ ﺍﻟﺠﺩﻭل ﻭ ﻟﻜﺘﺎﺒﺔ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤـﺔ ﺒﺎﺴـﺘﺨﺩﺍﻡ ‪ SQL Builder‬ﻨﺨﺘـﺎﺭ‬
‫ﺍﻟﺼﻔﺤﺔ ‪ Sorting‬ﺤﻴﺙ ﺘﻅﻬﺭ ﻓﻲ ﺍﻟﻘﺴﻡ ﺍﻷﻴﺴﺭ ﺠﻤﻴﻊ ﺍﻟﺤﻘﻭل ﺍﻟﻤﺨﺘﺎﺭﺓ ﻤﻥ ﺍﻟﺠﺩﻭل ‪ ،‬ﺤﺩﺩ ﺃﺤﺩ ﻫﺫﻩ ﺍﻟﺤﻘﻭل ﻭﺍﻀﻐﻁ‬
‫ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Add‬ﻟﻴﻀﺎﻑ ﺍﺴﻤﻪ ﺇﻟﻰ ﺍﻟﻘﺴﻡ ﺍﻷﻴﻤﻥ ﻤﻥ ﺍﻟﺼﻔﺤﺔ ) ‪ ، ( Sorted by‬ﻴﻤﻜﻨﻙ ﺇﻀﺎﻓﺔ ﺃﻜﺜﺭ ﻤﻥ ﺤﻘل ﻜﻤـﺎ‬
‫ﻴﻤﻜﻨﻙ ﺘﺤﺩﻴﺩ ﻁﺭﻴﻘﺔ ﺍﻟﺘﺭﺘﻴﺏ ) ﺘﺼﺎﻋﺩﻱ ﺃﻡ ﺘﻨﺎﺯﻟﻲ ( ﺒﺎﺨﺘﻴﺎﺭ ﺍﻟﺤﻘل ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Sorted By‬ﻭﺍﻟـﻀﻐﻁ ﻋﻠـﻰ ﺃﺤـﺩ‬
‫ﺍﻟﺯﺭﻴﻥ ‪ AÆZ‬ﺃﻭ ‪ Z ÆA‬ﻗﻲ ﺍﻟﻭﺴﻁ ‪....‬‬
‫ﺍﻟﺘﺠﻤﻴﻊ ﻭﺸﺭﻭﻁ ﺍﻟﺘﺠﻤﻴﻊ ‪:Group by …Having‬‬
‫ﻴﻤﻜﻨﻙ ﻜﺘﺎﺒﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ‪ Group by‬ﻭ ‪ Having‬ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﺼﻔﺤﺘﻴﻥ ‪ Grouping‬ﻭ ‪. Group Criteria‬‬
‫ﺭﺒﻁ ﺍﻟﺠﺩﺍﻭل ﺒﺎﺴﺘﺨﺩﺍﻡ ‪: SQL Builder‬‬
‫ﺤل ﺍﻟﻤﺜﺎل ﺍﻷﻭل ‪:‬‬
‫ﺍﻓﺘﺢ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪ ) SQL Builder‬ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﻤﻴﻨﻲ ﻋﻠﻰ ﻋﻨـﺼﺭ ‪ ( Query‬ﺍﺨﺘـﺭ ﺍﻟﻘﺎﻋـﺩﺓ‬
‫‪ Travel‬ﻭﺍﺨﺘﺭ ﺍﻟﺠﺩﻭل ‪ PassAndTrips‬ﻭﻤﻥ ﺍﻟﻼﺌﺤﺔ ‪ Table‬ﻭﻤﻥ ﺜﻡ ﺍﺨﺘﺭ ﺍﻟﺠﺩﻭل ‪ Passenegers‬ﻤـﻥ ﻨﻔـﺱ‬
‫ﺍﻟﻼﺌﺤﺔ ‪:‬‬
‫ﺴﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﻨﺎﻓﺫﺘﻲ ﺍﻟﺠﺩﻭﻟﻴﻥ ‪ ،‬ﺍﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻷﻴﺴﺭ ﻋﻠﻰ ﺍﻟﺤﻘل ‪ PNo‬ﻓـﻲ ﻨﺎﻓـﺫﺓ ﺍﻟﺠـﺩﻭل ‪Passengers‬‬
‫ﻭﺤﺭﻙ ﻴﺩﻙ ﺒﺎﺘﺠﺎﻩ ﺍﻟﺤﻘل ‪ PNo‬ﻓﻲ ﻨﺎﻓﺫﺓ ﺍﻟﺠﺩﻭل ‪ PassAndTrips‬ﻤﻊ ﺇﺒﻘﺎﺀ ﺍﻟﺯﺭ ﻤﻀﻐﻭﻁﹰﺎ ‪ ،‬ﺤﺭﺭ ﺯﺭ ﺍﻟﻔﺄﺭﺓ ﻓﻭﻕ‬
‫ﺍﻟﺤﻘل ‪ PNo‬ﺘﻤﺎﻤﹰﺎ ‪ ،‬ﺴﻴﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺨﻁ ﻴﺼل ﺒﻴﻥ ﺍﻟﻨﺎﻓﺫﺘﻴﻥ ﺩﻟﻴل ﻋﻠﻰ ﻋﻤﻠﻴﺔ ﺍﻟﺭﺒﻁ ) ﺍﺨﺘﺭ ﺒﻌـﺽ ﺍﻟﺤﻘـﻭل ﻤـﻥ‬
‫ﺍﻟﺠﺩﻭﻟﻴﻥ ﻭﺸﺎﻫﺩ ﺍﻟﻨﺎﻓﺫﺓ ‪ SQL‬ﻟﻠﻤﺸﺎﻫﺩﺓ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ( ‪.‬‬

‫‪125‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻟﺤل ﺍﻟﻤﺜﺎل ﺍﻟﺜﺎﻨﻲ ‪ :‬ﺃﻀﻑ ﺍﻟﺠﺩﻭل ‪ Trips‬ﻤﻥ ﺍﻟﻼﺌﺤﺔ ‪ Table‬ﺴﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﻨﺎﻓﺫﺓ ﺍﻟﺠﺩﻭل ‪ Trips‬ﻭﺒﻨﻔﺱ ﺍﻟﻁﺭﻴﻘﺔ‬
‫ﺍﻟﺴﺎﺒﻘﺔ ﺍﺭﺒﻁ ﺒﻴﻥ ﺍﻟﺤﻘﻠﻴﻥ ‪ TripNo‬ﻓﻲ ﺍﻟﺠﺩﻭﻟﻴﻥ ‪...‬‬
‫ﺍﻻﺴﺘﻔﺴﺎﺭﺍﺕ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻴﺔ ‪:‬‬
‫ﺠﻤﻴﻊ ﺍﻻﺴﺘﻔﺴﺎﺭﺍﺕ ﺍﻟﺘﻲ ﺃﺠﺭﻴﻨﻬﺎ ﺤﺘﻰ ﺍﻵﻥ ﺘﺩﻋﻰ ﺍﺴﺘﻔﺴﺎﺭﺍﺕ ) ﺍﺴﺘﻌﻼﻤﺎﺕ ( ﺴﺘﺎﺘﻴﻜﻴﺔ ﻭﺫﻟﻙ ﻷﻨﻬﺎ ﺸﺭﻭﻁﻬﺎ ﺘﻜـﻭﻥ‬
‫ﻼ ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺫﻱ ﺒﺤﺜﻨﺎ ﻓﻴﻪ ﻋﻥ ﺍﻟﺭﺤﻼﺕ ﺍﻟﻤﻐﺎﺩﺭﺓ ﻤﻥ ﻤﻁﺎﺭ ﺤﻠﺏ ﻜﺘﺒﻨـﺎ ﺍﻟﻌﺒـﺎﺭﺓ 'ﺤﻠـﺏ‬
‫ﻤﺤﺩﺩﺓ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ﻓﻤﺜ ﹰ‬
‫' = ‪ ، Where GoFrom‬ﻤﻥ ﺍﻟﻤﻼﺤﻅ ﺃﻥ ﻫﺫﺍ ﺍﻻﺴﺘﻔﺴﺎﺭ ﻴﻌﻴﺩ ﺩﺍﺌﻤﹰﺎ ﺍﻟﺭﺤﻼﺕ ﺍﻟﻤﻐﺎﺩﺭﺓ ﻤـﻥ ﺤﻠـﺏ ﻭﻻ ﻴـﺴﺘﻁﻴﻊ‬
‫ﺍﻟﻤﺴﺘﺨﺩﻡ ﺍﻟﺒﺤﺙ ﻋﻥ ﺍﻟﺭﺤﻼﺕ ﺍﻟﻤﻐﺎﺩﺭﺓ ﻤﻥ ﺩﻤﺸﻕ ﺩﻭﻥ ﺍﻟﻌﻭﺩﺓ ﺇﻟﻰ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺇﻟﻰ ﻭﻀﻊ ﺍﻟﺘﺼﻤﻴﻡ ﻭ ﺘﻐﻴﻴﺭ ﻜﻠﻤﺔ ﺤﻠﺏ‬
‫ﺇﻟﻰ ﺩﻤﺸﻕ ‪...‬‬
‫ﻟﺫﻟﻙ ﺯﻭﺩﺘﻨﺎ ﺩﻟﻔﻲ ﺒﻤﺎ ﻴﺴﻤﻰ ﺒﺎﻻﺴﺘﻔﺴﺎﺭﺍﺕ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻴﺔ ﻭﺍﻟﺘﻲ ﺘﻤﻜﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻤﻥ ﺇﻋﻁﺎﺀ ﺍﻟﺸﺭﻁ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ﻭﺫﻟﻙ ﻋﻥ‬
‫ﻁﺭﻴﻕ ﺘﻌﺩﻴل ﺍﻟﺸﺭﻁ ﺍﻟﺴﺎﺒﻕ ﺒﺎﻟﺸﻜل ‪ Where GoFrom = :ParamName‬ﺤﻴﺙ ‪ ParamName‬ﻭﺴﻴﻁ ﻟﻠﻌﻨـﺼﺭ‬
‫‪ Query‬ﻴﻌﻁﻰ ﻗﻴﻤﺔ ﻤﺎ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ‪.‬‬
‫ﻤﺜﺎل ‪ :‬ﺇﺤﻀﺎﺭ ﻤﻌﻠﻭﻤﺎﺕ ﻤﻥ ﺠﺩﻭل ﺍﻟﺭﺤﻼﺕ ﻋﻥ ﺍﻟﺭﺤﻼﺕ ﺍﻟﻤﻐﺎﺩﺭﺓ ﻤﻥ ﺒﻠﺩ ﻴﺤﺩﺩﻩ ﺍﻟﻤﺴﺘﺨﺩﻡ ‪:‬‬
‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﻋﻨﺼﺭ ‪ Query‬ﻭ ﻋﻨﺼﺭ ‪ DataSource‬ﻭ ﻋﻨﺼﺭ ‪ DBGrid‬ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﻋﻨـﺼﺭ‬
‫‪ Edit‬ﻭ ﺯﺭ ‪Button‬‬
‫ﺍﺭﺒﻁ ﺍﻟﻌﻨﺎﺼﺭ ﻤﻊ ﺒﻌﻀﻬﺎ ﻜﺎﻟﻌﺎﺩﺓ ‪ ...‬ﻭﺍﻜﺘﺏ ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ SQL‬ﻟﻠﻌﻨﺼﺭ ‪Query1‬‬
‫‪SELECT Company, TripNo, GoFrom, ArriveTo, GoTime, ArriveTime, CardCount‬‬
‫‪FROM Trips‬‬
‫‪Where GoFrom =:CityName‬‬
‫ﺤﻴﺙ ‪ CityName‬ﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻥ ﻭﺴﻴﻁ ﺴﺘﻤﺭﺭ ﻗﻴﻤﺘﻪ ﺇﻟﻰ ﺍﻟﻌﻨﺼﺭ ‪ Query1‬ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ) ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ‬
‫‪. ( Button1‬‬
‫ﺤﺩﺩ ﺍﻟﺨﺎﺼﺔ ‪ Params‬ﻟﻠﻌﻨﺼﺭ ‪ Query1‬ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﻤﻨﻘﻁ ‪ ...‬ﻟﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ‪، Edit Query1.Params‬‬
‫ﺤﺩﺩ ﺍﻟﻭﺴﻴﻁ ‪ CityName‬ﻤﻥ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﻟﺘﻅﻬﺭ ﺨﻭﺍﺼﻪ ﻓﻲ ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ﻭﻤﻥ ﺜﻡ ﻏﻴﺭ ﺍﻟﺨﺎﺼـﺔ ‪Data Type‬‬
‫ﺇﻟﻰ ﺍﻟﻘﻴﻤﺔ ‪. ftString‬‬
‫ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Button1‬ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫;‪query1.Close‬‬
‫;‪query1.ParamByName('cityName').Value := edit1.Text‬‬
‫‪query1.Open‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﻜﺘﺏ ﻓﻲ ﺍﻟﻌﻨﺼﺭ ‪ Edit1‬ﺍﺴﻡ ﺍﻟﺒﻠﺩ ﺍﻟﺫﻱ ﺘﺭﻴﺩ ) ﺤﻠﺏ ‪ ،‬ﺩﻤﺸﻕ ‪ ( ...‬ﻭﺍﻀﻐﻁ ﻋﻠـﻰ ﺍﻟـﺯﺭ ﻟﻴﺤـﻀﺭ‬
‫ﺍﻻﺴﺘﻌﻼﻡ ﺠﻤﻴﻊ ﺍﻟﺭﺤﻼﺕ ﺍﻟﻤﻐﺎﺩﺭﺓ ﻤﻥ ﻫﺫﺍ ﺍﻟﺒﻠﺩ ‪.‬‬
‫ﻤﺜﺎل ‪: 2‬‬
‫ﻴﻤﻜﻨﻙ ﺍﻻﺴﺘﻌﻼﻡ ﻋﻥ ﺭﻗﻡ ﺍﻟﺭﺤﻠﺔ ﺒﺸﻜل ﺩﻴﻨﺎﻤﻴﻜﻲ ﻋﻥ ﻁﺭﻴﻕ ﺍﻻﺴﺘﻔﺴﺎﺭ ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫‪SELECT Company, TripNo, GoFrom, ArriveTo, GoTime, ArriveTime, CardCount‬‬
‫‪FROM Trips‬‬
‫‪126‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫; ‪Where TripNo =: TripNumber‬‬
‫ﻓﻲ ﺍﻟﻨﺎﻓﺫﺓ ‪ Edit Query1.Params‬ﺤﺩﺩ ﺍﻟﻭﺴﻴﻁ ‪ TripNumber‬ﻭﻏﻴﺭ ﺍﻟﺨﺎﺼﺔ ‪ DataType‬ﺇﻟﻰ ‪. ftInteger‬‬
‫ﻭﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪query1.Close‬‬
‫; )‪query1.ParamByName('TripNumber').Value := strtoint (edit1.Text‬‬
‫; ‪query1.Open‬‬
‫ﻤﻼﺤﻅﺔ ‪:‬‬
‫‪ SQL Builder‬ﻻ ﻴﺩﻋﻡ ﺍﻟﻭﺴﻁﺎﺀ ‪ ، Parameter‬ﻭﻻ ﻴﻤﻜﻥ ﻓﺘﺢ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒﻌﺩ ﺇﻀﺎﻓﺔ ﻭﺴﻴﻁ ﺇﻟﻰ ﻋﺒﺎﺭﺓ ‪ SQL‬ﻭﺇﺫﺍ‬
‫ﺃﺭﺩﺕ ﺍﻟﺘﻌﺩﻴل ﻓﻲ ﺍﻟﻌﺒﺎﺭﺓ ﻓﻌﻠﻴﻙ ﺤﺫﻑ ﺍﻟﻭﺴﻴﻁ ﻭﺍﻟﺩﺨﻭل ﺇﻟﻰ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪ SQL Builder‬ﻭﻤﻥ ﺜﻡ ﺇﻋﺎﺩﺓ ﺍﻟﻭﺴﻴﻁ ﻋﻨﺩ‬
‫ﺍﻟﺨﺭﻭﺝ ﻤﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪.‬‬
‫ﻤﻨﺎﻫﺞ ﺍﻟﻌﻨﺼﺭ ‪: Query‬‬
‫ﺠﻤﻴﻊ ﺍﻟﻤﻨﺎﻫﺞ ﺍﻟﺘﻲ ﺍﺴﺘﺨﺩﻤﻨﺎﻫﺎ ﻤﻊ ﺍﻟﻌﻨﺼﺭ ‪ Table‬ﻴﻤﻜﻥ ﺍﺴـﺘﺨﺩﺍﻤﻬﺎ ﻤـﻊ ﺍﻟﻌﻨـﺼﺭ ‪ Query‬ﻤﺜـل ) ‪ Locate‬ﻭ‬
‫ـﺙ ‪ FindKey‬ﻭ‬
‫ـﻠﻭﺒﻲ ﺍﻟﺒﺤـ‬
‫ـﺴﺘﺨﺩﻡ ﺍﺴـ‬
‫ـﺼﺭ ‪ Query‬ﻻ ﻴـ‬
‫‪ Lookup‬ﻭ ‪ Bof‬ﻭ ‪ Eof‬ﻭ ‪ ( .... First‬ﺇﻻ ﺃﻥ ﺍﻟﻌﻨـ‬
‫‪ FindNearest‬ﻭﺫﻟﻙ ﻷﻥ ﺍﻟﺠﺩﺍﻭل ﺍﻟﺘﻲ ﻴﻌﻴﺩﻫﺎ ﺍﻟﻌﻨﺼﺭ ‪ Query‬ﻻ ﺘﻌﺘﻤﺩ ﻋﻠﻰ ﻤﻔﺘﺎﺡ ﺃﺴﺎﺴﻲ ‪..‬‬
‫ﻤﺜﺎل ﻫﺎﻡ ‪:‬‬
‫ﻟﻴﻜﻥ ﻗﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﻟﺸﺭﻜﺔ ﻤﺎ ‪ Company‬ﻭﻟﻴﻜﻥ ﻟﺩﻴﻨﺎ ﺠﺩﻭل ﺍﻟﻤﻭﻅﻔﻴﻥ ‪ Employees‬ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫ﺍﻟﺭﺍﺘﺏ‬ ‫ﺘﺎﺭﻴﺦ ﺍﻟﻤﺒﺎﺸﺭﺓ‬ ‫ﺭﻗﻡ ﺍﻟﻔﺭﻉ‬ ‫ﺭﻗﻡ ﺍﻟﻤﺩﻴﺭ‬ ‫ﺍﺴﻡ ﺍﻟﻤﻭﻅﻑ‬ ‫ﺭﻗﻡ‬
‫‪Salary‬‬ ‫‪Hiredate‬‬ ‫‪Department_id‬‬ ‫‪ManagerNo‬‬ ‫‪EmpName‬‬ ‫ﺍﻟﻤﻭﻅﻑ‬
‫‪EmpNo‬‬
‫‪9000‬‬ ‫‪10/1/2002‬‬ ‫‪3‬‬ ‫‪200‬‬ ‫‪Sara‬‬ ‫‪10‬‬
‫‪12500‬‬ ‫‪06/08/2000‬‬ ‫‪2‬‬ ‫‪300‬‬ ‫‪kala‬‬ ‫‪16‬‬
‫‪11000‬‬ ‫‪09/01/2001‬‬ ‫‪3‬‬ ‫‪100‬‬ ‫‪Dani‬‬ ‫‪20‬‬
‫‪14000‬‬ ‫‪05/07/2000‬‬ ‫‪2‬‬ ‫‪100‬‬ ‫‪Wleed‬‬ ‫‪30‬‬
‫ﺃﻨﺸﺊ ﻫﺫﺍ ﺍﻟﺠﺩﻭل ﺒﺎﺴﺘﺨﺩﺍﻡ ‪ Database Desktop‬ﻭﺃﺩﺨل ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻟﻴﻪ ‪:‬‬

‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﻼﺯﻤﺔ ﻜﻤﺎ ﻓﻲ ﺍﻟﺸﻜل ‪:‬‬

‫‪127‬‬
http://www.alshater.net ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬

‫ ﻤـﻊ ﺍل‬DataSource ‫ ﻭﺴﻨﻘﻭﻡ ﺒﺭﺒﻁ‬DataSource ‫ ﻤﻊ ﺍﻟﻌﻨﺼﺭ‬DBNavigator ‫ ﻭ‬DBGrid ‫ﺃﺭﺒﻁ ﺍﻟﻌﻨﺼﺭﻴﻥ‬

. ‫ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ‬Query
: ‫ ﻟﻜل ﻤﻨﻬﺎ‬SQL ‫ ﻭﻓﻴﻤﺎ ﻴﻠﻲ ﺘﻌﻠﻴﻤﺎﺕ‬Query ‫ﻜﻤﺎ ﺘﻼﺤﻅ ﻟﺩﻴﻨﺎ ﺴﺕ ﻋﻨﺎﺼﺭ‬
‫ ﻭ ﺍﻜﺘـﺏ‬QryEmpNo ‫ ﺍﻟﻘﻴﻤـﺔ‬Query1 ‫ ﻟﻠﻌﻨـﺼﺭ‬Name ‫ ﺃﻋﻁ ﺍﻟﺨﺎﺼـﺔ‬: ‫ ـ ﺍﺴﺘﻌﻼﻡ ﺍﻟﺒﺤﺙ ﻋﻥ ﻤﻭﻅﻑ‬1
: SQL ‫ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺍﻟﺨﺎﺼﺔ‬
Select * from employees Where EmpNo = : No
‫ ﻭﻜﺘﺏ ﻓﻲ‬QryEmpName ‫ ﺍﻟﻘﻴﻤﺔ‬Query2 ‫ ﻟﻠﻌﻨﺼﺭ‬Name ‫ﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ‬: ‫ ـ ﺍﺴﺘﻌﻼﻡ ﺍﻟﺒﺤﺙ ﻋﻥ ﺍﺴﻡ ﻤﻭﻅﻑ‬2
: SQl
Select * from employees Where EmpName =:name
‫ ﺍﻟﻘﻴﻤـﺔ‬Query3 ‫ ﻟﻠﻌﻨـﺼﺭ‬Name ‫ ) ﻴﻌﻁﻲ ﺍﻟﺭﻭﺍﺘﺏ ﺍﻟﺘﻲ ﺒﻴﻥ ﻗﻴﻤﺘﻴﻥ ( ﺃﻋﻁ ﺍﻟﺨﺎﺼـﺔ‬: ‫ ـ ﺍﺴﺘﻌﻼﻡ ﺍﻟﺭﻭﺍﺘﺏ‬3
... QrySal
Select * from Employees Where salary between :mn and :mx
QryHireDate ‫ ﺍﻟﻘﻴﻤﺔ‬Query4 ‫ ﻟﻠﻌﻨﺼﺭ‬Name ‫ ﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ‬: ‫ ـ ﺍﺴﺘﻌﻼﻡ ﺘﺎﺭﻴﺦ ﺍﻟﻤﺒﺎﺸﺭﺓ‬4
Select * from Employees Where hiredate between :b and :e
‫ ﺍﻟﻘﻴﻤـﺔ‬Query5 ‫ ﻟﻠﻌﻨـﺼﺭ‬Name ‫ ﺃﻋـﻁ ﺍﻟﺨﺎﺼـﺔ‬:‫ ـ ﺍﺴﺘﻌﻼﻡ ﺤﺴﺎﺏ ﻤﺠﻤﻭﻉ ﺍﻟﺭﻭﺍﺘـﺏ ﻓـﻲ ﻜـل ﻗـﺴﻡ‬5
QrysumsalaryByDepartment
Select Department_id ,sum(salary ) form employees
Group by DepartMent_id

128
http://www.alshater.net ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ ﺍﻟﻘﻴﻤـﺔ‬Query6 ‫ ﻟﻠﻌﻨـﺼﺭ‬Name ‫ ﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ‬: ‫ ـ ﺍﺴﺘﻌﻼﻡ ﺍﻟﺒﺤﺙ ﻋﻥ ﺍﻟﻤﻭﻅﻔﻴﻥ ﺍﻟﺫﻴﻥ ﻴﺘﺒﻌﻭﻥ ﻟﻤﺩﻴﺭ ﻤﻌﻴﻥ‬6
QryManager:
Select Empname From employees Where managerNo = :mno
: ‫ﻭﻓﻴﻤﺎ ﻴﻠﻲ ﻨﺴﺘﻌﺭﺽ ﺃﺤﺩﺍﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻷﺯﺭﺍﺭ‬
( ‫ ـ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ) ﺒﺤﺙ ﻋﻥ ﺍﺴﻡ ﺍﻟﻤﻭﻅﻑ‬1
QryEmpNo.Close;
DataSource1.DataSet := QryEmpNo ;
QryEmpNo.ParamByName ( 'No') .value := Strtoint ( Edit1.text ) ;
QryEmpNo.Open;
: ( ‫ﺍﻟﺯﺭ ) ﺍﺒﺤﺙ ﻋﻥ ﺍﺴﻡ ﺍﻟﻤﻭﻅﻑ‬ ‫ ـ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ‬2
QryEmpName.Close ;
DataSource1.DataSat := QryEmpName ;
QryEmpName.ParamesByName ( 'Name').Value := Edit2.text ;
QryEmpName.Open ;
( ‫ﺍﻟﺯﺭ ) ﺍﺴﺘﻌﻼﻡ ﺍﻟﺭﻭﺍﺘﺏ‬ ‫ ـ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ‬3
QrySal.Close ;
DataSource1.DataSat := QrySal ;
QrySal.ParamByName( ' mn') .Value := strtoint ( edit3.text ) ;
QrySal.ParamByName( ' mx') .Value := strtoint ( edit4.text ) ;
QrySal.Open ;
: ( ‫ﺍﻟﺯﺭ ) ﺍﺴﺘﻌﻼﻡ ﺍﻟﺘﺎﺭﻴﺦ‬ ‫ ـ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ‬4
QryHireDate.Close ;
DataSource1.DataSat := QryHireDate;
QryHireDate.ParamByName ( 'b').asdate := datetimepicker1.date;
QryHireDate.ParamByName ( 'e').asdate := datetimepicker2.date;
QryHireDate.Open ;
: ( ‫) ﻤﺠﻤﻭﻉ ﺍﻟﺭﻭﺍﺘﺏ ﻓﻲ ﻜل ﻗﺴﻡ‬ ‫ ـ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ‬5
QrysumsalaryByDepartment.Close ;
DataSource1.DataSat := QrysumsalaryByDepartment;
QrysumsalaryByDepartment.Open ;
: ( ‫ﺍﻟﺯﺭ ) ﻤﻭﻅﻔﻲ ﺍﻟﻤﺩﻴﺭ‬ ‫ ـ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ‬6

QryManager.Close ;
DataSource1.DataSat := QryManager;
QryManager.ParamByName ( 'mno').Value := strtoint ( Edit5.text ) ;
QryManager.Open ;
While not QryManager.eof Do
Begin
Showmessage (QryManager.fieldByName ('EmpName').Value ) ;
QryManager.Next ;
End;

129
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺴﻴﻅﻬﺭ ﻫﺫﺍ ﺍﻟﺤﺩﺙ ﺍﺴﻡ ﺃﻭل ﻤﻭﻅﻑ ﻴﺄﺘﻲ ﺒﻪ ﺍﻻﺴﺘﻌﻼﻡ ﻭﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ‪ Ok‬ﺴﻴﻅﻬﺭ ﺍﺴﻡ ﺍﻟﻤﻭﻅﻑ ﺍﻟﺘﺎﻟﻲ ﻭﻫﻜﺫﺍ ‪.‬‬

‫‪130‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ‪21‬‬

‫ﺇﻨﺸﺎﺀ ﺍﻟﺠﺩﺍﻭل ﺒﺒﺭﻨﺎﻤﺞ ‪:Access‬‬

‫ﺍﻓﺘﺢ ﺒﺭﻨﺎﻤﺞ ‪) Access XP‬ﻭﻫﻭ ﺃﺤﺩ ﺘﻁﺒﻴﻘﺎﺕ ‪ - ،(Microsoft Office XP‬ﻴﻤﻜﻥ ﺍﺴﺘﺨﺩﺍﻡ ‪ office 2003‬ﻓـﻼ‬
‫ﻑ ﺠﺩﻴﺩ" ‪ New File‬ﻓﻲ‬
‫ﻑ" ‪ File‬ﺍﺨﺘﺭ "ﺠﺩﻴﺩ" ‪ ..New‬ﺴﺘﻅﻬﺭ ﻟﻙ ﻨﺎﻓﺫﺓ "ﻤﻠ ﹼ‬
‫ﻴﺨﺘﻠﻑ ﺍﻷﻤﺭ ﻜﺜﻴﺭﹰﺍ ‪ -‬ﻭﻤﻥ ﻗﺎﺌﻤﺔ "ﻤﻠ ﹼ‬
‫ﺠﺎﻨﺏ ﻭﺍﺠﻬﺔ ﺍﻟﺘﻁﺒﻴﻕ ﻜﻤﺎ ﻓﻲ ﺍﻟﺼﻭﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬

‫ﻑ" ﻴﻁﻠﺏ ﻤﻨﻙ ﺘﺤﺩﻴﺩ ﺍﺴﻡ‬

‫ﺘﺤﺕ ﺸﺭﻴﻁ "ﺠﺩﻴﺩ" ﺍﻀﻐﻁ ﺍﻷﻤﺭ "ﻗﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﻓﺎﺭﻏﺔ"‪ ..‬ﺴﻴﻅﻬﺭ ﻟﻙ ﻤﺭﺒ‪‬ﻊ ﺤﻭﺍﺭ "ﺤﻔﻅ ﻤﻠ ﹼ‬
‫ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻤﻭﻗﻊ ﺤﻔﻅﻬﺎ ﻋﻠﻰ ﺍﻟﺠﻬﺎﺯ‪ ..‬ﻏﻴ‪‬ﺭ ﺍﺴﻡ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ ﺍﻻﺴﻡ ﺍﻻﻓﺘﺭﺍﻀﻲ ﺇﻟﻰ "‪ ،"Books.mdb‬ﻭﻗﻡ‬
‫ﺒﺤﻔﻅﻬﺎ ﻓﻲ ﺍﻟﻤﻭﻀﻊ ﺍﻟﺫﻱ ﺘﺭﻴﺩﻩ‪.‬‬

‫ﻤﻼﺤﻅﺎﺕ ‪:‬‬
‫ﺘﺨﺯﻥ ﻗﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﺃﻜﺴﻴﺱ ﻓﻲ ﻤﻠﻑ ﻭﺍﺤﺩ ﻤﻥ ﺍﻤﺘﺩﺍﺩ ‪ .Mdb‬ﻋﻠﻰ ﻋﻜﺱ ﻗﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﺒﺎﺭﺩﻭﻜﺱ ﺍﻟﺘﻲ ﺘﻌﺘﻤﺩ ﻤﻠﻑ‬
‫ﻤﺴﺘﻘل ﻟﻜل ﺠﺩﻭل ﺃﻭ ﻓﻬﺭﺱ ‪....‬‬
‫ﻟﻴﺴﺕ ﻫﻨﺎﻙ ﺍﺨﺘﻼﻓﺎﺕ ﻜﺒﻴﺭﺓ ﺒﻴﻥ ‪ Access XP‬ﻭ ‪ Access 2000‬ﻭ ‪ Access 97‬ﻓﻴﻤﺎ ﻴﺘﻌﻠﹼﻕ ﺒﺈﻨﺸﺎﺀ ﺍﻟﺠﺩﺍﻭل‪ ،‬ﻟﻬﺫﺍ‬
‫ﻱ ﻤﻥ ﻫﺫﻩ ﺍﻟﻨﺴﺦ‪.‬‬
‫ﻴﻤﻜﻨﻙ ﺃﻥ ﺘﺘﺒﻊ ﻤﻌﻨﺎ ﻫﺫﻩ ﺍﻟﺨﻁﻭﺍﺕ ﻋﻠﻰ ﺃ ‪‬‬

‫ﺒﻌﺩ ﺇﻏﻼﻕ ﻤﺭﺒ‪‬ﻊ ﺍﻟﺤﻭﺍﺭ ﺴﺘﻅﻬﺭ ﻟﻙ ﻨﺎﻓﺫﺓ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻜﻤـﺎ‬

‫ﻓﻲ ﺍﻟﺼﻭﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬

‫‪131‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬

‫ﺍﻨﻘﺭ ﺍﻷﻤﺭ "ﺇﻨﺸﺎﺀ ﺠﺩﻭل ﻓﻲ ﻁﺭﻴﻘﺔ ﻋﺭﺽ ﺍﻟﺘﺼﻤﻴﻡ" ﻤﺭ‪‬ﺘﻴﻥ ﺒﺎﻟﻔﺄﺭﺓ‪ ..‬ﺴﺘﻅﻬﺭ ﻟﻙ ﻨﺎﻓﺫﺓ ﺘﺼﻤﻴﻡ ﺍﻟﺠـﺩﻭل ﻜﻤـﺎ ﻓـﻲ‬
‫ﺍﻟﺼﻭﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬

‫ل ﻨﺒﺩﺃ ﺒﺘﺼﻤﻴﻡ ﺠـﺩﻭل ﺃﺴـﻤﺎﺀ‬

‫ل ﻤﻨﻬﺎ‪ ..‬ﺘﻌﺎ َ‬
‫ل ﻤﺎ ﻋﻠﻴﻙ ﻫﻭ ﻜﺘﺎﺒﺔ ﺃﺴﻤﺎﺀ ﺍﻟﺤﻘﻭل ﻭﺘﺤﺩﻴﺩ ﻨﻭﻋﻴ‪‬ﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﻜ ّ‬
‫ﺍﻵﻥ ﻜ ّ‬
‫ﺍﻟﻤﺅﻟﹼﻔﻴﻥ‪ ..‬ﻫﺫﺍ ﺍﻟﺠﺩﻭل ﺴﻴﺘﻜﻭ‪‬ﻥ ﻤﻥ ﺍﻟﻌﻤﻭﺩﻴﻥ ﺍﻟﺘﺎﻟﻴﻴﻥ‪:‬‬
‫ﺍﻟﻭﺼﻑ‬ ‫ﻨﻭﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ‬ ‫ﺍﺴﻡ ﺍﻟﺤﻘل‬
‫ﻲ ﻟﻬﺫﺍ ﺍﻟﺠﺩﻭل‬
‫ﺍﻟﻤﻔﺘﺎﺡ ﺍﻟﺭﺌﻴﺴ ‪‬‬ ‫ﺘﺭﻗﻴﻡ ﺘﻠﻘﺎﺌﻲ‬ ‫‪ID‬‬
‫ﺍﺴﻡ ﺍﻟﻤﺅﻟﹼﻑ‬ ‫ﻨﺹ‬ ‫‪Author‬‬

‫ﻱ ﺍﻟﻤﻭﺠﻭﺩ ﻋﻠﻰ ﻴﻤﻴﻥ ﺍﻟﺤﻘـل ‪ ،ID‬ﻭﻤـﻥ‬

‫ﺒﻌﺩ ﺃﻥ ﺘﻨﺸﺊ ﻫﺫﻩ ﺍﻷﻋﻤﺩﺓ‪ ،‬ﺍﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻷﻴﻤﻥ ﻋﻠﻰ ﺍﻟﻤﺭﺒ‪‬ﻊ ﺍﻟﺭﻤﺎﺩ ‪‬‬
‫ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﻤﻭﻀﻌﻴ‪‬ﺔ ﺍﻀﻐﻁ "ﻤﻔﺘﺎﺡ ﺃﺴﺎﺴﻲ" ﻭﺫﻟﻙ ﻟﺠﻌل ﻫﺫﺍ ﺍﻟﺤﻘل ﻤﻔﺘﺎﺤﺎ ﺃﺴﺎﺴﻴ‪‬ﺎ ﻟﻠﺠﺩﻭل‪.‬‬
‫ﻥ ﺨﺎﺼﻴ‪‬ﺔ "ﻤﻔﻬﺭﺱ" ‪ Indexed‬ﻓﻲ ﺍﻟﻤﻨﻁﻘﺔ ﺍﻟـﺴﻔﻠﻰ‬
‫ﺴﺘﻼﺤﻅ ﻅﻬﻭﺭ ﺭﻤﺯ ﺍﻟﻤﻔﺘﺎﺡ ﺃﻤﺎﻡ ﻫﺫﺍ ﺍﻟﺤﻘل‪ ..‬ﺴﺘﻼﺤﻅ ﻜﺫﻟﻙ ﺃ ‪‬‬
‫ﻲ ﻏﻴﺭ ﻗﺎﺒﻠﺔ ﻟﻠﺘﻜﺭﺍﺭ‪.‬‬
‫ﻥ ﻗﻴﻡ ﺍﻟﻤﻔﺘﺎﺡ ﺍﻷﺴﺎﺴ ‪‬‬
‫ﻤﻥ ﺍﻟﻨﺎﻓﺫﺓ ﺴﺘﺘﺤﻭ‪‬ل ﺇﻟﻰ "ﻨﻌﻡ ﺒﺩﻭﻥ ﺘﻜﺭﺍﺭ"‪ ،‬ﻭﻫﻭ ﺸﻲﺀ ﻤﺘﻭﻗﹼﻊ‪ ،‬ﻓﻠﻘﺩ ﺍﺘﻔﻘﹼﻨﺎ ﺃ ‪‬‬
‫ﺸﻲ ‪‬ﺀ ﺁﺨﺭ‪ ..‬ﺍﻀﻐﻁ ﺒﺎﻟﻔﺄﺭﺓ ﻋﻠﻰ ﺤﻘل ﺍﺴﻡ ﺍﻟﻤﺅﻟﹼﻑ ‪ ،Author‬ﻭﻓﻲ ﺍﻟﻤﻨﻁﻘﺔ ﺍﻟﺴﻔﻠﻰ ﻤﻥ ﺍﻟﻨﺎﻓﺫﺓ ﻏﻴ‪‬ﺭ ﻗﻴﻤـﺔ ﺨﺎﺼـﻴ‪‬ﺔ‬
‫"ﺤﺠﻡ ﺍﻟﺤﻘل" ﺇﻟﻰ ‪ 30‬ﺒﺩﻻ ﻤﻥ ‪ ،50‬ﺒﺎﻓﺘﺭﺍﺽ ﺃﻥ ﺃﻁﻭل ﺍﺴﻡ ﻟﻤﺅﻟﹼﻑ ﻟﻥ ﻴﺯﻴﺩ ﻋﻥ ‪ 20‬ﺤﺭﻓﺎ‪.‬‬
‫ﺍﻵﻥ ﺍﻀﻐﻁ ‪ Ctrl+S‬ﻟﺤﻔﻅ ﺍﻟﺠﺩﻭل‪ ..‬ﺴﻴﻅﻬﺭ ﻟﻙ ﻤﺭﺒ‪‬ﻊ ﺇﺩﺨﺎل ﻴﻁﺎﻟﺒﻙ ﺒﺈﺩﺨـﺎل ﺍﺴـﻡ ﺍﻟﺠـﺩﻭل‪ ..‬ﺴـﻤ‪‬ﻪ ‪Authors‬‬
‫ﻭﺍﻀﻐﻁ ﺯﺭ ‪.OK‬‬
‫ﻤﻠﺤﻭﻅﺔ‪:‬‬
‫ﻥ ﻫﺫﻩ ﺍﻷﺴﻤﺎﺀ ﺴﺘﺩﺨل ﻓﻲ ﻜﺘﺎﺒﺔ ﺍﻟﻜﻭﺩ ﻓﻲ ‪ ،VB‬ﻭﺴﻴﻜﻭﻥ ﻤﻥ ﺍﻟﻤﺭﻫﻕ‬
‫ﺴ ‪‬ﻡ ﺍﻟﺠﺩﺍﻭل ﻭﺍﻷﻋﻤﺩﺓ ﺒﺄﺴﻤﺎﺀ ﺃﺠﻨﺒﻴ‪‬ﺔ‪ ،‬ﻭﺫﻟﻙ ﻷ ‪‬‬
‫ﺍﻻﻨﺘﻘﺎل ﻤﻥ ﺍﻹﻨﺠﻠﻴﺯﻴﺔ ﺇﻟﻰ ﺍﻟﻌﺭﺒﻴ‪‬ﺔ ﻭﺍﻟﻌﻜﺱ ﺃﻜﺜﺭ ﻤﻥ ﻤﺭ‪‬ﺓ ﺃﺜﻨﺎﺀ ﻜﺘﺎﺒﺔ ﺍﻟﻜﻭﺩ‪.‬‬

‫‪132‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻥ ﺍﻟﺠﺩﻭل ‪ Authors‬ﻗﺩ ﺃﻀﻴﻑ ﺇﻟﻰ ﻨﺎﻓﺫﺓ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨـﺎﺕ‪ ..‬ﺍﻨﻘـﺭﻩ ﻤـﺭ‪‬ﺘﻴﻥ‬
‫ﺍﻵﻥ ﻟﻭ ﺃﻏﻠﻘﺕ ﻨﺎﻓﺫﺓ ﺍﻟﺘﺼﻤﻴﻡ‪ ،‬ﻓﺴﺘﺠﺩ ﺃ ‪‬‬
‫ﺒﺎﻟﻔﺄﺭﺓ‪ ..‬ﺴﺘﺠﺩ ﺃﻥ ﻨﺎﻓﺫﺓ ﺠﺩﻴﺩﺓ ﻗﺩ ﻓﺘﺤﺕ‪ ،‬ﺘﻌﺭﺽ ﻟﻙ ﺠﺩﻭل ﺍﻟﻤﺅﻟﹼﻔﻴﻥ‪ ..‬ﺃﺩﺨل ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬
‫ﺘﻭﻓﻴﻕ ﺍﻟﺤﻜﻴﻡ‬ ‫‪1‬‬
‫ﻋﺒﺎﺱ ﺍﻟﻌﻘﺎﺩ‬ ‫‪2‬‬
‫ﻤﺤﻤﺩ ﻋﺒﺩ ﺍﻟﺤﻠﻴﻡ ﻋﺒﺩ ﺍﷲ‬ ‫‪3‬‬
‫ﻨﺒﻴل ﻓﺎﺭﻭﻕ‬ ‫‪4‬‬
‫ﺃﺤﻤﺩ ﺨﺎﻟﺩ ﺘﻭﻓﻴﻕ‬ ‫‪5‬‬
‫ﻤﺤﻤﺩ ﺤﻤﺩﻱ ﻏﺎﻨﻡ‬ ‫‪6‬‬
‫ﻤﻨﺼﻭﺭ‬ ‫‪7‬‬
‫ﺭﺍﺘﺏ‬ ‫‪8‬‬
‫ﻋﻘل‬ ‫‪9‬‬

‫ﺒﻨﻔﺱ ﺍﻟﻁﺭﻴﻘﺔ ﺼﻤ‪‬ﻡ ﺠﺩﻭل ﺍﻟﻜﺘﺏ ﻜﺎﻟﺘﺎﻟﻲ‪:‬‬

‫ﺍﻟﻭﺼﻑ‬ ‫ﻨﻭﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ‬ ‫ﺍﺴﻡ ﺍﻟﺤﻘل‬

‫ﻲ ﻟﻬﺫﺍ ﺍﻟﺠﺩﻭل‪.‬‬
‫ﺍﻟﻤﻔﺘﺎﺡ ﺍﻟﺭﺌﻴﺴ ‪‬‬ ‫ﺘﺭﻗﻴﻡ ﺘﻠﻘﺎﺌﻲ‬ ‫‪ID‬‬
‫ﺍﺴﻡ ﺍﻟﻜﺘﺎﺏ‬ ‫ﻨﺹ‬ ‫‪Book‬‬
‫ﺭﻗﻡ ﺍﻟﻤﺅﻟﹼﻑ‬ ‫ﻨﺹ‬ ‫‪AuthorID‬‬

‫ﺍﺤﻔﻅ ﻫﺫﺍ ﺍﻟﺠﺩﻭل ﺒﺎﺴﻡ ‪ ،Books‬ﻭﺃﺩﺨل ﻓﻴﻪ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬

‫‪AuthorID‬‬ ‫‪Book‬‬ ‫‪ID‬‬

‫‪1‬‬ ‫ﺃﺭﻨﻲ ﺍﷲ‬ ‫‪1‬‬
‫‪1‬‬ ‫ﻴﻭﻤﻴّﺎﺕ ﻨﺎﺌﺏ ﻓﻲ ﺍﻷﺭﻴﺎﻑ‬ ‫‪2‬‬
‫‪1‬‬ ‫ﻋﺼﺎ ﺍﻟﺤﻜﻴﻡ‬ ‫‪3‬‬
‫‪2‬‬ ‫ﺴﺎﺭﺓ‬ ‫‪4‬‬
‫‪2‬‬ ‫ﻋﺒﻘﺭﻴﺔ ﻤﺤﻤﺩ‬ ‫‪5‬‬
‫‪2‬‬ ‫ﻋﺒﻘﺭﻴﺔ ﻋﻤﺭ‬ ‫‪6‬‬
‫‪3‬‬ ‫ﺸﺠﺭﺓ ﺍﻟﻠﺒﻼﺏ‬ ‫‪7‬‬
‫‪4‬‬ ‫ﻤﻬﻨﺘﻲ ﺍﻟﻘﺘل‬ ‫‪8‬‬
‫‪4‬‬ ‫ﺍﻷﻓﻕ ﺍﻷﺨﻀﺭ‬ ‫‪9‬‬
‫‪133‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪5‬‬ ‫ﺃﺴﻁﻭﺭﺓ ﺍﻟﻐﺭﺒﺎﺀ‬ ‫‪10‬‬
‫‪5‬‬ ‫ﺍﻟﻌﺎﺸﺭ‬ ‫‪11‬‬
‫‪5‬‬ ‫ﻻ ﺘﺩﺨﻠﻭﺍ ﺸﻴﺭﻭﺩ‬ ‫‪12‬‬
‫‪6‬‬ ‫ﻤﺠﺭﺩ ﻁﺭﻴﻘﺔ ﻟﻠﺘﻔﻜﻴﺭ‬ ‫‪13‬‬
‫‪6‬‬ ‫ﺤﺎﺌﺭﺓ ﻓﻲ ﺍﻟﺤﺏ‬ ‫‪14‬‬
‫‪6‬‬ ‫ﺒﻴﻥ ﻗﻭﺴﻴﻥ ﻤﻥ ﺍﻟﺨﻠﻭﺩ‬ ‫‪15‬‬
‫‪7‬‬ ‫ﺤﻴﺎﺘﻲ‬ ‫‪16‬‬
‫‪8‬‬ ‫ﺤﻴﺎﺘﻲ‬ ‫‪17‬‬
‫‪9‬‬ ‫ﺤﻴﺎﺘﻲ‬ ‫‪18‬‬
‫ﺇﻨﺸﺎﺀ ﻋﻼﻗﺔ ﺒﻴﻥ ﺠﺩﻭﻟﻲ ﺍﻟﻤﺅﻟﹼﻔﻴﻥ ﻭﺍﻟﻜﺘﺏ‪:‬‬
‫‪Referential‬‬ ‫ﻲ‬
‫ﺃﻋﺘﻘﺩ ﺃﻨﹼﻙ ﻤﺘﺸﻭ‪‬ﻕ ﻟﻤﻌﺭﻓﺔ ﻜﻴﻔﻴ‪‬ﺔ ﺭﺒﻁ ﺤﻘﻠﻲ ﺭﻗﻡ ﺍﻟﻤﺅﻟﹼﻑ ﺒﻴﻥ ﺍﻟﺠﺩﻭﻟﻴﻥ ﻟﺘﺤﻘﻴﻕ ﺍﻟﺘﻜﺎﻤـل ﺍﻟﻤﺭﺠﻌـ ‪‬‬
‫‪ Integration‬ﺒﻴﻥ ﺍﻟﺠﺩﻭﻟﻴﻥ‪ ..‬ﺴﺘﺠﺩ ﺍﻷﻤﺭ ﻏﺎﻴ ﹰﺔ ﻓﻲ ﺍﻟﺒﺴﺎﻁﺔ‪:‬‬
‫ﻤﻥ ﻗﺎﺌﻤﺔ ﺃﺩﻭﺍﺕ ‪ Tools‬ﺍﻀﻐﻁ ﺍﻷﻤﺭ "ﻋﻼﻗﺎﺕ" ‪ ..Relationships‬ﺴﺘﻅﻬﺭ ﻟﻙ ﻨﺎﻓﺫﺓ "ﺇﻅﻬﺎﺭ ﺠﺩﻭل" ﺍﻟﻤﻭﻀ‪‬ﺤﺔ ﻓﻲ‬
‫ﺍﻟﺼﻭﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬

‫ل ﺠﺩﻭل ﻭﺍﻀﻐﻁ ﺯ ‪‬ﺭ "ﺇﻀﺎﻓﺔ"‪ ..‬ﺒﻌﺩ ﺃﻥ ﺘﻀﻴﻑ ﺍﻟﺠﺩﻭﻟﻴﻥ ﺃﻏﻠﻕ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ‪ ..‬ﺴـﺘﺒﺩﻭ ﻟـﻙ ﻨﺎﻓـﺫﺓ ﺍﻟﻌﻼﻗـﺎﺕ‬
‫ﺍﺨﺘﺭ ﻜ ّ‬
‫ﻜﺎﻟﺘﺎﻟﻲ‪:‬‬

‫‪134‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬

‫ل ﺠﺩﻭل ﻜﻤﺴﺘﻁﻴل ﻋﻠﻴﻪ ﻋﻨﻭﺍﻥ ﺍﻟﺠﺩﻭل‪ ،‬ﻭﺒﻪ ﺃﺴﻤﺎﺀ ﺃﻋﻤﺩﺘﻪ‪.‬‬

‫ﺤﻴﺙ ﻴﻅﻬﺭ ﻜ ّ‬
‫ﻭﻹﻨﺸﺎﺀ ﻋﻼﻗﺔ ﺒﻴﻥ ﺍﻟﺠﺩﻭﻟﻴﻥ‪ ،‬ﺍﺴﺤﺏ ﺤﻘل ‪ ID‬ﺒﺎﻟﻔﺄﺭﺓ ﻤﻥ ﺠﺩﻭل ﺍﻟﻤﺅﻟﹼﻔﻴﻥ‪ ،‬ﻭﺘﺤﺭ‪‬ﻙ ﺒﺎﻟﻔﺄﺭﺓ ﺇﻟﻰ ﺍﻟﺤﻘـل ‪AuthorID‬‬
‫ﻓﻲ ﺠﺩﻭل ﺍﻟﻜﺘﺏ‪ ..‬ﺴﺘﻼﺤﻅ ﺘﻐ ‪‬ﻴﺭ ﺸﻜل ﻤﺅﺸﹼﺭ ﺍﻟﻔـﺄﺭﺓ‪ ..‬ﺍﺘـﺭﻙ ﺯﺭ‬
‫ﺍﻟﻔﺄﺭﺓ ﺍﻷﻴﺴﺭ ﻓﻭﻕ ﻫﺫﺍ ﺍﻟﺤﻘل‪ ..‬ﻫﻨﺎ ﺴﺘﻅﻬﺭ ﻟﻙ ﻨﺎﻓﺫﺓ ‪:‬‬

‫ﺇﻨﺸﺎﺀ ﺍﻟﻌﻼﻗﺔ ﺒﻴﻥ ﺍﻟﺤﻘﻠﻴﻥ‪:‬‬

‫ﺍﻀﻐﻁ ﺍﺨﺘﻴﺎﺭ "ﻓﺭﺽ ﺍﻟﺘﻜﺎﻤل ﺍﻟﻤﺭﺠﻌـﻲ" ‪Enforce Referential‬‬
‫‪ ،Integrity‬ﻟﺘﻘﻭﻡ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺁﻟﻴ‪‬ﺎ ﺒﺎﻟﺘﺤﻘﹼﻕ ﻤﻥ ﺼﺤ‪‬ﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﻴﻥ‬
‫ﺍﻟﺠﺩﻭﻟﻴﻥ‪ ..‬ﻭﻓﻲ ﻫﺫﺍ ﺍﻟﺼﺩﺩ ﻟﺩﻴﻙ ﺍﺨﺘﻴﺎﺭﺍﻥ‪:‬‬
‫ﺘﺘﺎﻟﻲ ﺘﺤـﺩﻴﺙ ﺍﻟﺤﻘـﻭل ﺍﻟﻤﺭﺘﺒﻁـﺔ ‪Cascade Update Related‬‬
‫‪:Fields‬‬
‫ل‬
‫ﻓﻤﺜﻼ‪ ،‬ﻟﻭ ﻏﻴ‪‬ﺭﺕ ﺭﻗﻡ )ﺘﻭﻓﻴﻕ ﺍﻟﺤﻜﻴﻡ( ﻤﻥ ‪ 1‬ﺇﻟﻰ ‪ ،10‬ﻓﺴﻴﺘ ‪‬ﻡ ﺘﻐﻴﻴﺭ ﺭﻗﻡ ﺍﻟﻤﺅﻟﹼﻑ ‪ AuthorID‬ﺘﻠﻘﺎﺌﻴ‪‬ﺎ ﻓﻲ ﺴﺠﻼﺕ ﻜـ ّ‬
‫ﺍﻟﻜﺘﺏ ﺍﻟﺘﻲ ﺃﻟﹼﻔﻬﺎ ﺇﻟﻰ ‪.10‬‬
‫ﻲ‪ ..‬ﻭﻟﻭ ﺃﺭﺩﺕ ﺘﻐﻴﻴﺭﻩ‪ ،‬ﻓﻌﻠﻴـﻙ‬
‫ﻤﻠﺤﻭﻅﺔ‪:‬ﻟﻥ ﺘﺴﺘﻁﻴﻊ ﺘﻐﻴﻴﺭ ﻗﻴﻤﺔ ﺭﻗﻡ ﺍﻟﻤﺅﻟﹼﻑ ‪ ID‬ﻓﻲ ﺠﺩﻭل ﺍﻟﻤﺅﻟﹼﻔﻴﻥ‪ ،‬ﻷﻨﹼﻪ ﺘﺭﻗﻴﻡ ﺘﻠﻘﺎﺌ ‪‬‬
‫ﺒﺘﻐﻴﻴﺭ ﻨﻭﻉ ﺍﻟﺤﻘل ﻤﻥ ﺘﺭﻗﻴﻡ ﺘﻠﻘﺎﺌﻲ ﺇﻟﻰ ﺭﻗﻡ‪ ،‬ﻋﻠﻰ ﺃﻥ ﻴﻜﻭﻥ ﻫﺫﺍ ﻗﺒل ﺇﻨﺸﺎﺀ ﺍﻟﻌﻼﻗﺔ‪ ،‬ﻷﻨﹼﻪ ﻤﻥ ﻏﻴﺭ ﺍﻟﻤﺴﻤﻭﺡ ﺘﻐﻴﻴﺭ ﻨﻭﻉ‬
‫ﺒﻴﺎﻨﺎﺕ ﺤﻘل ﺩﺍﺨل ﻓﻲ ﻋﻼﻗﺔ‪.‬‬
‫ﺘﺘﺎﻟﻲ ﺤﺫﻑ ﺍﻟﺴﺠﻼﺕ ﺍﻟﻤﺭﺘﺒﻁﺔ ‪:Cascade Delete Related Fields‬‬

‫ل ﻜﺘﺏ )ﻨﺒﻴل ﻓﺎﺭﻭﻕ( ﺘﻠﻘﺎﺌﻴ‪‬ﺎ ﻤﻥ ﺠﺩﻭل ﺍﻟﻜﺘﺏ‪.‬‬

‫ل )ﻨﺒﻴل ﻓﺎﺭﻭﻕ( ﻤﻥ ﺠﺩﻭل ﺍﻟﻤﺅﻟﹼﻔﻴﻥ‪ ،‬ﻴﺘ ‪‬ﻡ ﺤﺫﻑ ﻜ ّ‬
‫ﻓﻤﺜﻼ‪ ،‬ﻟﻭ ﺤﺫﻓﺕ ﺴﺠ ّ‬
‫ﺍﻀﻐﻁ ﺯ ‪‬ﺭ "ﺇﻨﺸﺎﺀ" ﻹﻏﻼﻕ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ‪.‬‬
‫ﻁ ﻴﺭﺒﻁ ﺍﻟﺠﺩﻭﻟﻴﻥ ﻜﺎﻟﺘﺎﻟﻲ‪:‬‬
‫ﺍﻵﻥ ﺴﻴﻅﻬﺭ ﺨ ﹼ‬

‫ﻁ ﺒﺯ ‪‬ﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻷﻴﻤﻥ‪ ،‬ﻭﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﻤﻭﻀﻌﻴ‪‬ﺔ ﺍﺨﺘﺭ "ﺤﺫﻑ"‪.‬‬

‫ﻭﻟﻭ ﺃﺭﺩﺕ ﺤﺫﻑ ﻫﺫﻩ ﺍﻟﻌﻼﻗﺔ‪ ،‬ﻓﺎﻀﻐﻁ ﺍﻟﺨ ﹼ‬
‫ل‬
‫ﻗﻡ ﺒﺤﻔﻅ ﺍﻟﺘﻐﻴﻴﺭﺍﺕ‪ ،‬ﻭﺃﻏﻠﻕ ﻨﺎﻓﺫﺓ ﺍﻟﻌﻼﻗﺎﺕ‪ ..‬ﺍﻓﺘﺢ ﺍﻵﻥ ﺠﺩﻭل ﺍﻟﻤﺅﻟﹼﻔﻴﻥ‪ ..‬ﺴﺘﻼﺤﻅ ﻅﻬﻭﺭ ﻋﻼﻤـﺔ "‪ "+‬ﺒﺠـﻭﺍﺭ ﻜـ ّ‬
‫ﻥ ﺠـﺩﻭﻻ ﺼـﻐﻴﺭﺍ‬
‫ﻥ ﻋﻼﻤﺔ "‪ "+‬ﺘﺤﻭ‪‬ﻟﺕ ﺇﻟﻰ ﻋﻼﻤﺔ "‪ ،"-‬ﻭﺃ ‪‬‬
‫ﺤﻘل‪ ..‬ﺍﻀﻐﻁ ﺃﻴ‪‬ﺎ ﻤﻨﻬﺎ‪ ،‬ﻭﻟﻴﻜﻥ )ﺘﻭﻓﻴﻕ ﺍﻟﺤﻜﻴﻡ(‪ ..‬ﺴﺘﺠﺩ ﺃ ‪‬‬
‫ﻴﺤﺘﻭﻱ ﻋﻠﻰ ﺍﻟﻜﺘﺏ ﺍﻟﺘﻲ ﺃﻟﹼﻔﻬﺎ ﺘﻭﻓﻴﻕ ﺍﻟﺤﻜﻴﻡ ﻗﺩ ﻅﻬﺭ‪ ..‬ﻭﻹﺨﻔﺎﺌﻪ ﺜﺎﻨﻴ ﹰﺔ ﺃﻋﺩ ﻀﻐﻁ ﻋﻼﻤﺔ "‪."-‬‬

‫‪135‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬

‫ﻭﻴﻤﻜﻨﻙ ﺇﺩﺨﺎل ﺍﻟﻤﺯﻴﺩ ﻤﻥ ﻜﺘﺏ )ﺘﻭﻓﻴﻕ ﺍﻟﺤﻜﻴﻡ( ﻓﻲ ﻫﺫﺍ ﺍﻟﺠﺩﻭل ﺍﻟﻔﺭﻋﻲ‪ ،‬ﺩﻭﻥ ﺃﻥ ﺘﹸﺩﺨل ﺭﻗﻤﻪ ﻓﻲ ﺨﺎﻨﺔ ‪AuthorID‬‬
‫ل ﻤﺭ‪‬ﺓ‪ ،‬ﺇﺫ ﺴﺘﺘ ‪‬ﻡ ﻜﺘﺎﺒﺔ ﻫﺫﺍ ﺍﻟﺭﻗﻡ ﺁﻟﻴ‪‬ﺎ‪ ،‬ﻤﻤ‪‬ﺎ ﻴﻭﻓﹼﺭ ﻟﻙ ﺍﻟﻭﻗﺕ ﻭﻴﻌﻔﻴﻙ ﻤﻥ ﺍﺤﺘﻤﺎﻻﺕ ﺍﻟﺨﻁﺄ‪.‬‬
‫ﻓﻲ ﻜ ّ‬
‫ﺭﺒﻁ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺃﻜﺴﻴﺱ ﻤﻊ ﻋﻨﺎﺼﺭ ‪ BDE‬ﻓﻲ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ﺩﻟﻔﻲ ‪:‬‬
‫ﻭﺠﺩﻨﺎ ﺃﻨﻪ ﺘﻤﻜﻨﺎ ﻤﻥ ﺭﺒﻁ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ Paradox‬ﻤﻊ ﺍﻟﻌﻨﺼﺭ‬
‫‪ Table‬ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ DataBaseName‬ﻟﻠﻌﻨﺼﺭ ﻋﻥ ﻁﺭﻴﻕ ﺍﻻﺴﻡ‬
‫ﺍﻟﺒﺩﻴل ‪ Alias‬ﺍﻟﺫﻱ ﺘﻡ ﺇﻨﺸﺎﺌﻪ ﺒﻭﺍﺴﻁﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪Database‬‬
‫‪ Desktop‬ﻭﺍﻟﺴﺅﺍل ﺍﻟﻤﻁﺭﻭﺡ ﻫﻨﺎ ﻜﻴﻑ ﻴﻤﻜﻥ ﺃﻥ ﻨﺭﺒﻁ ﺒﻴﻥ ﺍﻟﻌﻨﺼﺭ‬
‫‪ Table‬ﻭﺠﺩﻭل ﺒﻴﺎﻨﺎﺕ ﺃﻜﺴﻴﺱ ‪:‬‬
‫‪ 1‬ـ ﺍﻓﺘﺢ ﻟﻭﺤﺔ ﺍﻟﺘﺤﻜﻡ ﻓﻲ ﻭﻴﻨﺩﻭﺯ ﻭﺍﺨﺘﺭ‬
‫‪Adminstrative Tools →ODBC Data Sources‬‬
‫ﺴﺘﻅﻬﺭ ﻟﻙ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﺎﻟﻴﺔ‬
‫ﺍﺨﺘﺭ ﻤﻨﻬﺎ ﺍﻟﺼﻔﺤﺔ ‪System DNS‬‬

‫‪ 2‬ـ ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Add‬ﻟﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫ﺍﺨﺘﺭ ﻤﻨﻬﺎ )‪Microsoft Access Driver ( *.mdb‬‬
‫ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪. Finish‬‬

‫‪ 3‬ـ ﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﺎﻟﻴﺔ ‪ :‬ﺍﻜﺘـﺏ ﻓـﻲ ﺍﻟﻘـﺴﻡ ‪Data‬‬

‫‪ Source Name‬ﺍﻟﻘﻴﻤﺔ ‪ ، Library‬ﻭﺍﻀﻐﻁ ﺒﻌﺩﻫﺎ ﻋﻠﻰ ﺍﻟﺯﺭ‬

‫‪136‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ Select‬ﻭﺍﺨﺘﺭ ﻗﺎﻋﺩﺓ ﻤﻠﻑ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺃﻜﺴﻴﺱ ) ‪ ( Books.mdb‬ﺒﻌﺩ ﺘﺤﺩﻴﺩ ﺍﻟﻔﻬﺭﺱ ﺍﻟﺘﻲ ﻭﻀﻌﺘﻪ ﻓﻴﻪ ‪ ،‬ﺍﻀﻐﻁ‬
‫ﺒﻌﺩﻫﺎ ﻋﻠﻰ ﺍﻟﺯﺭ ‪Ok‬‬
‫ﻭﺍﺨﺭﺝ ﻤﻥ ‪. ODBC Data Source‬‬

‫‪ 4‬ـ ﺍﻓﺘﺢ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪ BDE Administrator‬ﻤﻥ ﻟﻭﺤﺔ ﺍﻟﺘﺤﻜﻡ ﺃﻭ ﻋﻥ ﻁﺭﻴﻕ‬

‫‪Start Æ Program Æ Borland Delphi Æ BDE Administrator‬‬
‫ﻤﻬﻤﺔ ﻫﺫﺍ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻫﻲ ﺘﻌﺭﻴﻑ ﺍﻟـ ‪ Alias‬ﻭﺍﻟﺘﺤﻜﻡ ﻓﻲ ﺨﺼﺎﺌﺹ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﻋﻠﻰ ﺍﻟﺠﻬﺎﺯ ‪.‬‬

‫ﺤﺩﺩ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ Library‬ﻤـﻥ ﺍﻟـﺼﻔﺤﺔ‬

‫‪ ، Database‬ﻓﺘﻅﻬﺭ ﺨﻭﺍﺹ ﻫﺫﻩ ﺍﻟﻘﺎﻋﺩﺓ ﻓـﻲ‬
‫ﺍﻟﺼﻔﺤﺔ ﺍﻟﻴﻤﻴﻨﻴﺔ ‪ ، Definition‬ﺃﻜﺘـﺏ ﻓـﻲ‬
‫ﺍﻟﺨﺎﺼﺔ ‪ Database Name‬ﻤـﺴﺎﺭ ﻗﺎﻋـﺩﺓ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ Books.mdb‬ﺃﻭ ﺤﺩﺩﻩ ﻋﻥ ﻁﺭﻴـﻕ‬
‫ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺫﻭ ‪، ...‬‬
‫ﺃﻏﻠــﻕ ﺍﻟﺒﺭﻨــﺎﻤﺞ ‪BDE Administrator‬‬
‫ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Yes‬ﻋﻨﺩﻤﺎ ﻴﻁﺎﻟﺒﻙ ﺒﺤﻔـﻅ‬
‫ﺍﻟﺘﻐﻴﺭﺍﺕ ‪.‬‬

‫‪ 5‬ـ ﺍﻵﻥ ﻴﻤﻜﻨﻙ ﺭﺒﻁ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ Library‬ﻤﻊ ﺍﻟﻌﻨﺼﺭ ‪ Table‬ﺃﻭ ‪ Query‬ﻭﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﻜﻤﺎ ﻭﺠﺩﻨﺎ ﻓﻲ ﺍﻷﻤﺜﻠـﺔ‬
‫ﺍﻟﺴﺎﺒﻘﺔ ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪:‬‬
‫ﻴﻤﻜﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻹﻀﺎﻓﺔ ﺍﺴﻡ ﺒﺩﻴل ‪ Alias‬ﻟﻘﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ‪ Paradox‬ﻭﺫﻟﻙ ﺒﺎﺨﺘﻴﺎﺭ ﺍﻷﻤﺭ ‪ New‬ﻤﻥ ﺍﻟﻘﺎﺌﻤـﺔ‬
‫‪ Object‬ﻭﻤﺜل ﺍﺨﺘﻴﺎﺭ ﺍﻟﻨﻭﻉ ‪ Standard‬ﻭﻤﻥ ﺜﻡ ﺘﺤﺩﻴﺩ ﻜﺘﺎﺒﺔ ﺍﻻﺴﻡ ﺍﻟﺒﺩﻴل ﻟﻠﻘﺎﻋﺩﺓ ﻭﺘﺤﺩﻴﺩ ﻤـﺴﺎﺭﻫﺎ ﻓـﻲ ﺼـﻔﺤﺔ‬
‫ﺍﻟﺨﺼﺎﺌﺹ ‪.‬‬
‫ﺍﻟﺼﻔﺤﺔ ‪ : ADO‬ﺒﻌﺩ ﺃﻥ ﺘﻌﺭﻓﻨﺎ ﻋﻥ ﻁﺭﻴﻘﺔ ﺭﺒﻁ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﻭﺍﺴﻁﺔ ﻤﺤﺭﻙ ﻗﻭﺍﻋﺩ ﺒﻴﺎﻨﺎﺕ ‪، Borland‬‬
‫ﺴﻨﺘﻌﺭﻑ ﺍﻵﻥ ﻋﻠﻰ ﻜﻴﻔﻴﺔ ﺭﺒﻁ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻊ ﻤﺤﺭﻙ ﻗﻭﺍﻋﺩ ﺒﻴﺎﻨﺎﺕ ﻤﺎﻴﻜﺭﻭﺴﻭﻓﺕ ‪.‬‬
‫ﺘﻌﺘﺒﺭ ‪ ADO‬ﺃﺤﺩﺙ ﻤﻥ ‪ BDE‬ﻭﺘﺴﺘﺨﺩﻡ ﺨﻭﺍﺭﺯﻤﻴﺎﺕ ﺃﺴﺭﻉ ﻓﻲ ﺍﻟﺒﺤﺙ ﻭﺍﻟﺘﻌﺩﻴل ‪ ،‬ﻜﻤﺎ ﺘﻘﺩﻡ ﻁﺭﻕ ﻗﻭﻴﺔ ﻟﺭﺒﻁ ﻗﻭﺍﻋﺩ‬
‫ﻤﻌﻁﻴﺎﺕ ﻤﻭﺯﻋﺔ ﻤﺜل ﻗﻭﺍﻋﺩ ﺒﻴﺎﻨﺎﺕ ‪ Oracle‬ﺃﻭ ‪SQL Server‬‬
‫ﻤﺜﺎل ‪ :‬ﺭﺒﻁ ﻗﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﻜﺘﺒﺔ ﺒﻭﺍﺴﻁﺔ ‪: ADO‬‬
‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺍﻀﻑ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪137‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ ADOTable ، ADOConnection‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪ ADO‬ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﺃﻴﻀﹰﺎ ﺍﻟﻌﻨﺎﺼﺭ ‪ DataSource‬ﻭ‬
‫‪ DBGrid‬ﻭ ‪. DBNavigator‬‬
‫ﺍﻀﻐﻁ ﻤﺭﺘﻴﻥ ﻋﻠﻰ ﺍﻟﻌﻨﺼﺭ‬
‫‪ ADOConnection‬ﻟﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﺍﺨﺘﺭ ﺯﺭ ﺍﻟﺭﺍﺩﻴﻭ ‪Use Connection String‬‬
‫ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪Build‬‬
‫ﻟﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫ﺍﺨﺘﺭ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪Microsoft Jet 4.0 OLE Db Provider‬‬

‫ﻭﺍﻀﻐﻁ ﻋﻠﻰ ‪. Next‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﺇﺫﺍ ﻜﻨﺕ ﺘﺴﺘﺨﺩﻡ ﻗﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ‪ Oracle‬ﻓﺎﺨﺘﺭ‬
‫‪Microsoft OLE DB Provider for Oracle‬‬

‫ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ‪ Next‬ﺘﻅﻬﺭ ﺍﻟﺼﻔﺤﺔ ‪ Connection‬ﻓﻲ ﺍﻟﻘﺴﻡ‬

‫‪ Select Or Enter Database Name‬ﺃﺩﺨل ﻤﻠﻑ ﻗﺎﻋﺩﺓ ﻤﻌﻁﻴﺎﺕ‬
‫ﺍﻟﻜﺘﺏ‬
‫ﺍﻀﻐﻁ ﺒﻌﺩﻫﺎ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Ok‬ﻹﻨﻬﺎﺀ ﺍﻟﻤﻌﺎﻟﺞ‬

‫‪138‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺤﺩﺩ ﺍﻵﻥ ﺍﻟﻌﻨﺼﺭ ‪ ADOTable1‬ﻭﺃﻋﻁﻪ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﺍﻟﺨﺎﺼﺔ ‪ Connection‬ﺃﻋﻁﻬﺎ ﺍﻟﻘﻴﻤﺔ ‪ ADOConnection1‬ﻭ ﺍﻟﺨﺎﺼﺔ ‪ TableName‬ﺃﻋﻁﻬﺎ ﺍﻟﻘﻴﻤـﺔ ِ‪Authors‬‬
‫ﻭﺍﻟﺨﺎﺼﺔ ‪ Active‬ﺍﻟﻘﻴﻤﺔ ‪True‬‬
‫ﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ DataSet‬ﻟﻠﻌﻨﺼﺭ ‪ DataSource‬ﺍﻟﻘﻴﻤﺔ ‪ADOTable1‬‬
‫ﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ Datasource‬ﻟﻠﻌﻨﺼﺭﻴﻥ ‪ DBGrid1‬ﻭ ‪ DBNavigator1‬ﺍﻟﻘﻴﻤﺔ ‪. DataSource1‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻻﺤﻅ ﺍﻟﻨﺘﺎﺌﺞ ‪.‬‬
‫ﺒﻨﻔﺱ ﺍﻟﻁﺭﻴﻘﺔ ﻴﻤﻜﻥ ﺭﺒﻁ ‪ SQLConnection‬ﻻﺴﺘﺨﺩﺍﻡ ﻟﻐﺔ ‪ SQL‬ﻓﻲ ﻤﺤﺭﻙ ‪ ، ADO‬ﻜﻤﺎ ﻴﻤﻜﻨﻨﺎ ﺍﺴﺘﺨﺩﺍﻡ ﻨﻔـﺱ‬
‫ﻤﻨﺎﻫﺞ ﺍﻟﻌﻨﺼﺭﻴﻥ ‪ Table‬ﻭ ‪ Query‬ﻟﻠﺘﻌﺎﻤل ﻤﻊ ﻫﺫﻩ ﺍﻟﻌﻨﺎﺼﺭ ‪.‬‬

‫‪139‬‬
 ‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ‪22‬‬
‫ﺒﺭﻨﺎﻤﺞ ﺩﻟﻴل ﺍﻟﻬﺎﺘﻑ ‪:‬‬
‫‪ 1‬ـ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪:‬‬
‫ﻗﺒل ﺍﻟﺸﺭﻭﻉ ﺒﻜﺘﺎﺒﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻋﻠﻴﻨﺎ ﺘﺤﺩﻴﺩ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﻁﻠﻭﺒﺔ ﻭﺘﺤﺩﻴﺩ ﻋﺩﺩ ﺍﻟﺠﺩﺍﻭل ﻭﻁﺭﻕ ﺍﻟﺭﺒﻁ ﺒﻴﻥ ﺍﻟﺠـﺩﺍﻭل‬
‫ﻭﻨﻭﻋﻴﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﺍﻟﻔﻬﺎﺭﺱ ﺍﻟﻤﻁﻠﻭﺒﺔ ‪...‬‬
‫ﻓﻲ ﺒﺭﻨﺎﻤﺞ ﺩﻟﻴل ﺍﻟﻬﺎﺘﻑ ﺴﻨﺤﺘﺎﺝ ﺇﻟﻰ ﺠﺩﻭل ﻭﺍﺤﺩ ﻭﻫﻭ‬
‫‪ss City Country‬‬ ‫‪Web‬‬ ‫‪Email‬‬ ‫‪Fax Mobil WPhon HPhon LName FName Num‬‬
‫ﺍﻟﻤﺩﻴﻨﺔ ﺍ‬ ‫ﺍﻟﺩﻭﻟﺔ‬ ‫ﻤﻭﻗﻊ‬ ‫ﺍﻟﺒﺭﻴﺩ‬ ‫ﺍﻟﻬﺎﺘﻑ ﺍﻟﻔﺎﻜﺱ‬ ‫ﻫﺎﺘﻑ‬ ‫ﻫﺎﺘﻑ‬ ‫ﺍﻟﻜﻨﻴﺔ‬ ‫ﺍﻻﺴﻡ‬ ‫ﺭﻗﻡ‬
‫ﺍﻹﻟﻜﺘﺭﻭﻨﻲ ﺍﻻﻨﺘﺭﻨﺕ‬ ‫ﺍﻟﺨﻠﻭﻱ‬ ‫ﺍﻟﻌﻤل‬ ‫ﺍﻟﻤﻨﺯل‬
‫)‬ ‫)‪A(15‬‬ ‫)‪A(15‬‬ ‫)‪A(40) A(40) A(15) A(15‬‬ ‫)‪A(15‬‬ ‫)‪A(15‬‬ ‫)‪A(15‬‬ ‫)‪A(15‬‬ ‫‪+‬‬
‫ﺤﻴﺙ ﺍﻟﺤﻘل ‪ Num‬ﻫﻭ ﺤﻘل ﻤﻔﺘﺎﺡ ﺭﺌﻴﺴﻲ ‪.‬‬
‫ﺴﻨﺤﺘﺎﺝ ﺃﻴﻀﹰﺎ ﺇﻟﻰ ﺘﻌﺭﻴﻑ ﻓﻬﺭﺴﻴﻥ ﺜﺎﻨﻭﻴﻴﻥ ﺍﻷﻭل ﻟﺘﺭﺘﻴﺏ ﺍﻟﺠﺩﻭل ﺤﺴﺏ ﺍﻻﺴﻡ ﻭﺍﻟﺜﺎﻨﻲ ﻟﺘﺭﺘﻴﺏ ﺍﻟﺠﺩﻭل ﺤﺴﺏ ﺍﻟﻜﻨﻴـﺔ‬
‫‪.‬‬
‫ﻭﻟﻠﺒﺩﺀ ﺒﺈﻨﺸﺎﺀ ﺍﻟﻘﺎﻋﺩﺓ ‪:‬‬
‫‪ 1‬ـ ﺃﻨﺸﺊ ﺍﻟﻤﺠﻠﺩ ‪ MyPhon‬ﻋﻠﻰ ﺍﻟﻘﺭﺹ ‪ C‬ﻭﺃﻨﺸﺊ ﺩﺍﺨﻠﻪ ﺍﻟﻤﺠﻠﺩ ‪ ، Data‬ﺤﻴﺙ ﺴﻨﻘﻭﻡ ﺒﺘﺨـﺯﻴﻥ ﻤﻠﻔـﺎﺕ ﻗﺎﻋـﺩﺓ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﺍﻟﻤﺠﻠﺩ ‪ Data‬ﻭﺴﻨﺨﺯﻥ ﻤﻠﻔﺎﺕ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻓﻲ ﺍﻟﻤﺠﻠﺩ ‪) Data‬ﺤﺎﻭل ﺩﺍﺌﻤﹰﺎ ﺃﻥ ﺘﻀﻊ ﻤﻠﻔﺎﺕ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ‬
‫ﻤﺠﻠﺩ ﻤﻨﻔﺼل ﻭﺨﺎﺼﺔ ﺇﺫﺍ ﻜﺎﻨﺕ ﺍﻟﻘﺎﻋﺩﺓ ﺘﺘﺄﻟﻑ ﻤﻥ ﻋﺩﺩ ﻤﻥ ﺍﻟﻤﻠﻔﺎﺕ ﻜﻤﺎ ﻓﻲ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪. Paradox‬‬
‫‪ 2‬ـ ﺃﻨﺸﺊ ﺍﺴﻡ ﺒـﺩﻴل ‪ Alias‬ﺒﺎﺴـﻡ ‪ Myphon‬ﻟﻴـﺸﻴﺭ ﺇﻟـﻰ ﺍﻟﻤﺠﻠـﺩ ‪ C:\MyPhon\Data‬ﺒﺎﺴـﺘﺨﺩﺍﻡ ‪BDE‬‬
‫‪ Administrator‬ﺃﻭ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪. Database Desktop‬‬
‫‪ 3‬ـ ﺃﻨﺸﺊ ﺍﻟﺠﺩﻭل ﺍﻟﺴﺎﺒﻕ ﻓﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪ Database Desktop‬ﺒﺎﺴﺘﺨﺩﺍﻡ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ Paradox‬ﻭ ﻻ ﺘﻨﺱ ﺇﻨﺸﺎﺀ‬
‫ﺍﻟﻔﻬﺎﺭﺱ ﺍﻟﺜﺎﻨﻭﻴﺔ ﻜﻤﺎ ﻴﻠﻲ ‪:‬‬
‫ﺃ ـ ﺍﺨﺘﺭ ‪ Secondary Indexes‬ﻤﻥ ﺍﻟﻼﺌﺤﺔ ‪ Table properties‬ﻭﺍﻀـﻐﻁ ﻋﻠـﻰ ﺍﻟـﺯﺭ ‪Define‬‬
‫ﻭﺃﻀﻑ ﺍﻟﺤﻘﻠﻴﻥ ‪ Fname‬ﻭ ‪ Lname‬ﻋﻠـﻰ ﺍﻟﺘﺭﺘﻴـﺏ ﻭﺍﻀـﻐﻁ ﻋﻠـﻰ ‪ Ok‬ﻭﺃﻋـﻁ ﺍﺴـﻡ ﻟﻠﻔﻬـﺭﺱ‬
‫‪. FNameIndex‬‬
‫ﺏ ـ ﺍﻀﻐﻁ ﻋﻠﻰ ‪ Define‬ﻤﺭﺓ ﺃﺨﺭﻯ ﻭﺃﻀﻑ ﺍﻟﺤﻘﻠﻴﻥ ‪ Lname‬ﻭ ‪ FName‬ﻋﻠﻰ ﺍﻟﺘﺭﺘﻴﺏ ‪ ....‬ﻭﺃﻋـﻁ‬
‫ﺍﻟﻔﻬﺭﺱ ﺍﺴﻡ ‪. LNameIndex‬‬
‫‪ 4‬ـ ﺃﺤﻔﻅ ﺍﻟﺠﺩﻭل ﺒﺎﺴﻡ ‪ Phonebook‬ﻀﻤﻥ ﺍﻻﺴﻡ ﺍﻟﺒﺩﻴل ‪ Alias‬ﺍﻟﺫﻱ ﺃﻨﺸﺄﺘﻪ ﺴﺎﺒﻘﹰﺎ ‪ MyPhon‬ﺃﻭ ﺩﺍﺨل ﺍﻟﻤﺠﻠـﺩ‬
‫‪. C:\MyPhon\Data‬‬
‫ﺒﻬﺫﺍ ﻨﻜﻭﻥ ﻗﺩ ﺃﻨﺸﺄﻨﺎ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﺴﻨﻨﺘﻘل ﺇﻟﻰ ﺍﻟﻤﺭﺤﻠﺔ ﺍﻟﺜﺎﻨﻴﺔ ‪:‬‬
‫‪ 2‬ـ ﻜﺘﺎﺒﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪:‬‬
‫ﻼ ﻟﻠﺸﻜل ﺍﻟﺫﻱ ﺘﺭﻴﺩ ﻟﻠﺒﺭﻨﺎﻤﺞ ﺃﻥ ﻴﻅﻬﺭ ﻋﻠﻴﻪ ‪ ،‬ﻤﺎ ﻫـﻭ‬
‫ﻗﺒل ﺍﻟﺸﺭﻭﻉ ﺒﻜﺘﺎﺒﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻴﺠﺏ ﻋﻠﻴﻙ ﺃﻥ ﺘﻤﻠﻙ ﺘﺼﻭﺭﹰﺍ ﻜﺎﻤ ﹰ‬
‫ﺸﻜل ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺭﺌﻴﺴﻴﺔ ﻭﻤﺎﻫﻲ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﺘﻲ ﺴﺘﺘﻭﻀﻊ ﻋﻠﻴﻬﺎ ﻭﻤﺎ ﻫﻲ ﺍﻟﻨﻭﺍﻓﺫ ﺍﻷﺨﺭﻯ ﺍﻟﻭﺍﺠﺏ ﻭﻀﻌﻬﺎ ﻓﻲ ﺍﻟﺒﺭﻨـﺎﻤﺞ )‬
‫‪140‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺒﻜﻠﻤﺎﺕ ﺃﺨﺭﻯ ‪ ،‬ﺃﻤﺴﻙ ﻭﺭﻗﺔ ﻭﻗﻠﻡ ﻭﺤﺎﻭل ﺃﻥ ﺘﺭﺴﻡ ﻤﺎ ﺘﺭﻴﺩ ﺃﻥ ﺘﻔﻌﻠﻪ ﻭﻤﺎ ﻫﻭ ﺍﻟﻤﻁﻠﻭﺏ ﻤﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺃﻥ ﻴﻘﺩﻤـﻪ ( ‪،‬‬
‫ﺤﺩﺩ ﻤﺎ ﻫﻲ ﺍﻟﻨﻘﺎﻁ ﺍﻷﺼﻌﺏ ﻓﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻫل ﻫﻲ ﻟﻌﺩﻡ ﺨﺒﺭﺘﻙ ﺍﻟﺒﺭﻤﺠﻴﺔ ﻓﻲ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻫﺫﻩ ﺍﻟﻨﻘﺎﻁ ﺃﻭ ﻟﻌـﺩﻡ ﻗـﺩﺭﺓ‬
‫ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ﻋﻠﻰ ﺘﻘﺩﻴﻡ ﻤﺎ ﺘﻁﻠﺒﻪ ) ﻋﻤﻠﻴﹰﺎ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ﻋﺎﻟﻴﺔ ﺍﻟﻤﺴﺘﻭﻯ ﻻ ﺘﻜﻭﻥ ﻗﺎﺼﺭﺓ ﻋﻥ ﺃﺩﺍﺀ ﺸﻴﺊ ﻤﻌـﻴﻥ ﻭﻟﻜـﻥ‬
‫ﻋﻠﻰ ﺍﻟﻤﺒﺭﻤﺞ ﺃﻥ ﻴﺒﺤﺙ ﻜﺜﻴﺭﹰﺍ ﻟﺘﻌﻠﻡ ﻜﻴﻔﻴﺔ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻤﻭﺍﻀﻴﻊ ﻤﻌﻴﻨﻪ ( ‪ ،‬ﺴﺄﻭﺭﺩ ﺍﻵﻥ ﺒﻌـﺽ ﺍﻷﻤﺜﻠـﺔ ﻋﻠـﻰ ﻫـﺫﻩ‬
‫ﺍﻟﻤﺸﺎﻜل ‪ ،‬ﺘﺼﻭﺭ ﺃﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻁﻠﺏ ﺃﻥ ﻴﻜﻭﻥ ﺒﺭﻨﺎﻤﺠﻪ ﻗﺎﺩﺭﹰﺍ ﻋﻠﻰ ﻁﺒﺎﻋﺔ ﺤﻘﻭل ﻤﻌﻴﻨﺔ ﻭﺃﻨﺕ ﺤﺘﻰ ﺍﻵﻥ ﻟـﻡ ﺘـﺘﻌﻠﻡ‬
‫ﺸﻴﺌﹰﺎ ﻋﻥ ﺍﻟﻁﺒﺎﻋﺔ ﺴﺘﻜﻭﻥ ﻫﻨﺎ ﺍﻵﻥ ﺃﻤﺎﻡ ﻁﺭﻴﻘﻴﻥ ‪:‬‬
‫ﺍﻷﻭل‪ :‬ﺍﻟﺒﺩﺀ ﺒﻜﺘﺎﺒﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺘﻌﻠﻡ ﺍﻟﻁﺒﺎﻋﺔ ﻋﻨﺩ ﺍﻟﻭﺼﻭل ﺇﻟﻰ ﺍﻟﻨﻘﺎﻁ ﺍﻟﺘﻲ ﺘﺤﺘﺎﺝ ﺍﻟﻁﺒﺎﻋﺔ ﻓﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ ) ﻋﻤﻠﻴﹰﺎ ﻴﺘـﺭﻙ‬
‫ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﺍﻟﻨﻘﺎﻁ ﺍﻟﺼﻌﺒﺔ ﺤﺘﻰ ﺁﺨﺭ ﻨﻘﻁﺔ ﻤﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ( ‪.‬‬
‫ﺍﻟﺜﺎﻨﻲ ‪ :‬ﺘﻌﻠﻡ ﺍﻟﻁﺒﺎﻋﺔ ﻭﺍﻟﺘﻌﺭﻑ ﻋﻠﻰ ﺇﻤﻜﺎﻨﻴﺎﺕ ﺍﻟﻁﺒﺎﻋﺔ ﺍﻟﺘﻲ ﺘﻘﺩﻤﻬﺎ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ﻭﻤﻥ ﺜﻡ ﺍﻟﺸﺭﻭﻉ ﺒﻜﺘﺎﺒﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪.‬‬
‫ﺍﻟﻤﺸﻜﻠﺔ ﻓﻲ ﺍﻟﻁﺭﻴﻕ ﺍﻷﻭل ‪ :‬ﺘﺼﻭﺭ ﺃﻨﻙ ﻋﺭﻓﺕ ﺒﻌﺽ ﺍﻟﺤﻘﻭل ﻤﻥ ﺍﻟﻨﻭﻉ ﻤﺫﻜﺭﺓ ‪ Memo‬ﺜﻡ ﺍﻜﺘﺸﻔﺕ ﺃﻥ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ‬
‫ﻻ ﺘﺴﺘﻁﻴﻊ ﺃﻥ ﺘﻁﺒﻊ ﺍﻟﺤﻘﻭل ﻤﻥ ﻨﻭﻉ ‪ Memo‬ﺃﻭ ﻋﻠﻰ ﺍﻷﻗل ﻻ ﺘﺴﺘﻁﻴﻊ ﻁﺒﺎﻋﺘﻬﺎ ﺒﺎﻟﺸﻜل ﺍﻟﺫﻱ ﺘﺭﻴﺩﻩ ‪ ،‬ﻤﺎﺫﺍ ﺴـﺘﻔﻌل‬
‫ﺍﻵﻥ ‪ ،‬ﺇﻤﺎ ﺃﻥ ﺘﻘﻭﻡ ﺒﻜﺘﺎﺒﺔ ﺨﻭﺍﺭﺯﻤﻴﺎﺕ ﺠﺩﻴﺩﺓ ﻟﻠﻁﺒﺎﻋﺔ ﻭﻫﺫﺍ ﺼﻌﺏ ﺠﺩﹰﺍ ﺒﺎﻟﻨﺴﺒﺔ ﻟﻤﺒﺭﻤﺞ ﻋﺎﺩﻱ ﺃﻭ ﺍﻟﻌﻭﺩﺓ ﺇﻟﻰ ﻗﺎﻋـﺩﺓ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﺘﺤﻭﻴل ﻨﻭﻉ ﻫﺫﻩ ﺍﻟﺤﻘﻭل ﺇﻟﻰ ﺍﻟﻨﻭﻉ ﻨﺹ ‪Alpha‬‬
‫ﻭﺒﺎﻟﺘﺎﻟﻲ ﺍﻟﻌﻭﺩﺓ ﺇﻟﻰ ﺍﻟﻨﻤﺎﺫﺝ ﻭﺘﻌﺩﻴﻠﻬﺎ ﺃﻴﻀﹰﺎ ﻟﻤﻼﺌﻤﺔ ﺍﻟﺘﻐﻴﺭﺍﺕ ﻓﻲ ﺍﻟﻘﺎﻋﺩﺓ ﺍﻷﻤﺭ ﺍﻟﺫﻱ ﻗـﺩ ﻴـﻀﻁﺭﻙ ﺃﺤﻴﺎﻨـﹰﺎ ﻟﻜﺘﺎﺒـﺔ‬
‫ﺍﻟﺒﺭﻨﺎﻤﺞ ﻤﻥ ﺠﺩﻴﺩ ‪.‬‬
‫ﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﺜﺎﻨﻴﺔ ﻫﻲ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻷﻓﻀل ﻭﺭﺒﻤﺎ ﻫﻲ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﻭﺤﻴﺩﺓ ﺍﻟﺘﻲ ﺘﺠﻌﻠﻙ ﺘﻨﻬﻲ ﻤﺎ ﺒﺩﺃﺕ ﺒﺎﻟﺸﻜل ﺍﻟﺫﻱ ﺘﺭﻴﺩ ‪.‬‬
‫ﻻ ﻤﻥ ﺃﺼﻌﺏ ﺍﻟﻨﻘﺎﻁ ﻭﺤﺎﻭل ﺤﻠﻬﺎ ﺤﺘﻰ ﺘﺴﺘﻁﻴﻊ ﺍﻟﻭﺼﻭل ﺇﻟﻰ ﺍﻟﻨﻬﺎﻴﺔ ‪.‬‬
‫ﻭﺍﻟﻘﺎﻋﺩﺓ ﻫﻲ ‪ :‬ﺍﺒﺩﺃ ﺃﻭ ﹰ‬
‫ﺴﻨﻨﺸﺊ ﺍﻵﻥ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺭﺌﻴﺴﻴﺔ ﻭﺍﻟﺘﻲ ﺴﺘﻅﻬﺭ ﺒﺎﻟﺸﻜل ‪:‬‬

‫ﺃﻀﻑ ﺍﻵﻥ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫‪141‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ 1‬ـ ﺃﻋﻁ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻷﻭل ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﺍﻟﻘﻴﻤﺔ‬ ‫ﺍﻟﺨﺎﺼﺔ‬
‫‪bdRightToLeft‬‬ ‫‪BiDiMode‬‬
‫ﺒﺭﻨﺎﻤﺞ ﺩﻟﻴل ﺍﻟﻬﺎﺘﻑ‬ ‫‪Caption‬‬
‫‪470‬‬ ‫‪Hieght‬‬
‫‪750‬‬ ‫‪Width‬‬
‫‪poScreenCenter‬‬ ‫‪Position‬‬

‫‪ 2‬ـ ﺃﻀﻑ ﺍﻟﻌﻨﺼﺭ ‪ TabControl‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪ Win32‬ﻭﺃﻋﻁﻪ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫‪alTop‬‬ ‫‪Align‬‬
‫‪True‬‬ ‫‪MultiLine‬‬
‫‪tsButtons‬‬ ‫‪Style‬‬
‫ﺃﻜﺘﺏ ﺍﻟﺤﺭﻭﻑ ﺍﻷﺒﺠﺩﻴﺔ ﻤﻥ ﺃ ﺇﻟﻰ ﻱ ﻭﻜل ﺤﺭﻑ ﻓﻲ ﺴﻁﺭ‬ ‫‪Tabs‬‬
‫‪True‬‬ ‫‪HotTrack‬‬

‫‪ 3‬ـ ﺃﻀﻑ ﺍﻟﻌﻨﺼﺭ ‪ Panel‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪ Standard‬ﻭﺃﻋﻁﻪ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫‪alClient‬‬ ‫‪Align‬‬
‫‪bvLowered‬‬ ‫‪Bevelinner‬‬
‫‪bvRaised‬‬ ‫‪BevelOuter‬‬
‫'' ﻓﺭﺍﻍ‬ ‫‪Caption‬‬
‫‪ 4‬ـ ﺍﻟﻌﻨﺼﺭ ‪: Table‬‬
‫‪MyPhone‬‬ ‫‪DatabaseName‬‬
‫‪Phonebook‬‬ ‫‪TableName‬‬
‫‪FnameIndex‬‬ ‫‪IndexName‬‬
‫‪True‬‬ ‫‪Active‬‬
‫ﺃﺩﺨل ﺇﻟﻰ ﻤﺤﺭﺭ ﺍﻟﺤﻘﻭل ﻭﺃﻀﻑ ﺠﻤﻴﻊ ﺍﻟﺤﻘﻭل ﺜﻡ ﺍﺤﺫﻑ ﺍﻟﺤﻘل ‪ Num‬ﻟﻜﻲ ﻻ ﻴﻅﻬﺭ ﻓﻲ ﺍﻟﺠﺩﻭل ﺜﻡ ﺃﻋﻁ ﻟﻜل ﺤﻘل‬
‫ﺍﺴﻤﻪ ﺒﺎﻟﻠﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ DisplayLabel‬ﺍﻟﺘﺎﺒﻌﺔ ﻟﻜل ﺤﻘل‪.‬‬
‫‪ 5‬ـ ﺍﻟﻌﻨﺼﺭ ‪ : DataSource‬ﻀﻌﻪ ﻀﻤﻥ ﺍﻟﻌﻨﺼﺭ ‪: Tabcontrol‬‬
‫‪Table1‬‬ ‫‪Dataset‬‬
‫‪ 6‬ـ ﺍﻟﻌﻨﺼﺭ ‪: DbGrid‬‬
‫‪alClient‬‬ ‫‪Align‬‬
‫‪DataSource1‬‬ ‫‪DataSource‬‬
‫ﺃﺩﺨل ﺇﻟﻰ ﻤﺤﺭﺭ ﺍﻷﻋﻤﺩﺓ ﻭﺃﻀﻑ ﺠﻤﻴﻊ ﺍﻟﺤﻘﻭل ﺜﻡ ﺤﺩﺩﻫﺎ ﻭﺍﺫﻫﺏ ﺇﻟﻰ ﺍﻟﺨﺎﺼﺔ ‪ Titel‬ﻭﺍﻀﻐﻁ ﻋﻠﻰ ‪ +‬ﻭﻏﻴﺭ‬
‫ﺍﻟﺨﺎﺼﺔ ‪ Aligment‬ﺇﻟﻰ ‪taCenter‬‬
‫‪ 7‬ـ ﺍﻟﻌﻨﺼﺭ ‪ : GroupBox‬ﻀﻌﻪ ﻀﻤﻥ ﺍﻟﻌﻨﺼﺭ ‪: Panel‬‬
‫ﺘﺭﺘﻴﺏ ﺤﺴﺏ‬ ‫‪Caption‬‬

‫‪142‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ 8‬ـ ﺍﻟﻌﻨﺼﺭ ‪ : RadioButton1‬ﻀﻌﻪ ﺩﺍﺨل ﺍﻟﻌﻨﺼﺭ ‪GroupBox1‬‬
‫ﺍﻻﺴﻡ‬ ‫‪Caption‬‬
‫‪True‬‬ ‫‪Checked‬‬
‫‪RBTName‬‬ ‫‪Name‬‬
‫‪ 9‬ـ ﺍﻟﻌﻨﺼﺭ ‪ : RadioButton2‬ﻀﻌﻪ ﺩﺍﺨل ﺍﻟﻌﻨﺼﺭ ‪GroupBox1‬‬
‫ﺍﻟﻜﻨﻴﺔ‬ ‫‪Caption‬‬
‫‪RBTLname‬‬ ‫‪Name‬‬
‫‪ 10‬ـ ﺍﻟﻌﻨﺼﺭ ‪ : Edit1‬ﻀﻌﻪ ﺩﺍﺨل ﺍﻟﻌﻨﺼﺭ ‪: GroupBox1‬‬
‫" ﻓﺭﺍﻍ‬ ‫‪Text‬‬
‫‪ 11‬ـ ﺍﻟﻌﻨﺼﺭ ‪ : Button‬ﻀﻌﻪ ﺩﺍﺨل ﺍﻟﻌﻨﺼﺭ ‪GroupBox1‬‬
‫ﺒﺤﺙ ﺤﺴﺏ ﺍﻻﺴﻡ‬ ‫‪Caption‬‬
‫‪BtnSearch‬‬ ‫‪Name‬‬
‫ﺴﻨﺒﺩﺃ ﺍﻵﻥ ﺒﻜﺘﺎﺒﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﻼﺯﻤﺔ ﺤﺘﻰ ﻫﺫﻩ ﺍﻟﻨﻘﻁﺔ ﻭﺴﻨﻌﻭﺩ ﻹﻜﻤﺎل ﺒﻘﻴﺔ ﺍﻟﻌﻨﺎﺼﺭ ﻻﺤﻘﹰﺎ ‪:‬‬

‫ـ ﻋﻨﺩﻤﺎ ﻴﻀﻐﻁ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻠﻰ ﺯﺭ ﺍﻟﺭﺍﺩﻴﻭ ﺍﻻﺴﻡ ﺴﻴﺘﻡ ﺘﺭﺘﻴﺏ ﺍﻟﺠﺩﻭل ﺤﺴﺏ ﺤﻘل ﺍﻻﺴﻡ ﻭﺴﻴﻜﻭﻥ ﺍﻟﺒﺤـﺙ ﻤﺘﺎﺤـﹰﺎ‬
‫ﺤﺴﺏ ﺍﺴﻡ ﺍﻟﺸﺨﺹ ﻟﺫﻟﻙ ﻨﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺍﻟﺭﺍﺩﻴﻭ ﺍﻻﺴﻡ ‪: RBTName‬‬
‫;'‪table1.IndexName := 'FnameIndex‬‬
‫;'ﺒﺤﺙ ﺤﺴﺏ ﺍﻻﺴﻡ' =‪btnSearch.Caption :‬‬
‫ـ ﻭﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺍﻟﺭﺍﺩﻴﻭ ﺍﻟﻜﻨﻴﺔ ﺴﻴﺭﺘﺏ ﺍﻟﺠﺩﻭل ﺤﺴﺏ ﺤﻘل ﺍﻟﻜﻨﻴﺔ ﻭﺴﻴﻜﻭﻥ ﺍﻟﺒﺤﺙ ﻤﺘﺎﺤﹰﺎ ﺤﺴﺏ ﺤﻘـل‬
‫ﺍﻟﻜﻨﻴﺔ ﻟﺫﻟﻙ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺍﻟﻜﻨﻴﺔ ‪: RBTLname‬‬
‫;'‪table1.IndexName := 'LnameIndex‬‬
‫;'ﺒﺤﺙ ﺤﺴﺏ ﺍﻟﻜﻨﻴﺔ ' =‪btnSearch.Caption :‬‬
‫ـ ﻋﻨﺩﻤﺎ ﻴﻀﻐﻁ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻠﻰ ﺃﻱ ﺼﻔﺤﺔ ﻤﻥ ﺼﻔﺤﺎﺕ ﺍﻟﻌﻨﺼﺭ ‪ Tabcontrol‬ﺴﻴﺘﻡ ﺇﻅﻬﺎﺭ ﺍﻷﺴـﻤﺎﺀ ﺍﻟﺘـﻲ ﺘﺒـﺩﺃ‬
‫ﺒﺎﻟﺤﺭﻑ ﺍﻟﺘﻲ ﻀﻐﻁ ﻋﻠﻴﻪ ﺍﻟﻤﺴﺘﺨﺩﻡ ‪ ،‬ﺃﻤﺎ ﺇﺫﺍ ﻜﺎﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻗﺩ ﺍﺨﺘﺎﺭ ﺍﻟﺘﺭﺘﻴﺏ ﺤﺴﺏ ﺍﻟﻜﻨﻴﺔ ﻓﺴﺘﻅﻬﺭ ﺍﻟﺤﻘﻭل ﺍﻟﺘﻲ ﻴﺒﺩﺃ‬
‫ﻓﻴﻬﺎ ﺤﻘل ﺍﻟﻜﻨﻴﺔ ﺒﺎﻟﺤﺭﻑ ﺍﻟﺫﻱ ﻀﻐﻁ ﻋﻠﻴﻪ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻟﺫﻟﻙ ﺍﻜﺘﺏ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnCahnge‬ﻟﻠﻌﻨـﺼﺭ ‪Tabcontrol1‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪if RBTName.Checked then‬‬
‫‪table1.Filter := 'fname = ' + quotedstr( tabcontrol1.Tabs[tabcontrol1.tabindex]+ '*') else‬‬
‫)'*' ‪table1.Filter := 'Lname = ' + quotedstr( tabcontrol1.Tabs[tabcontrol1.tabindex]+‬‬
‫ﻟﻤﻌﺭﻓﺔ ﻋﻤل ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺭﺍﺠﻊ ﺍﻟﻤﺤﺎﻀﺭﺍﺕ ﺍﻟﺴﺎﺒﻘﺔ ‪...‬‬
‫ـ ﺯﺭ ﺍﻟﺒﺤﺙ ‪:‬‬

‫‪143‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺴﻴﺘﻡ ﺍﻟﺒﺤﺙ ﻋﻥ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﻜﺘﻭﺒﺔ ﻓﻲ ﺍﻟﻌﻨﺼﺭ ‪ Edit1‬ﻓﻲ ﺤﻘل ﺍﻻﺴﻡ ﺃﻭ ﺤﻘل ﺍﻟﻜﻨﻴﺔ ) ﺤﺴﺏ ﺨﻴﺎﺭ ﺍﻟﻤﺴﺘﺨﺩﻡ ( ﻭﻓـﻲ‬
‫ﺤﺎل ﻋﺩﻡ ﻭﺠﺩﻭﻫﺎ ﺴﻴﺘﻭﻗﻑ ﻤﺅﺸﺭ ﺍﻟﺴﺠﻼﺕ ﻋﻨﺩ ﺃﻗﺭﺏ ﻗﻴﻤﺔ ﻟﻠﺒﺤﺙ ‪ ،‬ﺒﻤﺎ ﺃﻥ ﺍﻟﺒﺤﺙ ﺴﻴﺘﻡ ﻓﻲ ﻜﺎﻤل ﺍﻟﺠﺩﻭل ﻓﻴﺠـﺏ‬
‫ﺇﻟﻐﺎﺀ ﺍﻟﺘﺼﻔﻴﺔ ‪ Filter‬ﻗﺒل ﺍﻟﻘﻴﺎﻡ ﺒﺎﻟﺒﺤﺙ ‪ ،‬ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺭﺯ ‪: BtnSearch‬‬
‫;‪table1.Filtered := false‬‬
‫;)]‪table1.FindNearest([edit1.text‬‬
‫ﺃﻀﻑ ﺒﻌﺽ ﺍﻟﺴﺠﻼﺕ ﻋﻠﻰ ﺴﺒﻴل ﺍﻟﺘﺠﺭﺒﺔ ‪.............‬‬
‫ـ ﺍﻟﺒﺤﺙ ﻋﻥ ﺭﻗﻡ ﻫﺎﺘﻑ ‪:‬‬
‫ﻋﻨﺩﻤﺎ ﺘﺭﻴﺩ ﺃﻥ ﺘﺒﺤﺙ ﻋﻥ ﺭﻗﻡ ﻫﺎﺘﻑ ﻓﻠﻥ ﻴﻜﻭﻥ ﻤﻬﻤﹰﺎ ﺃﻥ ﺘﺤﺩﺩ ﻓﻲ ﺃﻱ ﺤﻘل ﺃﻱ ﻻ ﻴﻬﻡ ﺇﻥ ﻜﺎﻥ ﺍﻟﻬﺎﺘﻑ ﺍﻟﺫﻱ ﺴـﻨﺒﺤﺙ‬
‫ﻋﻥ ﺼﺎﺤﺒﻪ ﻫﻭ ﻫﺎﺘﻑ ﺍﻟﻤﻨﺯل ﺃﻭ ﻫﺎﺘﻑ ﺍﻟﻌﻤل ﻓﺎﻟﻤﻬﻡ ﺃﻥ ﻴﻌﻴﺩ ﺍﻟﺒﺤﺙ ﺍﺴﻡ ﺍﻟﺸﺨﺹ ﺍﻟﺫﻱ ﻨﺒﺤﺙ ﻋﻥ ﺭﻗﻡ ﻫﺎﺘﻔﻪ ﻟـﺫﻟﻙ‬
‫ﺴﺘﺒﺤﺙ ﻓﻲ ﺍﻟﺤﻘل ‪ HPhon‬ﻓﺈﺫﺍ ﻟﻡ ﻨﺠﺩ ﺍﻟﺭﻗﻡ ﻨﺒﺤﺙ ﻓﻲ ﺍﻟﺤﻘل ‪ WPhon‬ﻓﺈﺫﺍ ﻟﻡ ﻨﺠﺩ ﺍﻟـﺭﻗﻡ ﺴـﻨﺒﺤﺙ ﻓـﻲ ﺍﻟﺤﻘـل‬
‫‪ Mobil‬ﻭﺇﺫﺍ ﻟﻡ ﻨﺠﺩ ﺍﻟﺭﻗﻡ ﺘﻅﻬﺭ ﺭﺴﺎﻟﺔ ﺘﺨﺒﺭﻨﺎ ﺒﺄﻥ ﺍﻟﺭﻗﻡ ﻏﻴﺭ ﻤﻭﺠﻭﺩ‬
‫ﻟﺫﻟﻙ ﺃﻀﻑ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﺘﺎﻟﻴﺔ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺴﺎﺒﻕ ‪:‬‬
‫‪ 1‬ـ ﺍﻟﻌﻨﺼﺭ ‪ : GroupBox‬ﻀﻌﻪ ﻀﻤﻥ ﺍﻟﻌﻨﺼﺭ ‪: Panel‬‬
‫ﺒﺤﺙ ﻋﻥ ﺭﻗﻡ ﺍﻟﻬﺎﺘﻑ‬ ‫‪Caption‬‬
‫‪ 2‬ـ ﻋﻨﺼﺭ ‪Edit2‬‬
‫" ﻓﺭﺍﻍ‬ ‫‪Text‬‬
‫‪ 3‬ـ ﺍﻟﻌﻨﺼﺭ ‪: Button‬‬
‫ﺒﺤﺙ‬ ‫‪Caption‬‬
‫‪BtnPhSearch‬‬ ‫‪Name‬‬
‫ﻭﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﻫﺫﺍ ﺍﻟﺯﺭ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫;‪Table1.Filtered := false‬‬
‫‪if not Table1.Locate('HPhon',edit2.text,[]) then‬‬
‫‪if not Table1.Locate('WPhon',edit2.text,[]) then‬‬
‫‪if not Table1.Locate('Mobil',edit2.text,[]) then‬‬
‫; ) 'ﺍﻟﺭﻗﻡ ﻏﻴﺭ ﻤﻭﺠﻭﺩ' (‪showmessage‬‬
‫ﻴﻤﻜﻨﻙ ﺍﻵﻥ ﺇﻀﺎﻓﺔ ﺃﺯﺭﺍﺭ ﻟﻠﺒﺤﺙ ﻋﻥ ﺍﻟﺒﺭﻴﺩ ﺍﻻﻟﻜﺘﺭﻭﻨﻲ ﻭ ﺍﻟﻔﺎﻜﺱ ﻭ‪....‬‬
‫ﺤﻔﻅ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪:‬ﺍﺤﻔﻅ ﺍﻟﺘﻁﺒﻴﻕ ﻓﻲ ﺍﻟﻤﺠﻠﺩ ‪ C:\MyPhon‬ﺃﻋﻁ ﺍﻟﻭﺤﺩﺓ ﺍﺴـﻡ ‪ Main.pas‬ﻭﺃﻋـﻁ ﺍﻟﻤـﺸﺭﻭﻉ ﺍﺴـﻡ‬
‫‪. MyPhone‬‬
‫ﺃﻀﻑ ﺍﻵﻥ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﺘﺎﻟﻴﺔ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ‪:‬‬
‫ـ ﺍﻟﻌﻨﺼﺭ ‪ : GroupBox‬ﻀﻌﻪ ﻀﻤﻥ ﺍﻟﻌﻨﺼﺭ ‪: Panel‬‬
‫ﺨﻴﺎﺭﺍﺕ‬ ‫‪Caption‬‬

‫‪144‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ـ ﺃﺭﺒﻊ ﺃﺯﺭﺍﺭ ‪ Button‬ﺃﻋﻁﻬﺎ ‪Caption‬‬
‫ﺍﻹﺩﺨﺎل ‪ :‬ﺠﺭﺕ ﺍﻟﻌﺎﺩﺓ ﻋﻠﻰ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻌﻨﺎﺼﺭ ﻓﻲ ﺍﻟﺼﻔﺤﺔ ‪ Data control‬ﻹﺩﺨﺎل ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻟـﻰ ﺍﻟﻘﺎﻋـﺩﺓ ﻭﻋـﺩﻡ‬
‫ﺍﻻﻋﺘﻤﺎﺩ ﻋﻠﻰ ﺍﻟﻌﻨﺼﺭ ‪ DBGrid‬ﻓﻘﻁ ﻭﺨﺎﺼﺔ ﺃﻨﻪ ﻟﺩﻴﻨﺎ ﺤﻘل ﻤﻥ ﻨﻭﻉ ‪ Memo‬ﺍﻟﺫﻱ ﻻ ﻴﻤﻜﻥ ﺍﻹﺩﺨﺎل ﺇﻟﻴـﻪ ﻀـﻤﻥ‬
‫‪ ) DBGrid‬ﻓﻲ ﺃﻏﻠﺏ ﺍﻷﺤﻴﺎﻥ ﻴﻌﻁﻰ ﺍﻟﻌﻨﺼﺭ ‪ DBGrid‬ﺍﻟﺨﺎﺼﺔ ‪ ReadOnly‬ﻭﺫﻟﻙ ﻻﺴﺘﺨﺩﺍﻤﻪ ﻟﻠﻌﺭﺽ ﻓﻘﻁ ( ‪.‬‬
‫ـ ﺃﻨﺸﺊ ﻨﻤﻭﺫﺠﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻋﻁﻪ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪bdRightToLeft‬‬ ‫‪BiDiMode‬‬
‫ﺇﺩﺨﺎل‬ ‫‪Caption‬‬
‫‪poScreenCenter‬‬ ‫‪Position‬‬
‫‪DataEnter‬‬ ‫‪Name‬‬
‫ﻭﺃﻀﻑ ﺍﺴﻡ ﺍﻟﻭﺤﺩﺓ ‪ Main‬ﺇﻟﻰ ﺍﻟﻘﺴﻡ ‪ Uses‬ﻟﻬﺫﻩ ﺍﻟﻭﺤﺩﺓ ﻭﺫﻟﻙ ﻟﻜﻲ ﻨﺘﻤﻜﻥ ﻤﻥ ﺍﻟﻭﺼﻭل ﺇﻟﻰ ﺍﻟﻌﻨﺼﺭ ‪ Table1‬ﻋﻠﻰ‬
‫ﺍﻟﻨﻤﻭﺫﺝ ﺍﻷﻭل ‪:‬‬
‫ﺍﺤﻔﻅ ﺍﻟﻭﺤﺩﺓ ﺒﺎﺴﻡ ‪. DataEnterU‬‬
‫ﻀﻊ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﻋﻨﺎﺼﺭ ﺍﻟـ ‪ DBEdit‬ﻭﻋﻨﺎﺼﺭ ‪ Label‬ﻭﻋﻨﺼﺭ ‪ DBNavigator‬ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﻜﻤﺎ ﻓﻲ ﺍﻟﺸﻜل‬
‫‪:‬‬

‫ﺤﺩﺩ ﺠﻤﻴﻊ ﻋﻨﺎﺼﺭ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻗﻭﺍﻋﺩ ﺍﻟﻤﻌﻁﻴﺎﺕ ) ﺠﻤﻴﻊ ﺍﻟﻌﻨﺎﺼﺭ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﻋﺩﺍ ﻋﻨﺎﺼﺭ ﺍﻟـ ‪ ( Label‬ﻭﺃﻋﻁﻬﺎ‬
‫ﺍﻟﺨﺎﺼﺔ ‪ DataSource‬ﺍﻟﻘﻴﻤﺔ ‪. Form1.DataSource1‬‬
‫ﺜﻡ ﺍﺭﺒﻁ ﻜل ﻋﻨﺼﺭ ﻤﻥ ﻋﻨﺎﺼﺭ ‪ DBEdit‬ﺒﺤﻘل ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ DataField‬ﻭﺫﻟﻙ ﺤﺴﺏ ﺍﻟﻌﻨﺼﺭ ‪ Label‬ﺍﻟﻤﺠﺎﻭﺭ ‪.‬‬
‫ﻹﻅﻬﺎﺭ ﻫﺫﺍ ﺍﻟﻨﻤﻭﺫﺝ ﻋﺩ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻷﻭل ﻭﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺇﺩﺨﺎل ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; ‪DataEnter.ShowModal‬‬
‫ﻤﻥ ﺍﻟﻤﻔﻴﺩ ﺇﻴﻀﹰﺎ ﻅﻬﻭﺭ ﻫﺫﺍ ﺍﻟﻨﻤﻭﺫﺝ ﻋﻨﺩﻤﺎ ﻴﻀﻐﻁ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻠﻰ ﺍﺴﻡ ﺃﺤﺩ ﺍﻷﺸﺨﺎﺹ ﺩﺍﺨل ﺍﻟﻌﻨﺼﺭ ‪ DBGrid‬ﻟﺫﻟﻙ‬
‫ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnDbClick‬ﻟﻠﻌﻨﺼﺭ ‪DBGrid1‬‬
‫; ‪DataEnter.ShowModal‬‬

‫‪145‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﻁﺒﺎﻋﺔ ‪:‬‬
‫ﻴﺴﺘﺨﺩﻡ ﺼﻔﺤﺔ ﺍﻟﻌﻨﺎﺼﺭ ‪ QReport‬ﻟﻠﻁﺒﺎﻋﺔ ﻓﻲ ﺩﻟﻔﻲ ﻭﺘﺴﺘﻁﻴﻊ ﻫﺫﻩ ﺍﻟﺼﻔﺤﺔ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻜﻤﺎ ﻴﻤﻜﻨﻙ‬
‫ﻁﺒﺎﻋﺔ ﺍﻟﺼﻭﺭ ﻭﺍﻷﺭﻗﺎﻡ ﻭﺍﻟﺤﺴﺎﺒﺎﺕ ﻋﻥ ﻁﺭﻴﻘﻬﺎ ‪:‬‬
‫ﻤﻼﺤﻅﺔ ﻟﻤﺴﺘﺨﺩﻤﻲ ﺩﻟﻔﻲ ‪: 7‬‬
‫ﻻ ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪ QReport‬ﻭﺇﺫﺍ ﺃﺭﺩﺕ‬
‫ﺃﻀﺎﻓﺕ ﺒﻭﺭﻻﻨﺩ ﺼﻔﺤﺔ ﻤﺠﻤﻭﻋﺔ ﺠﺩﻴﺩﺓ ﻤﻥ ﺍﻟﻌﻨﺎﺼﺭ ﻓﻲ ﺍﻟﺼﻔﺤﺔ ‪ Rave‬ﺒﺩ ﹰ‬
‫ﺍﺴﺘﺨﺩﺍﻡ ‪ QReport‬ﻓﻲ ﺩﻟﻔﻲ ‪ 7‬ﺃﻀﻑ ﻫﺫﻩ ﺍﻟﺼﻔﺤﺔ ﻋﻥ ﻁﺭﻴﻕ ‪:‬‬
‫‪Commponnant Æ install package Æ add‬‬
‫ﺃﻀﻑ ﺍﻟﻭﺤﺩﺓ ‪ dclqrt60.bpl‬ﻤﻥ ﺍﻟﻔﻬﺭﺱ ‪ Bin‬ﺩﺍﺨل ﻤﺠﻠﺩ ‪. Delphi7‬‬
‫ﻟﻁﺒﺎﻋﺔ ﺩﻟﻴل ﺍﻟﻬﺎﺘﻑ ‪:‬‬
‫ﺃﻀﻑ ﻭﺤﺩﺓ ﺠﺩﻴﺩﺓ ﺇﻟﻰ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺃﻀﻑ ﺍﺴﻡ ﺍﻟﻭﺤﺩﺓ ‪ Main‬ﺇﻟﻰ ﺍﻟﻘﺴﻡ ‪ Uses‬ﻟﻬﺫﻩ ﺍﻟﻭﺤﺩﺓ ﻭﺫﻟﻙ ﻟﻜﻲ ﻨـﺘﻤﻜﻥ ﻤـﻥ‬
‫ﺍﻟﻭﺼﻭل ﺇﻟﻰ ﺍﻟﻌﻨﺼﺭ ‪ Table1‬ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻷﻭل ﻭﺃﻋﻁﻬﺎ ﺍﻟﺨﺎﺼﺔ ‪. Printform Name‬‬
‫ﻭﺃﻀﻑ ﺇﻟﻴﻬﺎ ﺍﻟﻌﻨﺼﺭ ‪ QuickRep‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪ Qreport‬ﻭﺃﻋﻁﻪ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﺃﻋﻁ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻟﻠﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻀﻤﻥ ﺍﻟﺨﺎﺼﺔ ‪ HasColumnHeader : Band‬ﻭ ‪ HasDetail‬ﻭ‬
‫‪ HasPageHeader‬ﻭ ‪. HasPagefooter‬‬
‫ﺍﻟﺨﺎﺼﺔ ‪ Dataset‬ﺃﻋﻁﻬﺎ ﺍﻟﻘﻴﻤﺔ ‪. Form1.DataSource1‬‬
‫ﺃﻀﻑ ﺍﻵﻥ ﺍﻟﻌﺼﺭ ‪ QRlabel‬ﺇﻟﻰ ﺍﻟﻘﺴﻡ ‪ Page Header‬ﺃﻭ ﺃﻋﻁﻪ ﺍﻟـ ‪ " Caption‬ﺒﺭﻨﺎﻤﺞ ﺩﻟﻴل ﺍﻟﻬﺎﺘﻑ "‬
‫ﺃﻀﻑ ﻟﻠـ ‪ Column Header‬ﻋﺩﺩ ﻤﻥ ﺍﻟﻌﻨﺎﺼﺭ ‪ QRlabel‬ﻜﻤﺎ ﻓﻲ ﺍﻟﺸﻜل ‪:‬‬

‫ﺃﻀﻑ ﺇﻟﻰ ‪ Detail‬ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﻌﻨﺎﺼﺭ ‪ QRDbText‬ﻭﺍﺭﺒﻁﻬﺎ ﻤﻊ ﺍﻟﺤﻘﻭل ﺍﻟﻤﻨﺎﺴﺒﺔ ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ Dataset‬ﻜﻤﺎ‬

‫ﻓﻲ ﺍﻟﺸﻜل ﺍﻟﺴﺎﺒﻕ ‪.‬‬
‫ﺃﻀﻑ ﺇﻟﻰ ‪ Page Footer‬ﺍﻟﻌﻨﺼﺭ ‪ QRSysData‬ﻭﺃﻋﻁﻪ ﺍﻟﺨﺎﺼﺔ ‪ data‬ﺍﻟﻘﻴﻤﺔ ‪... Page Number‬‬
‫ﺍﺤﻔﻅ ﺍﻟﻭﺤﺩﺓ ﺒﺎﺴﻡ ‪. PrintUnit‬‬
‫ﺍﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﻤﻴﻨﻲ ﻋﻠﻰ ﺍﻟﻌﻨﺼﺭ ‪ QUickRep1‬ﻭﺍﺨﺘﺭ ‪ Preview‬ﻟﺘﺸﺎﻫﺩ ﺍﻟﻨﺘﺎﺌﺞ ‪.‬‬
‫ﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﻁﺒﺎﻋﺔ ﻓﻲ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻷﻭل ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪Printform.QuickRep1.Preview‬‬

‫‪146‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ‪23‬‬
‫ﻟﻤﺴﺎﺕ ﺒﺭﻤﺠﻴﺔ ‪:‬‬
‫ﻴﻤﻜﻥ ﺃﻥ ﻨﻌﺘﺒﺭ ﺒﺭﻨﺎﻤﺞ ﺍﻟﻬﺎﺘﻑ ﺒﺭﻨﺎﻤﺞ ﺠﺎﻫﺯ ﻟﻠﺘﻭﺯﻴﻊ ﻭﺍﻟﻨﺸﺭ ﻭﻟﻜﻥ ﺒﺈﻀﺎﻓﺔ ﺒﻌﺽ ﺍﻟﻠﻤﺴﺎﺕ ﺇﻟﻰ ﺍﻟﺒﺭﻨـﺎﻤﺞ ﻴﻤﻜـﻥ ﺃﻥ‬
‫ﻨﺤﻭل ﻫﺫﺍ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺇﻟﻰ ﺒﺭﻨﺎﻤﺞ ﺴﻬل ﺍﻻﺴﺘﺨﺩﺍﻡ ﻭﻤﺭﻏﻭﺏ ﺒﺸﻜل ﺃﻜﺒﺭ ﻤﻥ ﻗﺒـل ﺍﻟﻤـﺴﺘﺨﺩﻤﻴﻥ‪ ،‬ﻭﺃﻗـﺼﺩ ﺒﺎﻟﻠﻤـﺴﺎﺕ‬
‫ﻼ ﻟﺘﺴﻬﻴل ﻋﻤل ﺍﻟﻤﺴﺘﺨﺩﻡ ‪.‬‬
‫ﺍﻟﺒﺭﻤﺠﻴﺔ ﺒﻤﺠﻤﻭﻋﺔ ﺍﻷﻋﻤﺎل ﺍﻟﺘﻲ ﻴﻘﻭﻡ ﺒﻬﺎ ﺍﻟﻤﺒﺭﻤﺞ ﻭﺍﻟﺘﻲ ﻴﻤﻜﻥ ﺃﻥ ﺘﺄﺨﺫ ﻭﻗﺕ ﻁﻭﻴ ﹰ‬
‫‪ 1‬ـ ﺘﻤﻜﻴﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻤﻥ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒﺩﻭﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻔﺄﺭﺓ ﻭﺒﺄﺴﺭﻉ ﺍﻟﻁﺭﻕ ﺍﻟﻤﻤﻜﻨﺔ ‪:‬‬
‫ﻼ ﻋﻨﺩﻤﺎ ﻴﻜﺘﺏ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺍﺴﻡ ﻟﻠﺒﺤﺙ ﻋﻨﻪ ﻀﻤﻥ ‪ Edit1‬ﻓﻼ ﺤﺎﺠﺔ ﻷﻥ ﻴﻌﻭﺩ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺇﻟﻰ ﺍﻟﻔﺄﺭﺓ ﻟﻴـﻀﻐﻁ ﻋﻠـﻰ‬
‫ﻤﺜ ﹰ‬
‫ﺍﻟﺯﺭ ﻟﻜﻲ ﻴﺘﻡ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺤﺙ ﺒل ﻴﻜﻔﻲ ﺃﻥ ﻴﻀﻐﻁ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻠﻰ ﺍﻟﺯﺭ ﺇﺩﺨﺎل ) ‪ ( Enter‬ﻤﻥ ﻟﻭﺤﺔ ﺍﻟﻤﻔﺎﺘﻴﺢ ﻟﻴﺘﻡ ﺍﻟﺒﺤـﺙ‬
‫ﻭﻟﺘﺤﻘﻴﻕ ﺫﻟﻙ ﺒﺭﻤﺠﻴﹰﺎ ‪ :‬ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ‪ OnKeyPress‬ﻟﻠﻌﻨﺼﺭ ‪: Edit1‬‬
‫‪if key = char( VK_Return ) then‬‬
‫; ‪btnsearch.Click‬‬
‫ﺤﻴﺙ ‪ VK_Return‬ﺜﺎﺒﺕ ﻤﻌﺭﻑ ﻓﻲ ﺩﻟﻔﻲ ﻭﻴﺤﻭﻱ ﺸﻴﻔﺭﺓ ﺍﻷﺴﻜﻲ ﻟﻠﺯﺭ ‪ ،Enter‬ﻓﻲ ﺍﻟﺤﻘﻴﻘﺔ ﻴﺠﻭﺩ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﻫـﺫﻩ‬
‫ﺍﻟﺜﻭﺍﺒﺕ ﻭﺍﻟﺘﻲ ﺘﺤﻭﻱ ﺸﻴﻔﺭﺓ ﺍﻷﺯﺭﺍﺭ ﺍﻻﻓﺘﺭﺍﻀﻴﺔ ) ‪ ( Virtual Key‬ﻭﻫﺫﻩ ﺍﻷﺯﺭﺍﺭ ﻫﻲ ﺍﻟﻤﻔﺎﺘﻴﺢ ‪ F1..F12‬ﻭ ﻤﻔﺎﺘﻴﺢ‬
‫ﺍﻷﺴﻬﻡ ﻭ ‪ Tab‬ﻭ ‪ Caps lock‬ﻭ ‪ Delete‬ﻭ ‪) ... End‬ﺃﻱ ﻤﺠﻤﻭﻋﺔ ﺃﺯﺭﺍﺭ ﻟﻭﺤﺔ ﺍﻟﻤﻔﺎﺘﻴﺢ ﻋﺩﺍ ﺍﻷﺤﺭﻑ ﻭﺍﻷﺭﻗﺎﻡ(‬
‫ﻭﻟﻠﺘﻌﺭﻑ ﻋﻠﻰ ﻫﺫﻩ ﺍﻟﺜﻭﺍﺒﺕ ﺭﺍﺠﻊ ﻤﻠﻔﺎﺕ ﺍﻟﻤـﺴﺎﻋﺩﺓ ﻓـﻲ ﺩﻟﻔـﻲ ﺃﻭ ﺍﻜﺘـﺏ ﻓـﻲ ﻤﻜـﺎﻥ ﻓـﻲ ﻤﺤـﺭﺭ ﺍﻟـﺸﻴﻔﺭﺓ‬
‫_‪ Windows.VK‬ﻭﺴﺘﻜﻤل ﺩﻟﻔﻲ ﺒﻘﻴﺔ ﺍﻟﺜﻭﺍﺒﺕ‪.‬‬
‫ﻤﻼﺤﻅﺎﺕ ‪:‬‬
‫ﺃ ـ ﻴﻤﻜﻥ ﺍﻻﺴﺘﻌﺎﻀﺔ ﻋﻥ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺴﺎﺒﻘﺔ ﺒﺎﻟﺘﻌﻠﻴﻤﺔ ‪:‬‬
‫; ‪If key = #13 then btnsearch.Click‬‬
‫ﺤﻴﺙ ‪ 13‬ﻫﻲ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺘﻲ ﻴﺤﻭﻴﻬﺎ ﺍﻟﺜﺎﺒﺕ ‪ VK_Return‬ﻭﻫﻲ ﺍﻟﻘﻴﻤﺔ ﺍﻻﺴﻜﻲ ﻟﻠﺯﺭ ‪ Enter‬ﻭ ‪ #‬ﺘﺴﺘﺨﺩﻡ ﻗﺒل ﺸـﻴﻔﺭﺓ‬
‫ﻼ ﺇﺫﺍ ﻜﺘﺒﻨﺎ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪ S:=#89#111#117 :‬ﻓﻬﺫﺍ ﻴﻜﺎﻓﺊ ﺍﻟﺘﻌﻠﻴﻤﺔ =‪S :‬‬
‫ﺍﻷﺴﻜﻲ ﻟﺘﺤﻭﻴل ﺍﻟﺭﻗﻡ ﺇﻟﻰ ﺤﺭﻑ ‪ ،‬ﻤﺜ ﹰ‬
‫'‪'You‬‬
‫ﺏ ـ ﻴﻤﻜﻥ ﺍﻻﺴﺘﻌﺎﻀﺔ ﻋﻥ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺴﺎﺒﻘﺔ ﺒﺎﻟﺘﻌﻠﻴﻤﺔ ‪:‬‬
‫;)‪If key = #13 then BtnSearchClick (Sender‬‬
‫ﻻ ﻤﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﻨﻬﺞ ‪ Click‬ﻟﻠﺯﺭ ‪ BtnSearch‬ﻨﺴﺘﺨﺩﻡ ﺍﻹﺠﺭﺍﺀ ﺍﻟﺫﻱ ﻴﻘﻭﻡ ﺒﻬﺫﻩ ﺍﻟﻌﻤﻠﻴﺔ ﻤﺒﺎﺸـﺭﺓ ) ﻻ ﺤـﻅ ﺃﻥ‬ ‫ﺒﺩ ﹰ‬
‫ﺍﻹﺠﺭﺍﺀ ‪ BtnSearchClick‬ﻗﺩ ﺘﻡ ﺘﻌﺭﻴﻔﺔ ﻤﻥ ﻗﺒل ﺍﻟﺩﻟﻔﻲ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Type‬ﻭﺍﻟﻘـﺴﻡ ‪ Implementation‬ﺒﻤﺠـﺭﺩ‬
‫ﻀﻐﻁﻙ ﻋﻠﻰ ﺍﻟﺯﺭ ‪....‬‬
‫‪ 2‬ـ ﻤﻥ ﺍﻟﻤﻼﺤﻅ ﺃﻨﻨﺎ ﻨﺴﺘﺨﺩﻡ ﺍﻟﻌﻨﺼﺭ ‪ Edit2‬ﻹﺩﺨﺎل ﺍﻷﺭﻗﺎﻡ ﻓﻘﻁ ﺃﻭ ﻋﻠﻰ ﺍﻷﻗل ﺭﻤـﻭﺯ ﻟﻭﺤـﺔ ﻤﻔـﺎﺘﻴﺢ ﺍﻟﻬـﺎﺘﻑ‬
‫ﻭﺒﺎﻟﺘﺎﻟﻲ ﻴﺠﺏ ﻤﻨﻊ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻤﻥ ﺇﺩﺨﺎل ﺍﻟﺤﺭﻭﻑ ﻭﺍﻟﺭﻤﻭﺯ ﻏﻴﺭ ﺍﻟﻤﺭﻏﻭﺒﺔ ﻭﻟﺘﺤﻘﻴﻕ ﺫﻟﻙ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;])‪const s = ['0','1','2','3','4','5','6','7','8','9','p',char(VK_back‬‬
‫‪begin‬‬
‫) ‪if not ( key in s‬‬
‫)‪then key:= char(vk_capital‬‬

‫‪147‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻨﻌﺭﻑ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﺭﻤﻭﺯ ﺍﻟﺘﻲ ﻴﺴﺘﺨﺩﻤﻬﺎ ﺍﻟﻬﺎﺘﻑ ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺍﻟﺯﺭ ‪ VK_back‬ﻭ ﻫﻭ ﺯﺭ ﺍﻟﺤﺫﻑ ‪ ، Å‬ﻓﺈﺫﺍ ﻟـﻡ‬
‫ﻴﻜﻥ ﺍﻟﺯﺭ ﺍﻟﻤﺩﺨل ﻤﻥ ﻫﺫﻩ ﺍﻟﻤﺠﻤﻭﻋﺔ ﻓﺤﻭﻟﻪ ﺇﻟﻰ ﺍﻟﺯﺭ ‪ Vk_Capital‬ﻭﻫﻭ ﺯﺭ ‪ Caps Lock‬ﻭﺍﻟﺫﻱ ﻟﻥ ﻴﺅﺜﺭ ﻋﻠـﻰ‬
‫ﻭﻀﻊ ﺍﻟﺯﺭ ‪ Caps Lock‬ﻭﻟﻜﻨﻪ ﺴﻴﺼﺩﺭ ﺼﻭﺕ ﻤﺎ ‪.‬‬
‫‪ 3‬ـ ﻓﻲ ﺍﻟﻨﺎﻓﺫﺓ ﺇﺩﺨﺎل ﻋﻠﻰ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺃﻥ ﻴﻨﺘﻘل ﻤﻥ ﻋﻨﺼﺭ ﺘﺤﺭﻴﺭ ‪ DBEdit‬ﺇﻟﻰ ﺁﺨﺭ ﺒﻭﺍﺴﻁﺔ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟـﺯﺭ‬
‫‪ Tab‬ﻤﻥ ﻟﻭﺤﺔ ﺍﻟﻤﻔﺎﺘﻴﺢ ﻋﻠﻰ ﺍﻟﺭﻏﻡ ﻤﻥ ﺃﻥ ﻤﻌﻅﻡ ﺍﻟﺒﺭﺍﻤﺞ ﺍﻟﺠﻴﺩﺓ ﺘﺴﺘﺨﺩﻡ ﺍﻟﺯﺭ ‪ Enter‬ﻟﻠﺘﻨﻘل ﺒﻴﻥ ﻋﻨﺎﺼﺭ ﺍﻹﺩﺨـﺎل‬
‫ﻟﺫﻟﻙ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnKeyPress‬ﻟﻠﻌﻨﺼﺭ ‪: DBEdit1‬‬
‫; ‪If key = #13 then DBEdit2.SetFocus‬‬
‫ﻭﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ‪ OnKeyPress‬ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; ‪If key =#13 then dbedit3.SetFocus‬‬
‫ﻭﻫﻜﺫﺍ ﻓﻲ ﺒﻘﻴﺔ ﺍﻟﻌﻨﺎﺼﺭ ‪.‬‬
‫ﻼ ﺍﻟﺘﻌﻠﻴﻤـﺔ‬
‫ﺍﻟﻤﻨﻬﺞ ‪ SetFocus‬ﻴﺴﺘﺨﺩﻡ ﻟﺘﺤﻔﻴﺯ ) ﺘﻔﻌﻴل ﺍﻟﻌﻨﺼﺭ ( ﻭﻫﻭ ﻴﺴﺘﺨﺩﻡ ﻤﻊ ﻤﻌﻅﻡ ﺍﻟﻌﻨﺎﺼﺭ ﻓﻲ ﺩﻟﻔـﻲ ﻓﻤـﺜ ﹰ‬
‫‪ Button1.SetFocus‬ﺴﺘﻅﻬﺭ ﺇﻁﺎﺭ ﺸﻔﺎﻑ ﺩﺍﺨل ﺍﻟﺯﺭ ﻭﺍﻟﺫﻱ ﻴﻌﻨﻲ ﺃﻥ ﻫﺫﺍ ﻫﻭ ﺍﻟﺯﺭ ﺍﻟﻔﻌﺎل ﻭﺍﻟﺫﻱ ﻴﻤﻜـﻥ ﺍﻟـﻀﻐﻁ‬
‫ﻋﻠﻴﻪ ﺒﻭﺍﺴﻁﺔ ﺍﻟﺯﺭ ‪ Enter‬ﺃﻭ ﺍﻟﺯﺭ ‪ Space‬ﻤﻥ ﻟﻭﺤﺔ ﺍﻟﻤﻔﺎﺘﻴﺢ ‪.‬‬
‫‪ 4‬ـ ﺍﻟﺘﺤﻜﻡ ﺒﺘﺤﻤﻴل ﺍﻟﻨﻭﺍﻓﺫ ﻓﻲ ﺍﻟﺫﺍﻜﺭﺓ ‪:‬‬
‫ﺍﻓﺘﺢ ﺍﻟﻘﺎﺌﻤﺔ ‪ Project Æ View Source‬ﺴﻴﻅﻬﺭ ﻟﻙ ﻤﻠﻑ ﺍﻟﻤﺸﺭﻭﻉ ‪ MyPhone.Dpr‬ﻭﺴـﺘﺠﺩ ﻓﻴـﻪ ﺘﻌﺭﻴـﻑ‬
‫ﺍﻟﻭﺤﺩﺍﺕ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Uses‬ﻭ ﺴﺘﺠﺩ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺍﻟﻘﺴﻡ ‪Begin‬‬
‫;‪Application.Initialize‬‬
‫;)‪Application.CreateForm(TForm1, Form1‬‬
‫;)‪Application.CreateForm(TDataEnter, DataEnter‬‬
‫;)‪Application.CreateForm(TForm2, Form2‬‬
‫;‪Application.Run‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ )‪ Application.CreateForm ( TFom1,Form1‬ﺘﻘﻭﻡ ﺒﺈﻨﺸﺎﺀ ﺍﻟﻨﺎﻓـﺫﺓ ‪ Form1‬ﻭﺍﻟﺘـﻲ ﻤـﻥ ﺍﻟﻨـﻭﻉ‬
‫‪ TForm1‬ﻭﺍﻟﻤﻌﺭﻑ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Interface‬ﻟﻠﻭﺤﺩﺓ ‪ Main.pas‬ﺍﻟﺘﻲ ﻴﺘﺒﻊ ﻟﻬﺎ ﺍﻟﻨﻤﻭﺫﺝ ‪ Form1‬ﻭﻜﺫﻟﻙ ﺍﻷﻤﺭ ﺒﺎﻟﻨﺴﺒﺔ‬
‫ﻟﺘﻌﻠﻴﻤــﺎﺕ ‪ CreateForm‬ﺍﻟﺘﺎﻟﻴــﺔ ‪ ،‬ﻭﻟﻜــﻥ ﻤــﺎﺫﺍ ﻴﻌﻨــﻲ ﺇﻨــﺸﺎﺀ ﻨﺎﻓــﺫﺓ‪ ....‬ﻋﻨــﺩ ﺍﺴــﺘﺨﺩﺍﻡ ﺍﻟﺘﻌﻠﻴﻤــﺔ‬
‫)‪Application.CreateForm ( TFom1,Form1‬‬
‫‪ 1‬ـ ﺴﻴﺘﻡ ﺇﻨﺸﺎﺀ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﻓﻲ ﺍﻟﺫﺍﻜﺭﺓ ) ﺃﻱ ﺤﺠﺯ ﺤﻴﺯ ﻓﻲ ﺍﻟﺫﺍﻜﺭﺓ ﻴﺤﻭﻱ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﻲ ﺴﺘﻅﻬﺭ ( ‪.‬‬
‫‪ 2‬ـ ﺴﻴﺘﻡ ﺇﻨﺸﺎﺀ ﺠﻤﻴﻊ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻋﻠﻰ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﻤﻥ ﺃﺯﺭﺍﺭ ﻭ ﻋﻨﺎﺼﺭ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ‪....‬‬
‫‪ 3‬ـ ﺴﻴﺘﻡ ﺤﺠﺯ ﺍﻟﻤﺘﺤﻭﻻﺕ ﺍﻟﻌﺎﻤﺔ ﻭﺇﻋﻁﺎﺀﻫﺎ ﺤﻴﺯ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ ﺃﻴﻀﹰﺎ ‪.‬‬
‫‪ 4‬ـ ﺴﻴﺘﻡ ﺘﻨﻔﻴﺫ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﻲ ﺘﻡ ﻭﻀﻌﻬﺎ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnCreate‬ﺍﻟﺘﺎﺒﻊ ﻟﻠﻨﻤﻭﺫﺝ ‪. Form1‬‬
‫ﺴﻴﺘﻡ ﺍﻵﻥ ﺘﻨﻔﻴﺫ ﻫﺫﻩ ﺍﻟﺨﻁﻭﺍﺕ ﺒﺎﻟﻨﺴﺒﺔ ﻟﻠﻨﻭﺍﻓﺫ ﺍﻟﺜﻼﺜﺔ ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﻓﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪ ،‬ﻟـﻨﻘﻡ ﺍﻵﻥ ﺒﺩﺭﺍﺴـﺔ ﺒـﺴﻴﻁﺔ ﻟﺤﺠـﻡ‬
‫ﺍﺴﺘﺨﺩﺍﻡ ﻜل ﻨﺎﻓﺫﺓ ‪:‬‬
‫‪ 1‬ـ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻷﻭﻟﻰ ‪ : Form1‬ﺴﻴﺴﺘﺨﺩﻡ ﺃﻱ ﻤﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﻋﻨﺩ ﻜل ﺩﺨﻭل ﺇﻟﻰ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺫﻟﻙ ﻷﻨﻬـﺎ ﺘﺤـﻭﻱ‬
‫ﻋﻨﺎﺼﺭ ﺍﻟﺒﺤﺙ ﻭﺍﻟﻔﻬﺭﺴﺔ ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﻋﺭﺽ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬

‫‪148‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ 2‬ـ ﺍﻟﻨﺎﻓﺫﺓ ‪ : DataEnter‬ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﻋﺩﺓ ﻤﺭﺍﺕ ﻓﻲ ﺍﻷﺴﺒﻭﻉ ﺍﻷﻭل ﻻﺴﺘﺨﺩﺍﻡ ﺍﻟﺒﺭﻨـﺎﻤﺞ ﻷﻥ ﺍﻟﻤـﺴﺘﺨﺩﻡ‬
‫ﺴﻴﻘﻭﻡ ﺒﺈﺩﺨﺎل ﺃﺭﻗﺎﻡ ﻫﻭﺍﺘﻔﻪ ﺇﻟﻰ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺒﻌﺩ ﺫﻟﻙ ﻟﻥ ﻴﺩﺨل ﺍﻟﻤﺴﺘﺨﺩﻡ ﺇﻟﻰ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﺇﻻ ﻤﺭﺓ ﻓﻲ ﺍﻷﺴﺒﻭﻉ ﺃﻭ ﺍﻟﺸﻬﺭ‬
‫ﺃﻭ ﺤﺘﻰ ﺒﺎﻟﺴﻨﺔ ‪.‬‬
‫‪ 3‬ـ ﺍﻟﻨﺎﻓﺫﺓ ‪ : Form2‬ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﺘﺤﻭﻱ ﻋﻨﺎﺼﺭ ﺍﻟﻁﺎﺒﻌﺔ ﻭﺇﺫﺍ ﻓﺭﻀﻨﺎ ﺃﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻴﻤﻠﻙ ﻁﺎﺒﻌﺔ ﻓﺈﻨﻪ ﻟﻥ ﻴﻁﺒﻊ ﺩﻓﺘﺭ‬
‫ﻫﻭﺍﺘﻔﻪ ﻜل ﻴﻭﻡ ‪.‬‬
‫ﻫﺫﺍ ﻴﻌﻨﻲ ﺃﻨﻨﺎ ﻨﺤﺠﺯ ﺤﻴﺯ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ ﻟﻨﺎﻓﺫﺘﻴﻥ ﻟﻥ ﻴﺴﺘﺨﺩﻤﻬﺎ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺇﻻ ﻤﺭﺍﺕ ﻗﻠﻴﻠﺔ‪ ،‬ﻟﻬﺫﺍ ﺯﻭﺩﺘﻨـﺎ ﺩﻟﻔـﻲ ﺒﻁﺭﻴﻘـﺔ‬
‫ﻹﻨﺸﺎﺀ ﺍﻟﻨﻤﻭﺫﺝ ﻋﻥ ﺍﻟﺤﺎﺠﺔ ﺇﻟﻴﻪ ﻭﺫﻟﻙ ﻋﻥ ﻁﺭﻴﻕ ‪:‬‬
‫ﺃ ـ ﺇﺯﺍﻟﺔ ﺍﻟﻨﻤﻭﺫﺝ ﻤﻥ ﻗﺎﺌﻤﺔ ﺍﻟﺘﺤﻤﻴل ﺍﻟﺘﻠﻘﺎﺌﻲ ‪:‬‬
‫ﺍﻓﺘﺢ ﺍﻟﻘﺎﺌﻤﺔ ‪ Project Æ Options‬ﻟﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﺎﻟﻴﺔ ‪ :‬ﺤﺩﺩ ﻤﻨﻬـﺎ‬
‫ﺍﻟﺼﻔﺤﺔ ‪ Forms‬ﻭﺍﻟﺘﻲ ﻓﻴﻬﺎ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﻤﻨﺴﺩﻟﺔ ‪ Main Form‬ﻭﻫﻲ ﺘﺤﺩﺩ‬
‫ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺫﻱ ﺴﻴﻅﻬﺭ ﻋﻨﺩ ﺘﺸﻐﻴل ﺍﻟﺒﺭﻨﺎﻤﺞ‪.‬‬
‫ﺍﻟﻼﺌﺤﺔ ‪ Auto-Create Forms‬ﻭﺘﻅﻬﺭ ﻓﻴﻬﺎ ﺃﺴﻤﺎﺀ ﺍﻟﻨﻤﺎﺫﺝ ﺍﻟﺘﻲ ﺴﻴﺘﻡ‬
‫ﺇﻨﺸﺎﺀﻫﺎ ﺘﻠﻘﺎﺌﻴﹰﺎ ﻋﻨﺩ ﺘﺸﻐﻴل ﺍﻟﺒﺭﻨﺎﻤﺞ ‪،‬‬
‫ﺍﻟﻼﺌﺤﺔ ‪ Available Form‬ﻭﺘﺤﻭﻱ ﺠﻤﻴﻊ ﺒﻘﻴﺔ ﺍﻟﻨﻭﺍﻓﺫ ﻓـﻲ ﺍﻟﺒﺭﻨـﺎﻤﺞ‬
‫ﻭﺍﻟﺘﻲ ﻻ ﺘﻭﺠﺩ ﻓﻲ ﻻﺌﺤﺔ ﺍﻟﺘﺸﻐﻴل ﺍﻟﺘﻠﻘﺎﺌﻲ‪.‬‬
‫ﺤﺩﺩ ﺍﻟﻨﻭﺍﻓﺫ ﺍﻟﺘﻲ ﻻ ﺘﺭﻴﺩ ﺃﻥ ﺘﻌﻤل ﺘﻠﻘﺎﺌﻴﹰﺎ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺴﻬﻡ > ﻟﺘﻨﺘﻘل ﻫﺫﻩ ﺍﻻﺴﻤﺎﺀ ﺇﻟﻰ ﺍﻟﻼﺌﺤﺔ ‪Avialable Form‬‬
‫‪.‬‬
‫ﺏ ـ ﺇﻨﺸﺎﺀ ﺍﻟﻨﻤﻭﺫﺝ ﻋﻨﺩ ﺍﻟﻁﻠﺏ ‪:‬‬
‫ﺒﻤﺎ ﺃﻨﻪ ﺍﻟﻨﺎﻓﺫﺓ ﻟﻥ ﺘﻨﺸﺄ ﺘﻠﻘﺎﺌﻴﹰﺎ ﻓﻌﻠﻴﻨﺎ ﺃﻥ ﻨﻜﺘـﺏ ﺒﻌـﺽ ﺍﻟﺘﻌﻠﻴﻤـﺎﺕ ﻹﻨـﺸﺎﺌﻬﺎ ﻗﺒـل ﺍﺴـﺘﺨﺩﺍﻡ ﺍﻟﻤـﻨﻬﺞ ‪ Show‬ﺃﻭ‬
‫‪ ShowModal‬ﺃﻭ ﺤﺘﻰ ﻗﺒل ﻁﻠﺏ ﺃﻱ ﻤﺘﺤﻭل ﻤﺎ ﻤﻨﻬﺎ ﻟﺫﻟﻙ ﻟﻨﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠـﻰ ﺍﻟـﺯﺭ‬
‫ﺇﺩﺨﺎل ‪:‬‬
‫;)‪Dataenter := TDataEnter.Create(application‬‬
‫‪Try‬‬
‫;‪DataEnter.Showmodal‬‬
‫‪Finally‬‬
‫; ‪DataEnter.Release‬‬
‫;‪end‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻷﻭﻟﻰ ﺘﻘﻭﻡ ﺒﺈﻨﺸﺎﺀ ﺍﻟﻤﺘﺤﻭل ‪ DataEnter‬ﻤﻥ ﺍﻟﻨﻭﻉ ‪ ) TDataEnter‬ﺍﻟﻤﻌﺭﻑ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Var‬ﺍﻟﺘﺎﺒﻊ ﻟﻠﻘـﺴﻡ‬
‫‪ Interface‬ﻓﻲ ﺍﻟﻭﺤﺩﺓ ‪ ( DataEnterU.pas‬ﻭﻴﺄﺨﺫ ﺍﻟﻤﻨﻬﺞ ‪ Create‬ﻟﻌﻨﺎﺼﺭ ‪ Delphi‬ﻭﺴﻴﻁﹰﺎ ﻭﺤﻴﺩﹰﺍ ﻴـﺩل ﻋﻠـﻰ‬
‫ﺍﻟﻌﻨﺼﺭ ﺍﻟﻤﺎﻟﻙ ﻟﻠﻌﻨﺼﺭ ﺍﻟﻤﺭﺍﺩ ﺇﻨﺸﺎﺌﻪ ﻭﺘﻤﺭﺭ ﻫﻨﺎ ﺍﻟﻘﻴﻤﺔ ‪ Application‬ﻋﺎﺩﺓ ﻷﻥ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﻤﻨﺸﺄ ﺴـﻴﻌﻭﺩ ﻟﺘﻁﺒﻴـﻕ‬
‫ﻤﺒﺎﺸﺭﺓ ‪.‬‬

‫‪149‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ DataEnter.Release‬ﻫﻲ ﻋﻤﻠﻴﺔ ﻹﺯﺍﻟﺔ ﺍﻟﻨﻤﻭﺫﺝ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ ﺒﻌﺩ ﺍﻨﺘﻬﺎﺀ ﻋﻤﻠـﻪ ﻭﺍﻟﺘـﻲ ﻴﻤﻜـﻥ ﺍﺴـﺘﺒﺩﺍﻟﻬﺎ‬
‫ﺒﺎﻟﺘﻌﻠﻴﻤﺔ ‪ DataEnter.Free‬ﻭﻟﻜﻥ ﺍﻟﻤﻨﻬﺞ ‪ Release‬ﻴﻌﺘﺒﺭ ﺃﻓﻀل ﻷﻨﻪ ﻻ ﻴﻌﻴﺩ ﺭﺴﺎﻟﺔ ﺨﻁﺄ ﺇﺫﺍ ﻟﻡ ﻴﻜﻥ ﺍﻟﻨﻤﻭﺫﺝ ﻤﻨﺸًﺄ‬
‫ﺒﺎﻟﻔﻌل ‪.‬‬
‫ﻻ ﻤﻥ ﺍﻟﻤﻨﻬﺞ ‪ ShowModal‬ﻓﻴﺠﺏ ﺇﻀﺎﻓﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻟﻠﺘﺄﻜـﺩ ﻤـﻥ ﻋﻤـل‬
‫ﺇﺫﺍ ﻜﻨﺎ ﻨﺴﺘﺨﺩﻡ ﺍﻟﻤﻨﻬﺞ ‪ Show‬ﺒﺩ ﹰ‬
‫ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒﺸﻜل ﺼﺤﻴﺢ ‪:‬‬
‫ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnClose‬ﻟﻠﻨﺎﻓﺫﺓ ‪ DataEnter‬ﺃﻀﻑ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪action := Cafree‬‬
‫;‪DataEnter := nil‬‬
‫ﻭﺍﻜﺘﺏ ﺍﻵﻥ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺇﺩﺨﺎل ) ﻓﻲ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻷﻭل ( ‪:‬‬
‫‪If DataEnter = nil then‬‬
‫;)‪DataEnter := TDataEnter.Create(application‬‬
‫;‪DataEnter.Show‬‬
‫ﺍﻟﺤﺩﺙ ‪ OnClose‬ﻟﻨﺎﻓﺫﺓ ﻴﺘﻡ ﺘﻨﻔﻴﺫﻩ ﻋﻨﺩﻤﺎ ﻴﺘﻡ ﺇﻏﻼﻕ ﺍﻟﻨﺎﻓﺫﺓ ) ﻀﻐﻁ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻠﻰ ﺯﺭ ﺇﻏﻼﻕ ( ﻭﻴﺄﺨﺫ ﻫﺫﺍ ﺍﻟﺤـﺩﺙ‬
‫ﺍﻟﻭﺴﻴﻁ ‪ Action‬ﻭﺍﻟﺫﻱ ﻴﻤﻜﻥ ﺃﻥ ﻴﺄﺨﺫ ﺍﻟﻘﻴﻡ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﺍﻟﻤﻌﻨﻰ‬ ‫ﺍﻟﻘﻴﻤﺔ‬
‫ﻻ ﻴﻤﻜﻥ ﺇﻏﻼﻕ ﺍﻟﻨﺎﻓﺫﺓ ﻭﻟﻥ ﻴﺤﺩﺙ ﺸﻲﺀ ﺇﺫﺍ ﻀﻐﻁ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻠﻰ ﺍﻟﺯﺭ ﺇﻏﻼﻕ‬ ‫‪CaNone‬‬
‫ﺴﻴﺘﻡ ﺇﻏﻼﻕ ﺍﻟﻨﺎﻓﺫﺓ ﻭﺘﺤﺭﻴﺭ ﻜﺎﻤل ﺍﻟﺫﺍﻜﺭﺓ ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﻤﻥ ﻗﺒﻠﻬﺎ‬ ‫‪CaFree‬‬
‫ﻻ ﻤﻥ ﺇﻏﻼﻗﻬﺎ ﻭﻴﻤﻜﻥ ﺇﻋﺎﺩﺓ ﺇﻅﻬﺎﺭﻫﺎ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﻤﻨﻬﺞ ‪ Show‬ﻭﻫﻭ ﺍﻟﺨﻴـﺎﺭ‬
‫ﺴﻴﺘﻡ ﺇﺨﻔﺎﺀ ﺍﻟﻨﺎﻓﺫﺓ ﺒﺩ ﹰ‬ ‫‪CaHide‬‬
‫ﺍﻻﻓﺘﺭﺍﻀﻲ ﻟﻠﻨﻭﺍﻓﺫ ﻤﻥ ﺍﻟﻨﻭﻉ ‪FormStyle := fsNormal‬‬
‫‪ CaMinimize‬ﺴﻴﺘﻡ ﺘﺼﻐﻴﺭ ﺍﻟﻨﺎﻓﺫﺓ ﻭﻫﻭ ﺍﻟﺨﻴﺎﺭ ﺍﻻﻓﺘﺭﺍﻀﻲ ﻤﻊ ﺍﻟﻨﻭﺍﻓﺫ ﻤﻥ ﺍﻟﻨﻭﻉ ‪fsMDIChild‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ DataEnter = Nil‬ﺘﻘﻭﻡ ﺒﺘﺤﻤﻴل ﻗﻴﻤﺔ ﺍﻟﻼﺸﻲﺀ ) ‪ ( Null‬ﻓﻲ ﺍﻟﻤﺘﺤﻭل ‪ DataEnter‬ﺍﻷﻤﺭ ﺍﻟـﺫﻱ ﻴﺠﻌﻠﻨـﺎ‬
‫ﻓﻴﻤﺎ ﺒﻌﺩ ﺃﻥ ﺍﻟﺤﺩﺙ ‪ OnClose‬ﻗﺩ ﺘﻡ ﺘﻨﻔﻴﺫﻩ ﻭﻤﻥ ﺜﻡ ﺘﻨﻔﻴﺫ ﻋﻤﻠﻴﺔ ﺇﻨﺸﺎﺀ ﺍﻟﻨﻤﻭﺫﺝ ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻫﺫﻩ ﺇﺤﺩﻯ ﺍﻟﻁﺭﻕ ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﻹﻨﺸﺎﺀ ﺍﻟﻨﺎﻓﺫﺓ ﺒﺸﻜل ﺩﻴﻨﺎﻤﻴﻜﻲ ﻭﻫﻨﺎﻙ ﻁﺭﻕ ﺃﺨﺭﻯ ﻤﺘﻌﺩﺩﺓ ‪.‬‬

‫ﻤﺴﺠل ﺍﻟﻨﻅﺎﻡ ‪: Windows Registry‬‬

‫ﻤﺴﺠل ﺍﻟﻨﻅﺎﻡ ﻋﺒﺎﺭﺓ ﻋﻥ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﻤﻠﻔﺎﺕ ﻴﺘﻡ ﺘﺨﺯﻴﻥ ﻓﻴﻪ ﺠﻤﻴﻊ ﻤﻌﻠﻭﻤﺎﺕ ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ‪ Windows‬ﺒﻤـﺎ ﻓﻴﻬـﺎ‬
‫ﺨﺼﺎﺌﺹ ﺍﻟﻨﻅﺎﻡ ﻭﺍﺴﻡ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻭﺍﺴﻡ ﺍﻟﻜﻤﺒﻴﻭﺘﺭ ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺃﻥ ﻤﻌﻅﻡ ﺍﻟﺒﺭﺍﻤﺞ ﺘﻀﻴﻑ ﺒﻌﺽ ﺍﻟﻤﻔﺎﺘﻴﺢ ﺇﻟﻰ ﻤـﺴﺠل‬
‫ﺍﻟﻨﻅﺎﻡ ﻟﻠﺘﺤﻜﻡ ﺒﻁﺭﻴﻘﺔ ﺇﻅﻬﺎﺭ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺤﺴﺏ ﺨﻴﺎﺭﺍﺕ ﻴﺤﺩﺩﻫﺎ ﺍﻟﻤﺴﺘﺨﺩﻡ ‪ ،‬ﻴﺩﻋﻰ ﻤﺴﺠل ﺍﻟﻨﻅﺎﻡ ﺒﻘﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﺍﻟﻨﻅـﺎﻡ‬
‫ﻭﻴﻜﻭﻥ ﻤﺨﺯﻥ ﻓﻲ ﺍﻟﻤﻠﻔﻴﻥ ‪ System.dat‬ﻭ ‪ User.dat‬ﺍﻟﻤﻭﺠﻭﺩﻴﻥ ﺩﺍﺨل ﻓﻬﺭﺱ ﺍﻟﻭﻴﻨﺩﻭﺯ ‪،‬ﻟﻤﺸﺎﻫﺩﺓ ﻤـﺴﺠل ﺍﻟﻨﻅـﺎﻡ‬
‫ﻭﺘﺤﺭﻴﺭﻩ ﺍﻓﺘﺢ ﺍﻟﻘﺎﺌﻤﺔ ﺃﺒﺩﺃ ﻭ ﺍﻀﻐﻁ ﻋﻠﻰ ‪ Run‬ﻭﺍﻜﺘﺏ ‪ Regedit‬ﻓﻲ ﺍﻟﻨﺎﻓﺫﺓ ﺘﺸﻐﻴل ﺜﻡ ﺍﻀﻐﻁ ﻋﻠﻰ ‪. Ok‬‬

‫‪150‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺴﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﺎﻟﻴﺔ ﻭﺍﻟﺘﻨﻲ ﺘﺤـﻭﻱ ﻓـﻲ ﺠﻬـﺔ‬
‫ﺍﻟﻴﻤﻴﻥ ﺴﺘﺔ ﻤﻥ ﺍﻟﻤﻔﺎﺘﻴﺢ ﺍﻟﺭﺌﻴﺴﻴﺔ ﺘﺩﻋﻰ ﻋـﺎﺩﺓ ﻤﻔـﺎﺘﻴﺢ‬
‫ﺍﻟﺠﺫﺭ ‪ ، Root key‬ﺒﺎﻟﻀﻐﻁ ﻋﻠﻰ ﺇﺸﺎﺭﺓ ‪ +‬ﺒﺠﺎﻨﺏ ﻫﺫﻩ‬
‫ﺍﻟﻤﻔﺎﺘﻴﺢ ﺘﻅﻬﺭ ﻟﻬﺎ ﻤﻔﺎﺘﻴﺢ ﻓﺭﻋﻴﺔ ﻭ ﺍﻟﺘﻲ ﻴﻤﻜﻥ ﺍﻟﻭﺼـﻭل‬
‫ﻤﻥ ﺨﻼﻟﻬﺎ ﺇﻟﻰ ﻤﻔﺎﺘﻴﺢ ﻓﺭﻋﻴﺔ ﺃﺨﺭﻯ‪ ،‬ﺘﺩﻋﻰ ﺍﻟﺭﻤﻭﺯ ﺍﻟﺘﻲ‬
‫ﺘﻅﻬﺭ ﻋﻠﻰ ﺍﻟﻘﺴﻡ ﺍﻟﻴﻤﻴﻨﻲ ﻤﻥ ﺍﻟﻨﺎﻓﺫﺓ ﺒﺎﻟﻘﻴﻡ ﻭﻫـﻲ ﻋﻠـﻰ‬
‫ﺜﻼﺜﺔ ﺃﻨﻭﺍﻉ ‪،‬‬
‫ﻗﻴﻡ ﻋﺩﺩﻴﺔ ﻭ ﻗﻴﻡ ﻨﺼﻴﺔ ﻭﻗﻴﻡ ﻤﻨﻁﻘﻴﺔ ‪،‬‬
‫ﻗﺒل ﺃﻥ ﺘﻌﺩل ﺃﻱ ﻗﻴﻤﺔ ﻤﺎ ﻓﻲ ﻤﺴﺠل ﺍﻟﻨﻅﺎﻡ ﻋﻠﻴﻙ ﺃﻥ ﺘﻌﺭﻑ ﻤﺎ ﺘﻔﻌل ﻷﻥ ﺒﻌﺽ ﺍﻟﺘﻌﺩﻴﻼﺕ ﻗﺩ ﺘﺅﺩﻱ ﺇﻟﻰ ﺘﻭﻗﻑ ﺍﻟﻨﻅﺎﻡ‬
‫ﻋﻥ ﺍﻟﻌﻤل ﺃﻭ ﺘﻌﻁﻴل ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﺫﻱ ﻋﺩﻟﺘﻪ ﻋﻠﻰ ﺍﻷﻗل ‪ ،‬ﻴﻤﻜﻨﻙ ﺃﻥ ﺘﺄﺨﺫ ﻨﺴﺨﺔ ﻋﻥ ﻤﺴﺠل ﺍﻟﻨﻅﺎﻡ ﺃﻭ ﻋﻥ ﺠـﺯﺀ ﻤﻨـﻪ‬
‫ﻀﻊ ﺤﺩﺩ ﺒﻤﺅﺸﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻤﻔﺘﺎﺡ ﺍﻟﺫﻱ ﺘﺭﻴﺩ ﺃﺨﺫ ﻨﺴﺨﻪ ﻤﻨﻪ ﻭﺍﺨﺘﺭ ﺍﻷﻤﺭ ‪ Regestry Æ Export‬ﺴـﺘﻁﺎﻟﺏ ﺒﺈﺩﺨـﺎل‬
‫ﺍﺴﻡ ﻤﻠﻑ ﻤﺎ ﻭﺴﻴﺘﻡ ﺒﻌﺩﻫﺎ ﺤﻔﻅ ﻨﺴﺨﺔ ﻋﻥ ﺍﻟﻤﻔﺘﺎﺡ ‪ ،‬ﻻﺴﺘﻌﺎﺩﺓ ﻤﺴﺠل ﺍﻟﻨﻅﺎﻡ ﺍﻀﻐﻁ ﻤﺭﺘﻴﻥ ﻋﻠﻰ ﻤﻠﻑ ﺍﻟﻤﻠـﻑ ﺍﻟـﺫﻱ‬
‫ﻜﻨﺕ ﻗﺩ ﺤﻔﻅﺘﻪ ﺴﺎﺒﻘﹰﺎ ‪.‬‬
‫ﺴﺄﺸﺭﺡ ﺒﺸﻜل ﻤﻭﺠﺯ ﻤﺎﻫﻲ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﺍﻟﻤﺨﺯﻨﺔ ﻓﻲ ﻜل ﻤﻔﺘﺎﺡ ﺭﺌﻴﺴﻲ ‪:‬‬
‫‪ : HKEY_ClASSES_ROOT‬ﻴﺤﻭﻱ ﻫﺫﺍ ﺍﻟﻤﻔﺘﺎﺡ ﻤﻌﻠﻭﻤﺎﺕ ﻋﻥ ﻜل ﺃﻨﻭﺍﻉ ﺍﻟﻤﻠﻔﺎﺕ ﺍﻟﻤﻌﺭﻓﺔ ﻓﻲ ﺍﻟﻨﻅﺎﻡ ) ﻻ ﺤﻅ‬
‫ﺃﻨﻪ ﻴﺤﻭﻱ ﻗﺎﺌﻤﺔ ﺒﺠﻤﻴﻊ ﺍﻤﺘﺩﺍﺩﺍﺕ ﺍﻟﻤﻠﻔﺎﺕ ﺍﻟﺘﻲ ﻴﺘﻌﺎﻤل ﻤﻌﻬﺎ ﻭﻴﻨﺩﻭﺯ ( ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﻤﻌﻠﻭﻤﺎﺕ ﻋﻥ ﺍﻟﺒـﺭﺍﻤﺞ ﺍﻟﻘـﺎﺩﺭﺓ‬
‫ﻼ ‪ .jpg‬ﺃﻭ ‪... .Doc‬‬
‫ﻋﻠﻰ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻫﺫﻩ ﺍﻟﻤﻠﻔﺎﺕ ﻤﺜ ﹰ‬
‫‪ : HKEY_CURRENT_USER‬ﻴﺤﻭﻱ ﻤﻌﻠﻭﻤﺎﺕ ﻋﻥ ﻤﺴﺘﺨﺩﻡ ﺍﻟﻨﻅﺎﻡ ﻭﺍﻟﻘﻴﻡ ﺍﻻﻓﺘﺭﺍﻀﻴﺔ ﺍﻟﺘﻲ ﺃﻋﻁﺎﻫـﺎ ﻟـﺒﻌﺽ‬
‫ﺒﺭﺍﻤﺞ ﺍﻟﻭﻴﻨﺩﻭﺯ ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺍﻟﺨﺼﺎﺌﺹ ﻟﻭﺤﺔ ﺍﻟﺘﺤﻜﻡ ﻭﺍﻟﺒﺭﺍﻤﺞ ﺍﻟﺘﻲ ﺘﻨﺼﺒﻬﺎ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻠﻰ ﺍﻟﺠﻬﺎﺯ ‪.....‬‬
‫‪ : HKEY_LOCAL_MACHINE‬ﻴﺤﻭﻱ ﻤﻌﻠﻭﻤﺎﺕ ﻋﻥ ﺠﻬﺎﺯ ﺍﻟﺤﺎﺴﻭﺏ ﺒﺎﻟﻜﺎﻤل ﺒﻤﺎ ﻓﻴﻬـﺎ ﺃﻨـﻭﺍﻉ ﺍﻷﺠﻬـﺯﺓ‬
‫ﻼ ﺘﺴﺘﻁﻴﻊ ﻤﻌﺭﻓﺔ ﻨﻭﻋﻴﺔ ﻜﺭﺕ ﺍﻟـﺸﺎﺸﺔ‬
‫ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﻓﻲ ﺍﻟﺠﻬﺎﺯ ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﻤﺸﻐﻼﺕ ﻫﺫﻩ ﺍﻷﺠﻬﺯﺓ ) ‪ ( Driver‬ﻤﺜ ﹰ‬
‫ﺍﻟﻤﺴﺘﺨﺩﻡ ﻭﻨﻭﻋﻴﺔ ﺍﻟﺸﺎﺸﺔ ﺍﻟﻤﻌﺭﻓﺔ ﻋﻠﻰ ﺍﻟﺠﻬﺎﺯ ‪....‬‬
‫‪ : HKEY_USERS‬ﻴﺤﻭﻱ ﻤﻌﻠﻭﻤﺎﺕ ﻋﻥ ﺍﻟﺘﺸﻜﻴﻼﺕ ﺍﻟﺠﺎﻨﺒﻴﺔ ﻟﻠﻤﺴﺘﺨﺩﻡ ) ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘـﻲ ﻴﺤـﺩﺩﻫﺎ ﺍﻟﻤـﺴﺘﺨﺩﻡ‬
‫ﻼ ‪ ، ( ..‬ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺍﻟﺘﺸﻜﻴﻼﺕ ﺍﻟﺠﺎﻨﺒﻴﺔ ﺍﻻﻓﺘﺭﺍﻀﻴﺔ ﺍﻟﺘﻲ ﺴﺘﻌﻁﻰ ﻋﻨﺩﻤﺎ ﻴـﺩﺨل ﻤـﺴﺘﺨﺩﻡ‬
‫ﻷﻟﻭﺍﻥ ﺴﻁﺢ ﺍﻟﻤﻜﺘﺏ ﻤﺜ ﹰ‬
‫ﺠﺩﻴﺩ ﺇﻟﻰ ﺍﻟﻭﻴﻨﺩﻭﺯ ‪.‬‬
‫‪ : HKEY_CURRENT_CONFIG‬ﻴﻌﺘﺒﺭ ﺠﺯﺀ ﻤـﻥ ﺍﻟﻤﻔﺘـﺎﺡ ‪ HKEY_LOCAL_MACHINE‬ﻭﻟﻜـﻥ‬
‫ﺒﻁﺭﻴﻘﺔ ﻋﺭﺽ ﺃﺨﺭﻯ ‪.‬‬
‫‪ : HKEY_DYN_Data‬ﻴﺤﻭﻱ ﻤﻌﻠﻭﻤﺎﺕ ﻋﻥ ﺃﺠﻬﺯﺓ ﺍﻟﻨﻅﺎﻡ ﻭﻁﺭﻕ ﺇﻋﺩﺍﺩﻫﺎ ) ﻏﻴﺭ ﻤﻭﺠﻭﺩ ﻓﻲ ‪Windows NT‬‬
‫(‪.‬‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻤﺴﺠل ﺍﻟﻨﻅﺎﻡ ﻴﺴﻤﺢ ﻟﻙ ﺒﺎﻟﺘﺤﻜﻡ ﺒﺎﻟﻨﻅﺎﻡ ﺒﺸﻜل ﻜﺎﻤل ﻭﻻ ﺒﺩ ﺃﻨﻙ ﺴﻤﻌﺕ ﻋﻥ ﺒﺭﺍﻤﺞ ﺘﺘﺤﻜﻡ ﺒﺴﺭﻋﺔ ﻗﺎﺌﻤـﺔ‬
‫ﺍﺒﺩﺃ ﻭ ﺘﻐﻴﺭ ﺃﺴﻡ ﺴﻠﺔ ﺍﻟﻤﺤﺫﻭﻓﺎﺕ ﻭﺘﻐﻴﺭ ﺍﻟﺼﻭﺭﺓ ﺍﻟﺘﻲ ﺘﻅﻬـﺭ ﺒﺠﺎﻨـﺏ ﻗﺎﺌﻤـﺔ ﺍﺒـﺩﺃ ) ﺍﻟـﺼﻭﺭﺓ ﺍﻟﻤﻜﺘـﻭﺏ ﻓﻴﻬـﺎ‬
‫ﻼ ( ﻭ ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺘﻐﻴﺭ ﺼﻭﺭﺓ ﺠﻬﺎﺯ ﻜﻤﺒﻴﻭﺘﺭ ﻭ ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺍﻟﺒﺭﺍﻤﺞ ﺍﻟﺘﻲ ﺘﻀﻴﻑ ﻨﻔﺴﻬﺎ‬
‫‪ WINDOWS Me‬ﻤﺜ ﹰ‬
‫‪151‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺇﻟﻰ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﺘﻲ ﺘﻅﻬﺭ ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻴﻤﻴﻥ ﻋﻠﻰ ﺴﻁﺢ ﺍﻟﻤﻜﺘﺏ ﺃﻭ ﻤﺴﺘﻜﺸﻑ ﻭﻴﻨﺩﻭﺯ ‪ ،‬ﺤﺘﻰ ﺃﻥ ﺍﻟﺒـﺭﺍﻤﺞ ﺍﻟﺘـﻲ‬
‫ﺘﺩﻋﻲ ﺃﻨﻬﺎ ﺘﺘﺤﻜﻡ ﺒﺴﺭﻋﺔ ﺍﻻﺘﺼﺎل ﺍﻨﺘﺭﻨﺕ ﺘﺘﻌﺎﻤل ﻤﻊ ﻤﺴﺠل ﺍﻟﻨﻅﺎﻡ ‪( ......‬‬
‫ﻫﺫﻩ ﻤﻭﺠﺯ ﺼﻐﻴﺭ ﺠﺩﹰﺍ ﻋﻥ ‪ Windows Registry‬ﻭﺇﺫﺍ ﺃﺭﺩﺕ ﺃﻥ ﺘﺼﺒﺢ ﻤﺒﺭﻤﺠﹰﺎ ﻤﺤﺘﺭﻓﹰﺎ ﻋﻠﻴﻙ ﻗﺭﺍﺀﺓ ﺃﺤﺩ ﺍﻟﻜﺘـﺏ‬
‫ﺍﻟﻤﺨﺘﺼﺔ ﺒﻬﺫﺍ ﺍﻟﻤﻭﻀﻭﻉ ﻓﻜﺘﺎﺏ ‪ Windows 2000 Registry‬ﺒﺤﺠﻡ ‪ 800‬ﺼﻔﺤﺔ ﺘﻘﺭﻴﺒﹰﺎ ‪.‬‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ‪ Registry‬ﻓﻲ ﺩﻟﻔﻲ ‪:‬‬
‫ﺇﺫﺍ ﻟﻡ ﺘﻜﻥ ﺘﺭﻴﺩ ﺃﻥ ﺘﺘﺤﻜﻡ ﺒﻨﻅﺎﻡ ﻭﻴﻨﺩﻭﺯ ﻤﻥ ﺩﺍﺨل ﺒﺭﻨﺎﻤﺠﻙ ﻓﺄﻨﺕ ﺒﺤﺎﺠﺔ ﺇﻟﻰ ﺘﺨﺯﻴﻥ ﺒﻌﺽ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﻋﻥ ﺒﺭﻨﺎﻤﺠﻙ‬
‫ﺩﺍﺨل ﻤﺴﺠل ﺍﻟﻨﻅﺎﻡ ﺍﻷﻤﺭ ﺍﻟﺫﻱ ﻴﻁﺭﻙ ﺇﻟﻰ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻨﻅﺎﻡ ‪.‬‬
‫ﻤﺜﺎل ‪ :‬ﺴﻨﻘﻭﻡ ﺒﺈﻨﺸﺎﺀ ﺒﺭﻨﺎﻤﺞ ﻴﻘﻭﻡ ﺒﻤﻌﺭﻓﺔ ﺍﺴﻡ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺍﻟﺫﻱ ﺴﺠل ﺍﻟﻨﻅﺎﻡ ﺒﺎﺴﻤﻪ ﻭﻤﻥ ﺜﻡ ﺘﻐﻴﺭﻩ ) ﻨـﺴﺘﻁﻴﻊ ﻤﻌﺭﻓـﺔ‬
‫ﺍﺴﻡ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﻤﻴﻨﻲ ﻋﻠﻰ ﺃﻴﻘﻭﻨﺔ ﺠﻬﺎﺯ ﺍﻟﻜﻤﺒﻴﻭﺘﺭ ﻭﺍﺨﺘﻴﺎﺭ ﺨﺼﺎﺌﺹ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ( ‪.‬‬
‫ﺍﺴﻡ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻴﻭﺠﺩ ﺩﺍﺨل ﻤﺴﺠل ﺍﻟﻨﻅﺎﻡ ﺘﺤﺕ ﺍﻟﻤﻔﺘﺎﺡ‬
‫]‪[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion‬‬
‫ﻭﻤﺨﺯﻥ ﻓﻲ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻨﺼﻴﺔ ‪ ) RegisteredOwner‬ﺍﻓﺘﺢ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪ Regedit‬ﻟﻠﺘﺄﻜﺩ ﻤﻥ ﺫﻟﻙ ( ‪.‬‬
‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺯﺭﻴﻥ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﻭﻋﻨﺼﺭ ‪، Edit1‬‬
‫ﻟﻠﺘﻌﺎﻤل ﻤﻊ ﻤﺴﺠل ﺍﻟﻨﻅﺎﻡ ﻋﻠﻴﻙ ﺇﻀﺎﻓﺔ ﺍﻟﻭﺤﺩﺓ ‪ Registry‬ﺇﻟﻰ ﺍﻟﻘﺴﻡ ‪USES‬‬
‫ﻟﻠﻘﺭﺍﺀﺓ ﻤﻥ ﻤﺴﺠل ﺍﻟﻨﻅﺎﻡ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻷﻭل‬
‫; ‪Var reg:tregistry‬‬
‫‪Begin‬‬
‫ﺇﻨﺸﺎﺀ ﺍﻟﻤﺘﺤﻭل ﻭﺤﺠﺯ ﻤﻜﺎﻥ ﻟﻪ ﻓﻲ ﺍﻟﺫﺍﻜﺭﺓ‪reg:= tregistry.Create ; //‬‬
‫‪try‬‬
‫ﺘﺤﺩﻴﺩ ﺍﻟﻤﻔﺘﺎﺡ ﺍﻟﺭﺌﻴﺴﻲ ‪reg.RootKey := HKEY_LOCAL_MACHINE ;//‬‬
‫; ) ‪reg.OpenKey('SOFTWARE\Microsoft\Windows\CurrentVersion',false‬‬
‫ﻗﺭﺍﺀﺓ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻨﺼﻴﺔ ﺍﻟﻤﺨﺯﻨﺔ ﻓﻲ ﺍﻟﻭﺴﻴﻁ ﺍﻟﻤﺫﻜﻭﺭ‪edit1.text := reg.ReadString('RegisteredOwner');//‬‬
‫ﺇﻏﻼﻕ ﺍﻟﻤﻔﺘﺎﺡ‪reg.CloseKey ; //‬‬
‫‪Finally‬‬
‫ﺘﺤﺭﻴﺭ ﺍﻟﺫﺍﻜﺭﺓ ﺒﻌﺩ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﺘﺤﻭل‪reg.Free ; //‬‬
‫;‪end‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ OpenKey‬ﺘﻘﻭﻡ ﺒﻔﺘﺢ ﺍﻟﻤﻔﺘﺎﺡ ﺍﻟﻤﺭﺭ ﻟﻬﺎ ﻜﻭﺴﻴﻁ ﺃﻭل ﻭﺇﺫﺍ ﻟﻡ ﻴﻜﻥ ﻤﻭﺠﻭﺩﹰﺍ ﻓﺘﻘﻭﻡ ﺒﺈﻨﺸﺎﺀ ﻫﺫﺍ ﺍﻟﻤﻔﺘﺎﺡ ﺇﺫﺍ ﻜﺎﻥ‬
‫ﻭﺴﻴﻁﻬﺎ ﺍﻟﺜﺎﻨﻲ ‪.True‬‬
‫ﻟﻠﻜﺘﺎﺒﺔ ﺇﻟﻰ ﻤﺴﺠل ﺍﻟﻨﻅﺎﻡ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺜﺎﻨﻲ ‪:‬‬
‫; ‪Var reg:tregistry‬‬
‫‪Begin‬‬
‫ﺇﻨﺸﺎﺀ ﺍﻟﻤﺘﺤﻭل ﻭﺤﺠﺯ ﻤﻜﺎﻥ ﻟﻪ ﻓﻲ ﺍﻟﺫﺍﻜﺭﺓ ‪reg:= tregistry.Create ;//‬‬
‫‪try‬‬
‫ﺘﺤﺩﻴﺩ ﺍﻟﻤﻔﺘﺎﺡ ﺍﻟﺭﺌﻴﺴﻲ ‪reg.RootKey := HKEY_LOCAL_MACHINE ;//‬‬
‫; ) ‪reg.OpenKey('SOFTWARE\Microsoft\Windows\CurrentVersion',false‬‬
‫‪152‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻜﺘﺎﺒﺔ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﺩﺨﻠﺔ ﻓﻲ ﻋﻨﺼﺭ ﺍﻟﺘﺤﺭﻴﺭ ﺇﻟﻰ ﺍﺴـﻡ ‪reg.WriteString('RegisteredOwner',edit1.Text ); //‬‬
‫ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﺤﺩﺩﺓ‬
‫ﺇﻏﻼﻕ ﺍﻟﻤﻔﺘﺎﺡ‪reg.CloseKey ; //‬‬
‫‪Finally‬‬
‫ﺘﺤﺭﻴﺭ ﺍﻟﺫﺍﻜﺭﺓ ﺒﻌﺩ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﺘﺤﻭل‪reg.Free ; //‬‬
‫;‪end‬‬
‫ﻤﺜﺎل ‪ : 2‬ﺴﻨﻌﻭﺩ ﺇﻟﻰ ﺒﺭﻨﺎﻤﺞ ﺍﻟﻬﺎﺘﻑ ‪:‬‬
‫ﻴﻘﻭﻡ ﺒﺭﻨﺎﻤﺠﻨﺎ ﺒﺎﻟﺘﺭﺘﻴﺏ ﺤﺴﺏ ﺍﻻﺴﻡ ﺩﺍﺌﻤﹰﺎ ﻭﻋﻠﻰ ﻓﺭﺽ ﺃﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻴﻔﻀل ﺍﻟﺘﺭﺘﻴﺏ ﺤﺴﺏ ﺍﻟﻜﻨﻴﺔ ﻓﺈﻥ ﻋﻠﻴـﻪ ﻋـﻥ‬
‫ﻴﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺍﻟﺭﺍﺩﻴﻭ ﺍﻟﻜﻨﻴﺔ ﻜﻠﻤﺎ ﺩﺨل ﺇﻟﻰ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪ ،‬ﺴﻨﻀﻴﻑ ﺍﻵﻥ ﻤﻔﺘﺎﺡ ﺇﻟﻰ ﻤﺴﺠل ﺍﻟﻨﻅﺎﻡ ﻴﻘﻭﻡ ﺒﺘﺨﺯﻴﻥ ﺍﻟﺨﻴﺎﺭ‬
‫ﺍﻻﻓﺘﺭﺍﻀﻲ ﻟﻠﻤﺴﺘﺨﺩﻡ ‪ ،‬ﻭﺴﻨﻘﻭﻡ ﺒﻔﺤﺹ ﻗﻴﻤﺔ ﻫﺫﺍ ﺍﻟﻤﻔﺘﺎﺡ ﻜﻠﻤﺎ ﺩﺨﻠﻨﺎ ﺇﻟﻰ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪:‬‬
‫ﺴﻨﺨﺯﻥ ﻗﻴﻤﺔ ﻋﺩﺩﻴﺔ ﺘﺤﺕ ﺃﺴﻡ ‪ IndexBy‬ﻓﻲ ﺍﻟﻤﻔﺘﺎﺡ ‪:‬‬
‫‪HKEY_CURRENT_USER\Software\MyPhone‬‬
‫ﻭﻋﻨﺩ ﺘﺸﻐﻴل ﺍﻟﺒﺭﻨﺎﻤﺞ ﺴﻨﻔﺤﺹ ﻗﻴﻤﺔ ﻫﺫﺍ ﺍﻟﻤﺘﺤﻭل ﻓﺈﺫﺍ ﻜﺎﻥ ﻫﺫﺍ ﺍﻟﻤﺘﺤﻭل ﻴﺤﻭﻱ ﻗﻴﻤﺔ ‪ 1‬ﻓﺎﻟﻔﻬﺭﺴﺔ ﺴﺘﺘﻡ ﺤﺴﺏ ﺍﻟﻜﻨﻴـﺔ‬
‫ﻭﺇﻻ ﻓﺎﻟﻔﻬﺭﺴﺔ ﺴﺘﺘﻡ ﺤﺴﺏ ﺍﻻﺴﻡ ‪.‬‬
‫ﺃﻀﻑ ﺯﺭ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻷﻭل ‪ Form1‬ﻓﻲ ﺒﺭﻨﺎﻤﺞ ﺍﻟﻬﺎﺘﻑ ﻭﺃﻋﻁﻪ ﺍﻟﻌﻨﻭﺍﻥ " ﻓﻬﺭﺱ ﺩﺍﺌﻤﹰﺎ ﺤﺴﺏ ﺍﻟﻜﻨﻴﺔ " ‪.‬‬
‫ﻭﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﻫﺫﺍ ﺍﻟﺯﺭ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; ‪Var reg:tregistry‬‬
‫‪Begin‬‬
‫; ‪reg:= tregistry.Create‬‬
‫‪try‬‬
‫; ‪reg.RootKey := HKEY_CURRENT_USER‬‬
‫; ) ‪reg.OpenKey('SOFTWARE\MyPhone',True‬‬
‫‪ ' Then‬ﻓﻬﺭﺱ ﺩﺍﺌﻤﹰﺎ ﺤﺴﺏ ﺍﻟﻜﻨﻴﺔ' = ‪if button4.Caption‬‬
‫) ‪reg.WriteInteger ('IndexBy',1‬‬
‫) ‪else reg.WriteInteger ('IndexBy',0‬‬
‫; ‪reg.CloseKey‬‬
‫‪Finally‬‬
‫; ‪reg.Free‬‬
‫;‪end‬‬
‫ﺘﻘﻭﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ OpenKey‬ﺒﺈﻨﺸﺎﺀ ﺍﻟﻤﻔﺘﺎﺡ ﺇﺫﺍ ﻟﻡ ﻴﻜﻥ ﻤﻭﺠـﻭﺩﹰﺍ ﻭﺘﻘـﻭﻡ ﺍﻟﺘﻌﻠﻴﻤـﺔ ‪ WriteInteger‬ﺒﺈﻨـﺸﺎﺀ ﺍﻟﻘﻴﻤـﺔ‬
‫‪ IndexBy‬ﻭﺘﺨﺯﻥ ﻓﻴﻬﺎ ﺍﻟﻘﻴﻤﺔ ‪ 1‬ﺃﻭ ﺼﻔﺭ ﺤﺴﺏ ﺍﻟﺸﺭﻁ ‪.‬‬
‫ﺍﻵﻥ ﺴﻨﻔﺤﺹ ﻫﺫﺍ ﺍﻟﻤﻔﺘﺎﺡ ﻋﻨﺩ ﺘﺸﻐﻴل ﺍﻟﺒﺭﻨﺎﻤﺞ ‪:‬‬
‫‪RBTLname‬‬
‫; ‪reg:= tregistry.Create‬‬
‫‪try‬‬
‫; ‪reg.RootKey := HKEY_CURRENT_USER‬‬
‫; )‪reg.OpenKey('SOFTWARE\MyPhone',True‬‬
‫‪if reg.ReadInteger ('IndexBy') = 1 then begin‬‬
‫‪153‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫;‪RBTLname.Checked := true‬‬
‫;)‪RBTLnameClick(Sender‬‬
‫; 'ﺭﺘﺏ ﺩﺍﺌﻤﹰﺎ ﺤﺴﺏ ﺍﻻﺴﻡ' =‪button5.Caption :‬‬
‫؛‪end‬‬
‫; ‪reg.CloseKey‬‬
‫‪Finally‬‬
‫; ‪reg.Free‬‬
‫;‪end‬‬
‫ﺘﻔﺤﺹ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﺨﺯﻨﺔ ‪ IndexBy‬ﻓﺈﺫﺍ ﻜﺎﻨﺕ ﺘﺴﺎﻭﻱ ‪ 1‬ﻓﺈﻨﻬﺎ ﺘﻘﻭﻡ ﺒﺘﺤﻔﻴﺯ ﺯﺭ ﺍﻟﺭﺍﺩﻴﻭ ﺍﻟﻜﻨﻴـﺔ ﻭﺘﻨﻔﻴـﺫ‬
‫ﺍﻟﺤﺩﺙ ﺍﻟﺨﺎﺹ ﺒﺎﻟﻀﻐﻁ ﻋﻠﻰ ﻫﺫﺍ ﺍﻟﺯﺭ ﻭﺍﻟﺫﻱ ﻓﻴﻪ ﺘﻌﻠﻴﻤﺎﺕ ﺘﻐﻴﻴﺭ ﺍﻟﻔﻬﺭﺱ ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺘﻐﻴﺭ ﻋﻨﻭﺍﻥ ﺍﻟﺯﺭ ﺇﻟﻰ ﺭﺘﺏ‬
‫ﺩﺍﺌﻤﹰﺎ ﺤﺴﺏ ﺍﻻﺴﻡ ‪.‬‬
‫ﺒﻬﺫﺍ ﻨﻜﻭﻥ ﻗﺩ ﺘﻌﻠﻤﻨﺎ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻤﺴﺠل ﺍﻟﻨﻅﺎﻡ ‪.‬‬
‫ﻭﻅﻴﻔﺔ ‪ :‬ﻓﻜﺭ ﺒﻁﺭﻴﻘﺔ ﺘﻘﻭﻡ ﺒﻬﺎ ﺒﺈﻀﺎﻓﺔ ﻜﻠﻤﺔ ﺴﺭ ﺇﻟﻰ ﺒﺭﻨﺎﻤﺞ ﺍﻟﻬﺎﺘﻑ ‪ ،‬ﺤﻴﺙ ﺴﺘﻅﻬﺭ ﻨﺎﻓﺫﺓ ﻋﻨـﺩ ﺘـﺸﻐﻴل ﺍﻟﺒﺭﻨـﺎﻤﺞ‬
‫ﺘﻁﺎﻟﺏ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺒﺈﺩﺨﺎل ﻜﻠﻤﺔ ﺍﻟﺴﺭ ﻓﺈﺫﺍ ﺃﺩﺨل ﻜﻠﻤﺔ ﺍﻟﺴﺭ ﺍﻟﺼﺤﻴﺤﺔ ﻓﺴﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺭﺌﻴﺴﻴﺔ ﻭﺇﻻ ﻓﺴﻴﻁﺎﻟﺏ ﺒﺈﺩﺨـﺎل‬
‫ﻜﻠﻤﺔ ﺍﻟﺴﺭ ﻤﺭﺓ ﺃﺨﺭﻯ ﻭﺇﺫﺍ ﻓﺸل ﻓﻲ ﺍﻟﺩﺨﻭل ﺜﻼﺙ ﻤﺭﺍﺕ ﻤﺘﺘﺎﻟﻴﺔ ﻓﻴﺘﻡ ﺇﻏﻼﻕ ﺍﻟﺒﺭﻨﺎﻤﺞ ) ﺨﺯﻥ ﻜﻠﻤﺔ ﺍﻟﺴﺭ ﻓﻲ ﻤـﺴﺠل‬
‫ﺍﻟﻨﻅﺎﻡ ( ‪.‬‬
‫ﺘﻭﺍﺒﻊ ﻭﺜﻭﺍﺒﺕ ﺍﻟﻭﻴﻨﺩﻭﺯ ‪: Windows API‬‬
‫ﺘﻭﺍﺒﻊ ﻭﺜﻭﺍﺒﺕ ﺍﻟﻭﻴﻨﺩﻭﺯ ﻫﻲ ﻤﺠﻤﻭﻋﺔ ﻫﺎﺌﻠﺔ ﻤﻥ ﺍﻟﺘﻭﺍﺒﻊ ﻭﺍﻟﺜﻭﺍﺒﺕ ﺍﻟﻤﻌﺭﻓﺔ ﻓﻲ ﻭﻴﻨﺩﻭﺯ ﻭﺍﻟﻤﻭﺠـﻭﺩﺓ ﻀـﻤﻥ ﻤﻜﺘﺒـﺎﺕ‬
‫ﻭﻴﻨﺩﻭﺯ ﻓﻲ ﻤﻠﻔﺎﺕ ﺫﺍﺕ ﺍﻻﻤﺘﺩﺍﺩ ‪ .DLL‬ﻭﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﻨﻭﺍﻓﺫ ﻟﻠﺘﺤﻜﻡ ﻓﻲ ﻭﻴﻨﺩﻭﺯ ﻭﻓﻲ ﻜل ﺸﻲﺀ ﻓﻲ ﻭﻴﻨـﺩﻭﺯ ﺍﺒﺘـﺩﺍﺀ‬
‫ﺒﻠﻭﺤﺔ ﺍﻟﻤﻔﺎﺘﻴﺢ ﻭﺍﻨﺘﻬﺎﺀ ﻤﺭﻭﺭﹰﺍ ﺒﺎﻟﺫﺍﻜﺭﺓ ﻭﺍﻟﻤﻌﺎﻟﺞ ﻭ ﺍﻟﺸﺎﺸﺔ ﺒﻤﺎ ﻓﻲ ﺫﻟﻙ ﺍﻟﺘﺤﻜﻡ ﺒﺎﻟﺒﺭﺍﻤﺞ ﻭﺍﻟﻨﻭﺍﻓﺫ ﻭﻁﺭﻕ ﺇﻅﻬﺎﺭﻫـﺎ )‬
‫ﻴﻤﻜﻨﻙ ﻋﻠﻰ ﺴﺒﻴل ﺍﻟﻤﺜﺎل ﺍﻟﺘﺤﻜﻡ ﺒﺎﺭﺘﻔﺎﻉ ﺍﻟﺼﻭﺕ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺘﻭﺍﺒﻊ ‪ Api‬ﻭ ﻤﻌﺭﻓﺔ ﻤﻌﻠﻭﻤﺎﺕ ﻤﻌﻴﻨﺔ ﻋﻥ ﺍﻷﺠﻬﺯﺓ ﻤﺜـل‬
‫ﻤﻌﺭﻓﺔ ﺤﺠﻡ ﺍﻟﺴﻭﺍﻗﺔ ﺍﻟﺼﻠﺒﺔ ‪ Hard Disk‬ﻴﻤﻜﻨﻙ ﺍﻟﺤﺼﻭل ﻋﻠﻰ ﻤﻌﻠﻭﻤﺎﺕ ﻓﻲ ﺒﺭﻨﺎﻤﺞ ﺁﺨﺭ ﻤﻥ ﺒﺭﻨﺎﻤﺠﻙ ﻜﺄﻥ ﺘﺤﺼل‬
‫ﻋﻠﻰ ﻤﻌﻠﻭﻤﺎﺕ ﻤﻥ ﻤﻠﻑ ﻭﺭﺩ ﻭﺍﻟﻤﺯﻴﺩ ﺍﻟﺫﻱ ﻻ ﻴﻤﻜﻥ ﺤﺼﺭﻩ ﻫﻨﺎ ‪.‬‬
‫ﺴﻨﺸﺭﺡ ﺃﻤﺜﻠﺔ ﻋﻥ ﺍﻟﺘﻭﺍﺒﻊ ﻭﻁﺭﻕ ﺍﻟﺘﻌﺎﻤل ﻤﻌﻬﺎ ‪:‬‬
‫‪ 1‬ـ ﺇﻏﻼﻕ ‪: Windows‬‬
‫ﻴﺴﺘﺨﺩﻡ ﺍﻟﺘﺎﺒﻊ ) (‪ ExitWindowsEx‬ﻹﻁﻔﺎﺀ ﺍﻟﺠﻬﺎﺯ ﺃﻭ ﺇﻋﺎﺩﺓ ﺍﻟﺘﺸﻐﻴل ‪:‬‬
‫ﺍﺒﺩﺃ ﺒﺭﻨﺎﻤﺠﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺍﻀﻑ ﺯﺭ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﻭﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; )‪ExitWindowsEx(ewx_ShutDown,0‬‬
‫ﺍﺤﻔﻅ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻗﻡ ﺒﺘﻨﻔﻴﺫﻩ ﻭﻻ ﺘﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪،‬ﺃﻏﻠﻕ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺸﻐﻠﻪ ﻤﻥ ﺨﺎﺭﺝ ﺍﻟﺩﻟﻔﻲ ) ﻤﻥ ﺍﻟﻤﻜﺎﻥ ﺍﻟﺫﻱ ﺤﻔﻅﺘﻪ‬
‫ﻓﻴﻪ ( ‪ ،‬ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻵﻥ ﻭﺴﻴﺘﻡ ﺇﻴﻘﺎﻑ ﺘﺸﻐﻴل ﻭﻴﻨﺩﻭﺯ ‪.‬‬
‫)‪. ExitWindowsEx(ewx_Reboot,0‬‬ ‫ﻹﻋﺎﺩﺓ ﺇﻗﻼﻉ ﺍﻟﻨﻅﺎﻡ ﺍﺴﺘﺨﺩﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪:‬‬
‫‪ 2‬ـ ﺍﻟﺘﺤﻜﻡ ﺒﻠﻐﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻻﻓﺘﺭﺍﻀﻴﺔ ‪ :‬ﺇﺫﺍ ﻜﺎﻨﺕ ﺍﻟﻠﻐﺔ ﺍﻻﻓﺘﺭﺍﻀﻴﺔ ﻋﻠﻰ ﺍﻟﺠﻬﺎﺯ ﻫﻲ ﺍﻟﻠﻐﺔ ﺍﻹﻨﻜﻠﻴﺯﻴﺔ ﻓﺈﻥ ﺒﺭﻨﺎﻤﺠـﻙ‬
‫ﺴﻴﻅﻬﺭ ﺍﻟﻤﺅﺸﺭ ﻓﻲ ﻋﻨﺎﺼﺭ ﺍﻟﺘﺤﺭﻴﺭ ﺒﺤﻴﺙ ﻴﺘﻡ ﺍﻟﻜﺘﺎﺒﺔ ﺒﺎﻟﻠﻐﺔ ﺍﻹﻨﻜﻠﻴﺯﻴﺔ ﻭﻋﻠﻰ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺃﻥ ﻴﺤﻭل ﺇﻟﻰ ﺃﺴﻠﻭﺏ ﺍﻟﻜﺘﺎﺒﺔ‬
‫ﺒﺎﻟﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ ﻜﻠﻤﺎ ﺃﺭﺍﺩ ﺍﻟﻜﺘﺎﺒﺔ ‪ ،‬ﻭﻴﻤﻜﻥ ﺤل ﻫﺫﻩ ﺍﻟﻤﺸﻜﻠﺔ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪:‬‬
‫‪154‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫; )‪LoadKeyboardLayout('00002801',klf_activate‬‬
‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﻀﻊ ﻓﻴﻪ ﻋﻨﺼﺭ ﺘﺤﺭﻴﺭ ‪ Edit‬ﻭﺃﻀﻑ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺴﺎﺒﻘﺔ ﺇﻟﻰ ﺍﻟﺤﺩﺙ ‪ OnCreate‬ﻟﻠﻨﻤﻭﺫﺝ ﻭﺸﻐل‬
‫ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺴﺘﻼﺤﻅ ﺃﻥ ﺍﻟﻤﺅﺸﺭ ﺃﺼﺒﺢ ﺒﺠﻬﺔ ﺍﻟﻜﺘﺎﺒﺔ ﺒﺎﻟﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ ‪.‬‬
‫ﺍﻟﺭﻗﻡ ‪ 00002801‬ﻫﻭ ﺍﻟﺭﻗﻡ ﺍﻟﺫﻱ ﻴﺭﻤﺯ ﺇﻟﻰ ﻟﻭﺤﺔ ﺍﻟﻤﻔﺎﺘﻴﺢ ﺍﻟﻌﺭﺒﻴﺔ ﺍﻟﺴﻌﻭﺩﻴﺔ ﺇﺫﺍ ﺃﺭﺩﺕ ﺍﻟﻌﻭﺩﺓ ﺇﻟﻰ ﺍﻟﻠﻐﺔ ﺍﻹﻨﻜﻠﻴﺯﻴـﺔ‬
‫ﺍﻷﻤﺭﻴﻜﻴﺔ ﺒﺩل ﻫﺫﺍ ﺍﻟﺭﻗﻡ ﺇﻟﻰ ‪. 00000409‬‬
‫ﺘﻁﺒﻴﻕ ‪ :‬ﺍﺫﻫﺏ ﺇﻟﻰ ﺒﺭﻨﺎﻤﺞ ﺍﻟﻬﺎﺘﻑ ﻭﺃﻀﻑ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﻟﻠﺤﺩﺙ ‪ OnCreate‬ﻟﻠﻨﻤﻭﺫﺝ ﺍﻷﻭل ‪. Form1‬‬
‫ﻴﻭﺠﺩ ﻟﺩﻴﻨﺎ ﻓﻲ ﺍﻟﻨﺎﻓﺫﺓ ﺇﺩﺨﺎل ﻓﻲ ﺒﺭﻨﺎﻤﺞ ﺍﻟﻬﺎﺘﻑ ﺤﻘﻠﻴﻥ ﻴﺠﺏ ﻜﺘﺎﺒﺘﻬﻤﺎ ﺒﺎﻟﻠﻐﺔ ﺍﻹﻨﻜﻠﻴﺯﻴﺔ ﻫﻤﺎ ﺤﻘل ﺍﻟﺒﺭﻴـﺩ ﺍﻹﻟﻜﺘﺭﻭﻨـﻲ‬
‫ﻭﺤﻘل ﻤﻭﻗﻊ ﺍﻻﻨﺘﺭﻨﺕ ﻟﺫﻟﻙ ﻴﻤﻜﻨﻙ ﻜﺘﺎﺒﺔ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnEnter‬ﻟﻬﺫﻴﻥ ﺍﻟﺤﻘﻠﻴﻥ ‪:‬‬
‫; )‪LoadKeyboardLayout('00000409 ',klf_activate‬‬
‫ﺤﻴﺙ ﺴﻴﺘﻡ ﺍﻟﺘﺤﻭل ﺇﻟﻰ ﺍﻟﻠﻐﺔ ﺍﻹﻨﻜﻠﻴﺯﻴﺔ ﻋﻨﺩ ﺩﺨﻭل ﺍﻟﻤﺅﺸﺭ ﺇﻟﻰ ﻫﺫﻴﻥ ﺍﻟﺤﻘﻠﻴﻥ ﻭﺍﻜﺕ ﺍﻟﺘﻌﻠﻴﻤـﺔ ﺍﻟﺘﺎﻟﻴـﺔ ﻓـﻲ ﺍﻟﺤـﺩﺙ‬
‫‪OnExit‬‬
‫; )‪LoadKeyboardLayout('00002801',klf_activate‬‬
‫ﺇﺫﺍ ﺃﺭﺩﺕ ﺃﻥ ﻴﻌﻭﺩ ﺍﻟﻤﺅﺸﺭ ﺇﻟﻰ ﺍﻟﻠﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ ﻋﻥ ﺨﺭﻭﺝ ﺍﻟﻤﺅﺸﺭ ﻤﻥ ﻫﺫﻴﻥ ﺍﻟﺤﻘﻠﻴﻥ ‪.‬‬
‫ﺍﻟﺘﺎﺒﻊ ‪: MessageBox‬‬
‫ﺘﻌﺎﻤﻠﻨﺎ ﻤﻊ ﺍﻟﺘﺎﺒﻌﻴﻥ ‪ ShowMessage‬ﻭ‪ MessageDlg‬ﺴﺎﺒﻘﹰﺎ ﻭﻟﻜﻥ ﻤﺸﻜﻠﺔ ﻫﺫﻴﻥ ﺍﻟﺘﺎﺒﻌﻴﻥ ﺃﻥ ﻋﻨﺎﻭﻴﻥ ﺍﻷﺯﺭﺍﺭ ﺘﻅﻬﺭ‬
‫ﺒﺎﻟﻐﺔ ﺍﻹﻨﻜﻠﻴﺯﻴﺔ ﺩﺍﺌﻤﹰﺎ ﻟﺫﻟﻙ ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺘﺎﺒﻊ ‪ MEssageBox‬ﻤﻥ ﻭﻴﻨﺩﻭﺯ ‪ Api‬ﺍﻟﺫﻱ ﺴﻴﻅﻬﺭ ﻋﻨـﺎﻭﻴﻥ ﺍﻷﺯﺭﺍﺭ‬
‫ﺘﺒﻌﹰﺎ ﻟﻠﻐﺔ ﺍﻟﻨﻅﺎﻡ ‪.‬‬
‫ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪:‬‬
‫; ) ‪ ' , MB_Ok‬ﻫﺫﺍ ﻋﻨﻭﺍﻥ ﺍﻟﺭﺴﺎﻟﺔ ' ‪ ' ,‬ﻫﺫﺍ ﻨﺼﺭ ﺍﻟﺭﺴﺎﻟﺔ'‪MessageBox ( 0,‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻻﺤﻅ ﺃﻥ ﺍﻟﺯﺭ ‪ Ok‬ﺴﻴﻅﻬﺭ ﺒﺎﻟﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ ) ﻤﻭﺍﻓﻕ ( ﺇﺫﺍ ﻜﻨﺕ ﺘﺴﺘﺨﺩﻡ ﻭﻴﻨﺩﻭﺯ ﺒﺎﻟﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ ‪.‬‬
‫ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺁﺨﺭ ‪:‬‬
‫‪ ' ,Mb_YesNo ) = IDYES‬ﺘﻐﻴﺭ ﻟﻭﻥ ﺍﻟﻨﺎﻓﺫﺓ ' ‪ ' ,‬ﻫل ﺘﺭﻴﺩ ﺘﻠﻭﻴﻥ ﺍﻟﻨﺎﻓﺫﺓ ﺒﺎﻟﻠﻭﻥ ﺍﻷﺤﻤﺭ'‪If MessageBox ( 0,‬‬
‫‪then‬‬
‫;‪Form1.color := clred‬‬
‫ﻟﻤﺯﻴﺩ ﻤﻥ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻀﻊ ﺍﻟﻤﺅﺸﺭ ﻓﻭﻕ ﺍﺴﻡ ﺍﻟﺘﺎﺒﻊ ‪ MessagBox‬ﻭﺍﻀﻐﻁ ﻋﻠﻰ ‪. F1‬‬

‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻨﻭﺍﻓﺫ ‪:‬‬

‫ﻟﻜل ﻨﺎﻓﺫﺓ ﻓﻲ ﻭﻴﻨﺩﻭﺯ ﻤﻘﺒﺽ ﺃﻭ ﻤﻤﺴﻙ ﻴﺩﻋﻰ ‪ Handle‬ﻭﻫﻭ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Thandle‬ﻭﻫﻭ ﻋﺒﺎﺭﺓ ﻋﻥ ﻋـﺩﺩ ﺼـﺤﻴﺢ‬
‫ﻁﻭﻴل ﻴﺘﻌﺎﻤل ﺍﻟﻨﻅﺎﻡ ﻤﻊ ﻫﺫﺍ ﺍﻟﻤﻘﺒﺽ ﻟﻠﻭﺼﻭل ﺇﻟﻰ ﺍﻟﻨﺎﻓﺫﺓ ) ﻻ ﻴﻘﺼﺩ ﺒﺎﻟﻨﺎﻓﺫﺓ ﻫﻨﺎ ﺍﻟﻨﻤﻭﺫﺝ ‪ Form‬ﻓﻘﻁ ﺒل ﻟﻜل ﻋﻨﺼﺭ‬
‫ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﻤﻘﺒﺽ ﺃﻴﻀﹰﺎ ﻓﻬﻨﺎﻙ ﻤﻘﺒﺽ ﻟﻠﺯﺭ ﻭﻟﻠﻌﻨﺼﺭ ‪ Edit‬ﻭ‪ ، ( ....‬ﺍﻟﻤﻘﺒﺽ ﻟﻴﺱ ﻟﻪ ﻗﻴﻤﺔ ﺜﺎﺒﺘﺔ ﺇﺫ ﻴﻌﻁﻰ ﻟﻠﻨﺎﻓﺫﺓ‬
‫ﺭﻗﻡ ﻤﻘﺒﺽ ﺠﺩﻴﺩ ﻋﻨﺩ ﻜل ﺇﻨﺸﺎﺀ ﻟﻠﻨﺎﻓﺫﺓ ‪ ،‬ﻋﻨﺩﻤﺎ ﺘﻘﻭﻡ ﻴﺘﺤﺭﻴﻙ ﻨﺎﻓﺫﺓ ﻤﺎ ﻋﻠﻰ ﺴﻁﺢ ﺍﻟﻤﻜﺘـﺏ ﻓـﺈﻥ ﺍﻟﻨﻅـﺎﻡ ﻴـﺴﺘﺩﻋﻲ‬
‫ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺘﻭﺍﺒﻊ ‪ Api‬ﻟﺘﻨﻔﻴﺫ ﻫﺫﻩ ﺍﻟﺤﺭﻜﺔ ‪.‬‬
‫ﻴﻭﺠﺩ ﻋﺩﺩ ﻫﺎﺌل ﻤﻥ ﺍﻟﺘﻭﺍﺒﻊ ﺍﻟﻤﺘﻌﻠﻘﺔ ﺒﺎﻟﻨﻭﺍﻓﺫ ﺴﻨﺫﻜﺭ ﺒﻌﺽ ﻤﻨﻬﺎ ﻓﻲ ﻫﺫﻩ ﺍﻟﻌﺠﺎﻟﺔ ‪:‬‬

‫‪155‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ 1‬ـ ﺒﺭﻨﺎﻤﺞ ﻴﻌﻴﺩ ﺃﺴﻤﺎﺀ ﺠﻤﻴﻊ ﺍﻟﻨﻭﺍﻓﺫ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﺫﺍﻜﺭﺓ ‪:‬‬
‫ﺃﻀﻑ ﺯﺭ ﻭ ﻋﻨﺼﺭ ‪ ListBox‬ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﻓﻲ ﺒﺭﻨﺎﻤﺞ ﺠﺩﻴﺩ ﻭﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ‬
‫‪:‬‬
‫;‪var h:Thandle‬‬
‫;‪p:pchar‬‬
‫‪begin‬‬
‫;)‪getmem(p,250‬‬
‫; )‪h:= gettopwindow ( getdesktopwindow‬‬
‫;)‪getwindowtext(h,p,250‬‬
‫;)‪listbox1.Items.Add(p‬‬
‫‪while h > 0 do begin‬‬
‫;)‪h:= getnextwindow( h,gw_hwndnext‬‬
‫;)‪getwindowtext(h,p,250‬‬
‫; )‪listbox1.Items.Add(p‬‬
‫;‪end‬‬
‫;)‪freemem(p,200‬‬
‫;‪end‬‬
‫ﺸﺭﺡ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪:‬‬
‫ﻓﻲ ﺍﻟﺒﺩﺍﻴﺔ ﺘﻡ ﺘﻌﺭﻴﻑ ﺍﻟﻤﺘﺤﻭل ‪ h‬ﻭﻫﻭ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Thandle‬ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺍﻟﻤﺘﺤﻭل ‪ P‬ﻤﻥ ﺍﻟﻨﻭﻉ ‪ ) Pchar‬ﻤﻼﺤﻅـﺔ‬
‫ﺠﻤﻴﻊ ﺘﻭﺍﺒﻊ ‪ Api‬ﺘﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻨﻭﻉ ‪( Pchar‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ )‪ GetMem( p,200‬ﺘﺨﺼﺹ ‪ 200‬ﺒﺎﻴﺕ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ ﻟﻠﻤﺘﺤﻭل ‪. p‬‬
‫‪ : GetDesktopwindow‬ﻴﻌﻴﺩ ﻤﻘﺒﺽ ﺴﻁﺢ ﺍﻟﻤﻜﺘﺏ ﻓﻲ ﻭﻴﻨﺩﻭﺯ ‪.‬‬
‫‪ GetTopWindow‬ﻴﻌﻴﺩ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺃﻋﻠﻰ ﺍﻟﻨﻭﺍﻓﺫ ﻓﻲ ﺤﻴﺯ ﺍﻟﺫﺍﻜﺭﺓ ﺍﻟﻤﺨﺯﻥ ﻓﻴﻪ ﻤﻘﺒﺽ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺫﻱ ﻴﻤـﺭﺭ‬
‫ﻜﻭﺴﻴﻁ ﻟﻬﺫﺍ ﺍﻟﺘﺎﺒﻊ‬
‫)‪ :getwindowtext(h,p,250‬ﻴﻌﻴﺩ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﻓﻲ ﺍﻟﻤﺘﺤﻭل ‪ p‬ﻋﻨﻭﺍﻥ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﻲ ﻤﻘﺒﻀﻬﺎ ‪ h‬ﻭﻴﻌﻴﺩ ﻨﺹ ﺒﻁﻭل ‪250‬‬
‫ﺤﺭﻑ‬
‫)‪ : GetNextWindow( h, gw_hwndnext‬ﻴﻌﻴﺩ ﻤﻘﺒﺽ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﻲ ﺘﻠﻲ ﺍﻟﻨﺎﻓﺫﺓ ‪ h‬ﻭﻓﻲ ﺤﺎل ﻭﺼﻠﻨﺎ ﺇﻟـﻰ ﺁﺨـﺭ‬
‫ﻨﺎﻓﺫﺓ ﻓﻴﻌﻴﺩ ﺍﻟﻘﻴﻤﺔ ‪. Nil‬‬
‫‪ 2‬ـ ﺒﺭﻨﺎﻤﺞ ﺇﺨﻔﺎﺀ ﻭﺇﻅﻬﺎﺭ ﺸﺭﻴﻁ ﺍﻟﻤﻬﺎﻡ ‪:‬‬
‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﺯﺭﻴﻥ ‪:‬‬
‫‪ 1‬ـ ﻋﺭﻑ ﺍﻟﻤﺘﺤﻭل ﺍﻟﺘﺎﻟﻲ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Private‬ﻟﻠﻭﺤﺩﺓ ‪:‬‬

‫;‪hTaskBar: THandle‬‬

‫‪ 2‬ـ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnCreate‬ﻟﻠﻨﻤﻭﺫﺝ ‪:‬‬

‫;)‪hTaskBar := FindWindow('Shell_TrayWnd', nil‬‬
‫ﺘﻌﻴﺩ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﻲ ﻨﻭﻋﻬﺎ ﻤﺫﻜﻭﺭ ﻓﻲ ﺍﻟﻭﺴﻴﻁ ﺍﻷﻭل ﻭﻋﻨﻭﺍﻨﻬﺎ ﻤﺫﻜﻭﺭ ﻓﻲ ﺍﻟﻭﺴﻴﻁ ﺍﻟﺜﺎﻨﻲ‬

‫‪156‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ 3‬ـ ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻷﻭل ‪:‬‬
‫;)‪ShowWindow(hTaskBar, SW_HIDE‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺈﻅﻬﺎﺭ ﺃﻭ ﺇﺨﻔﺎﺀ ﺍﻟﻨﺎﻓﺫﺓ ﺘﺒﻌﹰﺎ ﻟﻠﻭﺴﻴﻁ ﺍﻟﺜﺎﻨﻲ ‪.‬‬
‫‪ 4‬ـ ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺜﺎﻨﻲ ‪:‬‬

‫;)‪ShowWindow(hTaskBar, SW_SHOW‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪.‬‬
‫ﻤﻼﺤﻅﺎﺕ ‪:‬‬
‫‪ 1‬ـ ﻟﻠﻤﺯﻴﺩ ﻤﻥ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﻋﻥ ﺍﻟﺘﻭﺍﺒﻊ ﺍﻟﻤﺫﻜﻭﺭﺓ ﺴﺎﺒﻘﹰﺎ ﺍﻀﻐﻁ ‪ F1‬ﻓﻭﻕ ﺒﻌﺩ ﻭﻀﻊ ﺍﻟﻤﺅﺸﺭ ﻓﻭﻕ ﺍﺴﻡ ﺍﻟﺘﺎﺒﻊ ‪.‬‬
‫‪ 2‬ـ ﻟﻠﺤﺼﻭل ﻋﻠﻰ ﺍﺴﻤﺎﺀ ﻤﻌﻅﻡ ﺘﻭﺍﺒﻊ ‪ Windows Api‬ﺍﻜﺘﺏ ‪ Windows‬ﻓﻲ ﺃﻱ ﻤﻜﺎﻥ ﻤﻥ ﻤﺤـﺭﺭ ﺍﻟـﺸﻴﻔﺭﺓ ﻭ‬
‫ﻀﻊ ﺍﻟﻨﻘﻁﺔ ‪ ،‬ﻓﺴﻴﺘﻡ ﻜﺘﺎﺒﺔ ﺠﻤﻴﻊ ﺍﻟﺜﻭﺍﺒﺕ ﻭﺍﻟﺘﻭﺍﺒﻊ ﺍﻟﻤﻌﺭﻓﺔ ﻓﻲ ﺍﻟﻭﺤﺩﺓ ‪ Windows.pas‬ﻭﻫﻲ ﻤﺭﺘﺒﻁﺔ ﻤﺒﺎﺸـﺭﺓ ﻤـﻊ‬
‫‪. Windows Api‬‬
‫‪ 3‬ـ ﻟﻠﺤﺼﻭل ﻋﻠﻰ ﻤﻌﻠﻭﻤﺎﺕ ﻭﺍﻓﺭﺓ ﻋﻥ ‪ Windows Api‬ﻋﻠﻴﻙ ﻤﺭﺍﺠﻌﺔ ﺍﻟﻜﺘﺏ ﺍﻟﻤﺨﺘـﺼﺔ ﺃﻭ ﺍﻟﺤـﺼﻭل ﻋﻠـﻰ‬
‫ﻤﺠﻤﻭﻋﺔ ﺍﻷﻗﺭﺍﺹ ﺍﻟﻠﻴﺯﺭﻴﺔ ﺍﻟﻤﺴﻤﺎﺓ ‪ MSDN Library‬ﻭﺍﻟﺘﻲ ﺘﺒﺎﻉ ﻤﻊ ‪. MicroSoft Visual Studio‬‬

‫ﺇﻋﺩﺍﺩ ﺍﻟﻤﻬﻨﺩﺱ ‪ :‬ﻤﺤﻤﺩ ﺨﺎﻟﺩ ﻨﺎﺼﺭ ﺁﻏﺎ‬

‫‪157‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ‪24‬‬
‫ﺇﻀﺎﻓﺔ ﻋﻨﺎﺼﺭ ﺠﺩﻴﺩﺓ ) ‪: ( Add new omponant‬‬
‫ﻗﺒل ﺇﻀﺎﻓﺔ ﻋﻨﺎﺼﺭ ﺠﺩﻴﺩﺓ ﺇﻟﻰ ﺩﻟﻔﻲ ﻋﻠﻴﻨﺎ ﺃﻥ ﻨﻌﺭﻑ ﻤﺎ ﻫﻲ ﺍﻟﻌﻨﺎﺼﺭ‪:‬‬
‫ﻟﻘﺩ ﺘﻌﺎﻤﻠﻨﺎ ﻤﻊ ﻤﺠﻤﻭﻋﺔ ﻜﺒﻴﺭﺓ ﻤﻥ ﺍﻟﻌﻨﺎﺼﺭ ﻓﻲ ﺩﻟﻔﻲ ﻤﻨﻬﺎ ﺍﻟﻤﺭﺌﻲ ﻭﻤﻨﻬﺎ ﺍﻟﻤﺨﻔﻲ ﻭﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻥ ﻜﺘل ﺒﺭﻤﺠﻴﻪ ﺠﺎﻫﺯﺓ‬
‫ﻴﻀﻌﻬﺎ ﺍﻟﻤﺒﺭﻤﺞ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﻹﻋﻁﺎﺀ ﺒﺭﻨﺎﻤﺠﻪ ﺸﻜل ﻭﺨﺼﺎﺌﺹ ﻤﻌﻴﻨﺔ‪ ،‬ﻭﺘﺨﺘﻠﻑ ﺍﻟﻌﻨﺎﺼﺭ ﺒﻁﺒﻴﻌﺘﻬﺎ ﻓﻤﻨﻬﺎ ﺍﻟﺒﺴﻴﻁ‬
‫ﺍﻟﻌﻨﺼﺭ ‪ TLabel‬ﺃﻭ ﻋﻨﺎﺼﺭ ﻤﻌﻘﺩﺓ ﻜﻌﻨﺎﺼﺭ ‪ BDE‬ﻭﻋﻨﺎﺼﺭ ﺍﻟﻁﺒﺎﻋﺔ ‪.‬‬
‫ﻤﻥ ﺍﻟﻤﻌﺭﻭﻑ ﺃﻥ ﻟﻐﺔ ﺍﻟﺩﻟﻔﻲ ﻫﻲ ﻟﻐﺔ ﺒﺭﻤﺠﺔ ﻏﺭﻀﻴﺔ ﺍﻟﺘﻭﺠﻪ ‪ object-oriented programming‬ﺃﻱ ﺃﻨﻨﺎ ﻨﺴﺘﻁﻴﻊ‬
‫ﺃﻥ ﻨﻜﺘﺏ ﻜﺘﻠﻨﺎ ﺍﻟﺒﺭﻤﺠﻴﺔ ﺍﻋﺘﻤﺎﺩﹰﺍ ﻋﻠﻰ ﻜﺘل ﺃﺨﺭﻯ ‪ ،‬ﻓﻌﻨﺩ ﺇﻨﺸﺎﺀ ﺍﻟﻨﻤﻭﺫﺝ ﻟﺴﻨﺎ ﺒﺤﺎﺠﺔ ﺇﻟﻰ ﻜﺘﺎﺒﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻹﻨﺸﺎﺀ‬
‫ﺍﻟﻨﻤﻭﺫﺝ ﻭﺇﻅﻬﺎﺭﻩ ﻭﻟﺴﻨﺎ ﺒﺤﺎﺠﺔ ﺃﻴﻀﹰﺎ ﻟﻜﺘﺎﺒﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺒﺭﻤﺠﻴﺔ ﻹﻅﻬﺎﺭ ﻜل ﻋﻨﺼﺭ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ‪ ،‬ﺇﺫ ﻴﻜﻔﻲ ﺃﻥ‬
‫ﻨﺴﺤﺏ ﺍﻟﻌﻨﺼﺭ ﻭﻨﻀﻌﻪ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﻟﺘﻘﻭﻡ ‪ Delphi‬ﺒﺈﻀﺎﻓﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺒﺭﻤﺠﻴﺔ ﺍﻟﻼﺯﻤﺔ ﻹﻅﻬﺎﺭ ﺍﻟﻌﻨﺼﺭ ﻭﻁﺭﻕ‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻫﺫﻩ ﺍﻟﻌﻨﺎﺼﺭ (‬
‫ﺘﻨﺤﺩﺭ ﺠﻤﻴﻊ ﺍﻟﻌﻨﺎﺼﺭ ﻓﻲ ﺩﻟﻔﻲ ﻤﻥ ﺍﻟﻌﻨﺼﺭ ‪ Tobject‬ﻭﻫﻭ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺭﺌﻴﺴﻲ ) ﺍﻷﺏ ( ﻓﻲ ﺩﻟﻔﻲ ﺤﻴﺙ ﺘﻨﺤﺩﺭ ﺠﻤﻴﻊ‬
‫ﺍﻟﻌﻨﺎﺼﺭ ﻤﻨﻪ ﻭﺤﻴﺙ ﺘﺄﺨﺫ ﺍﻟﻌﻨﺎﺼﺭ ﺒﻌﺽ ﺨﻭﺍﺹ ﺍﻟﻌﻨﺼﺭ ‪ Tobject‬ﻭﺘﻀﻴﻑ ﺇﻟﻴﻬﺎ ﺨﻭﺍﺹ ﺠﺩﻴﺩﺓ ﺃﻭ ﺘﻌﺩل ﻓﻲ‬
‫ﺒﻌﺽ ﻫﺫﻩ ﺍﻟﺨﻭﺍﺹ ﺒﻤﺎ ﻴﻼﺌﻡ ﻋﻤل ﻜل ﻋﻨﺼﺭ ﻭﺍﻟﺸﺠﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺘﻭﻀﺢ ﺍﻟﺒﻨﺎﺀ ﺍﻟﻬﻴﻜﻠﻲ ﻟﻠﻌﻨﺎﺼﺭ ‪:‬‬

‫ﻟﻤﺎﺫﺍ ﻴﺘﻡ ﺇﻨﺸﺎﺀ ﻋﻨﺎﺼﺭ ﺠﺩﻴﺩﺓ ‪:‬‬

‫ﻴﻘﻭﻡ ﺒﻌﺽ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﺍﻟﻤﺤﺘﺭﻓﻴﻥ ﺃﻭ ﺒﻌﺽ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﺍﻟﻬﻭﺍﺓ ﺒﺈﻨﺸﺎﺀ ﻋﻨﺎﺼﺭ ﺠﺩﻴﺩﺓ ﺤﺘﻰ ﻴﺠﻌﻠﻭﺍ ﻤﻥ ﺍﻟﺒﺭﻤﺠﺔ ﺃﻤﺭ‬
‫ﺴﻬل ﻭﻤﻤﺘﻊ ‪ ،‬ﻷﻨﻙ ﻜﻤﺒﺭﻤﺞ ﻋﺎﺩﻱ ﻻ ﺘﺴﺘﻁﻴﻊ ﺃﻥ ﺘﺒﺭﻤﺞ ﻜل ﺸﻲﺀ ﺒﻨﻔﺴﻙ ﻭﻋﻠﻴﻙ ﺃﻥ ﺘﻌﺘﻤﺩ ﻋﻠﻰ ﺍﻟﻐﻴﺭ ﻓﻲ ﺃﻨﺸﺎﺀ‬

‫‪158‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺒﺭﺍﻤﺠﻙ ﻓﻼ ﺤﺩﻭﺩ ﻟﻺﻤﻜﺎﻨﻴﺎﺕ ﺍﻟﺘﻲ ﺘﺴﺘﻁﻴﻊ ﺍﻟﻌﻨﺎﺼﺭ ﺃﻥ ﺘﻘﺩﻤﻬﺎ ﻭﻜل ﻴﻭﻡ ﻨﺴﻤﻊ ﻋﻥ ﻋﻨﺎﺼﺭ ﺠﺩﻴﺩﺓ ﻭﺍﺒﺘﻜﺎﺭﺍﺕ ﺠﺩﻴﺩﺓ‬
‫ﻓﻲ ﻋﺎﻟﻡ ﺍﻟﻌﻨﺎﺼﺭ ‪.‬‬
‫ﻁﺭﻕ ﺇﻀﺎﻓﺔ ﻋﻨﺎﺼﺭ ﺠﺩﻴﺩﺓ ﺇﻟﻰ ﻟﻭﺤﺔ ﺍﻟﻌﻨﺎﺼﺭ ‪:‬‬
‫ﻫﻨﺎﻙ ﺍﻟﻌﺩﻴﺩ ﻤﻥ ﺍﻟﻁﺭﻕ ﻹﻀﺎﻓﺔ ﻋﻨﺎﺼﺭ ﺠﺩﻴﺩﺓ ﺇﻟﻰ ﺼﻔﺤﺔ ﺍﻟﻌﻨﺎﺼﺭ ﻭﺃﻓﻀل ﻁﺭﻴﻘﺔ ﻫﻲ ﻗﺭﺍﺀﺓ ﻤﻠﻔﺎﺕ ﺍﻟﻤﺴﺎﻋﺩﺓ ﺍﻟﺘﻲ‬
‫ﺘﺄﺘﻲ ﻤﻊ ﺍﻟﻌﻨﺼﺭ ﻭﻟﻜﻨﻨﺎ ﺴﻨﺭﻜﺯ ﻋﻠﻰ ﺒﻌﺽ ﺍﻟﻁﺭﻕ ﺍﻟﻌﺎﻤﺔ ‪:‬‬
‫‪ 1‬ـ ﻋﻥ ﻁﺭﻴﻕ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﻜﺘﺒﺔ ‪: .bpl‬‬
‫ﺇﺫﺍ ﻭﺠﺩﺕ ﻓﻲ ﻓﻬﺭﺱ ﺍﻟﻌﻨﺼﺭ ﻤﻠﻑ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ bpl‬ﻓﺎﺘﺒﻊ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻹﻀﺎﻓﺔ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﺇﻟﻰ ﺼﻔﺤﺔ ﺍﻟﻌﻨﺎﺼﺭ ‪:‬‬
‫ﺃ ـ ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪ Component‬ﺍﺨﺘﺭ ‪Install Package‬‬
‫ﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻤﺠﺎﻭﺭﺓ ﺍﺨﺘﺭ ﻤﻨﻬﺎ ‪ Add‬ﻭﺍﺫﻫﺏ ﺇﻟﻰ ﺍﻟﻤﺴﺎﺭ‬
‫ﺍﻟﻤﻭﺠﻭﺩ ﻓﻴﻪ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺫﻱ ﺘﺭﻴﺩ ﺇﻀﺎﻓﺘﻪ ﻭﺍﺨﺘﺭ ﻤﻠﻑ ‪ .bpl‬ﻭﺍﻀﻐﻁ‬
‫ﻋﻠﻰ ‪. Ok‬‬
‫ﻤﺜﺎل ) ﻨﻔﺫ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﺴﺎﺒﻘﺔ ﻋﻠﻰ ﺍﻟﻌﻨﺼﺭ‬
‫‪TIBEAntialiasButton02_all‬‬
‫ﺍﻟﻤﻭﺠﻭﺩ ﻋﻠﻰ ﺍﻟﺩﻴﺴﻙ ﺍﻟﻤﺭﻓﻕ ( ‪ .‬ﺃﻭ ﺤﻤﻠﻪ ﻤﻥ ﺍﻟﻤﻭﻗﻊ‬
‫‪http://www.ibe-software.com‬‬
‫ﺴﺘﻼﺤﻅ ﺃﻥ ﺍﻟﻌﻨﺼﺭ ﻭﻀﻊ ﻨﻔﺴﻪ ﻓﻲ ﺍﻟﺼﻔﺤﺔ ﺍﻷﺨﻴﺭ ﻓﻲ ﻟﻭﺤﺔ‬
‫ﺍﻟﻌﻨﺎﺼﺭ ‪.‬‬

‫ﺏ ـ ﺍﻵﻥ ﻴﺠﺏ ﺇﻀﺎﻓﺔ ﻤﺠﻠﺩ ﺍﻟﻌﻨﺼﺭ ﺇﻟﻰ ﻤﺴﺎﺭ ﺍﻟﻤﻜﺘﺒﺎﺕ‬

‫ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﻓﻲ ﺩﻟﻔﻲ ‪:‬‬
‫ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪Tools Æ Environment Options‬‬
‫ﺴﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﻨﺎﻓﺫﺓ ﺃﺨﺘﺭ ﻤﻨﻬﺎ ﺍﻟﺼﻔﺤﺔ ‪Library‬‬

‫ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Library path‬ﻟﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ‬

‫ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﻤﺠﺎﻭﺭ ﻟﻌﻨﺼﺭ ﺍﻟﺘﺤﺭﻴﺭ ﺒﺎﻷﺴﻔل‬
‫) ‪( ...‬‬

‫‪159‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻭﺤﺩﺩ ﻤﺴﺎﺭ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺫﻱ ﻗﻤﺕ ﺒﺈﻀﺎﻓﺘﻪ ) ﺤﺩﺩ ﻤﺴﺎﺭ ﻤﻠﻔﺎﺕ ‪ bpl‬ﺃﻭ ﻤﻠﻔﺎﺕ ‪ Dcu‬ﻭﻤﻠﻔﺎﺕ ‪ ( pas‬ﺜﻡ ﺍﻀﻐﻁ ﻋﻠﻰ‬
‫‪ Add‬ﻭﻤﻥ ‪Ok‬‬

‫ﺒﺈﻤﻜﺎﻨﻙ ﺍﻵﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺠﺩﻴﺩ ﺒﺎﻟﻁﺭﻴﻘﺔ ﺍﻟﺘﻲ ﻜﻨﺎ ﻨﺴﺘﺨﺩﻤﻬﺎ ﻤﻊ ﺃﻱ ﻋﻨﺼﺭ ﺴﺎﺒﻕ ﻤﻥ ﻋﻨﺎﺼﺭ ﺩﻟﻔﻲ ‪ )،‬ﻴﻔﻀل‬
‫ﺍﺴﺘﻌﺭﺍﺽ ﺍﻷﻤﺜﻠﺔ ﺍﻟﺘﻲ ﺘﺄﺘﻲ ﻤﻊ ﺍﻟﻌﻨﺼﺭ ﻋﺎﺩﺓ ﻓﻲ ﺍﻟﻔﻬﺭﺱ ‪( Demo‬‬
‫‪ 2‬ـ ﺍﺴﺘﺨﺩﺍﻡ ﻤﻠﻔﺎﺕ ‪: .Dpk‬‬
‫ﺇﺫﺍ ﻭﺠﺩ ﻤﻊ ﺍﻟﻌﻨﺼﺭ ﻤﻠﻑ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ ) .Dpk‬ﻤﻠﻑ ﺤﺯﻤﺔ ﺩﻟﻔﻲ ‪ ( Delphi Package‬ﻓﺎﺘﺒﻊ ﺍﻟﺨﻁﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ‬
‫ﻹﻀﺎﻓﺔ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﺇﻟﻰ ﺼﻔﺤﺔ ﺍﻟﻌﻨﺎﺼﺭ ‪:‬‬
‫ﺃ ـ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪ File Æ Open‬ﺤﺩﺩ ﺍﻟﻤﻠﻑ ﺫﻭ ﺍﻻﻤﺘﺩﺍﺩ ‪ .Dpk‬ﻭﺍﻀﻐﻁ ﻋﻠﻰ ‪ ok‬ﻟﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﺍﻀﻐﻁ ﻤﻨﻬﺎ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Install‬ﺴﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺭﺴﺎﻟﺔ ﺘﻌﻠﻤﻙ‬
‫ﺒﺄﻨﻪ ﻗﺩ ﺘﻡ ﺘﺤﻤﻴل ﺍﻟﻌﻨﺼﺭ ‪.‬‬
‫ﺏ ـ ﺍﻋﺩ ﺍﻟﺨﻁﻭﺓ ﺏ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﺴﺎﺒﻘﺔ ‪.‬‬
‫ﻤﻼﺤﻅﺔ ﻗﺩ ﺘﻅﻬﺭ ﺒﻌﺽ ﺍﻟﻤﺸﺎﻜل ﻋﻥ ﺍﺴﺘﺨﺩﺍﻡ ﻫﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ‪،‬‬
‫ﻟﺤل ﺍﻟﻤﺸﻜﻠﺔ ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ option‬ﻭﺍﺨﺘﺭ ﻤﻥ ﺍﻟﺼﻔﺤﺔ‬
‫‪ Description‬ﻭﻏﻴﺭ ﻓﻲ ﺍﻟﻘﺴﻡ ﺍﻟﻤﻭﻀﺢ ﻓﻲ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫ﺜﻡ ﺃﻏﻠﻕ ﻨﺎﻓﺫﺓ ﺍﻟﺨﻴﺎﺭﺍﺕ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ‪. Install‬‬

‫‪3‬ـ ﻓﻲ ﺤﺎل ﺍﻟﻌﻨﺼﺭ ﺍﻟﺠﺩﻴﺩ ﻤﻜﻭﻥ ﻤﻥ ﻤﻠﻑ ﻭﺍﺤﺩ ﻤﻥ ﺍﻻﻤﺘﺩﺍﺩ ‪: Pas‬‬
‫ﺃ ـ ﺍﻓﺘﺢ ﺍﻟﻤﻠﻑ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪File‬‬
‫‪: ÆOpen‬‬
‫ﺍﺨﺘﺭ ﺍﻟﻘﺎﺌﻤﺔ ‪Component Æ Install‬‬
‫‪ Component‬ﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺍﻟﻨﺎﻓﺫﺓ‬
‫ﺍﻟﻤﺠﺎﻭﺭﺓ‬
‫ﺍﺨﺘﺭ ﺍﻟﺼﻔﺤﺔ ‪Into New package‬‬
‫ﻭﺍﻜﺘﺏ ﺃﻱ ﺍﺴﻡ ﺘﺭﻴﺩ ﻓﻲ ﺍﻟﺤﻘل‬
‫‪ Package file name‬ﻭﺍﻀﻐﻁ ﻋﻠﻰ ‪ok‬‬
‫ﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻤﻭﻀﺤﺔ ﻓﻲ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﺜﺎﻨﻴﺔ ‪ ،‬ﺍﻀﻐﻁ ﻤﻨﻬﺎ ﻋﻠﻰ ‪. Install‬‬
‫‪160‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺏ ـ ﺃﻋﺩ ﺍﻟﺨﻁﻭﺓ ﺏ ﺍﻟﺴﺎﺒﻘﺔ ‪.‬‬
‫‪ 4‬ـ ﺒﻌﺽ ﺍﻟﻌﻨﺎﺼﺭ ﺘﺄﺘﻲ ﻤﻊ ﺒﺭﻨﺎﻤﺞ ﺘﻨﺼﻴﺏ ) ‪ ( Setup‬ﻭﺘﻘﻭﻡ ﺒﺘﻨﺼﻴﺏ ﻨﻔﺴﻬﺎ ﺘﻠﻘﺎﺌﻴ ﹰﺎ ‪.‬‬
‫ﻟﻤﺎﺫﺍ ﻫﺫﻩ ﺍﻟﻁﺭﻕ ﺍﻟﻤﺘﻌﺩﺩﺓ ‪:‬‬
‫ﻋﻤﻠﻴﹰﺎ ﻫﻨﺎﻙ ﻁﺭﻴﻘﺔ ﻭﺍﺤﺩﺓ ﻟﺘﺭﻜﻴﺏ ﺍﻟﻌﻨﺎﺼﺭ ﻭﻫﻲ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﺜﺎﻟﺜﺔ ﻭﻟﻜﻥ ﺒﻌﺽ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﻴﺤﺘﺎﺝ ﺇﻟﻰ ﺃﻜﺜﺭ ﻤﻥ ﻭﺤﺩﺓ‬
‫‪ Unit‬ﻓﻲ ﻋﻨﺼﺭﻩ ﻭﻟﺫﻟﻙ ﻴﻘﻭﻡ ﺒﺤﺯﻡ ﻫﺫﻩ ﺍﻟﻭﺤﺩﺍﺕ ﻓﻲ ﻤﻠﻑ ﺤﺯﻤﺔ ‪ Package‬ﻭﺒﺎﻟﺘﺎﻟﻲ ﻴﻨﺸﺄ ﻋﻨﺩﻨﺎ ﻤﻠﻑ ‪، .Dpk‬‬
‫ﻋﻨﺩﻤﺎ ﺘﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Install‬ﻓﻲ ﺍﻟﻨﺎﻓﺫﺓ ‪ Package‬ﻓﻲ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﺜﺎﻨﻴﺔ ﺃﻭ ﺍﻟﺜﺎﻟﺜﺔ ‪ ،‬ﺘﻘﻭﻡ ﺩﻟﻔﻲ ﺒﺈﻨﺸﺎﺀ ﺍﻟﻤﻠﻑ ﺫﻭ‬
‫ﺍﻻﻤﺘﺩﺍﺩ ‪ Bpl‬ﻭﻫﻭ ﻤﻠﻑ ﺍﻟﻤﻜﺘﺒﺎﺕ ﻓﻲ ﺩﻟﻔﻲ ) ﻓﻲ ﻟﻐﺔ ﺍﻟﻔﻴﺠﻭل ﺴﻲ ﺃﻭ ﺍﻟﻔﻴﺠﻭل ﺒﻴﺴﻙ ﻴﺘﻡ ﺍﻋﺘﻤﺎﺩ ﺍﻟﻤﻠﻔﺎﺕ ﺫﺍﺕ ﺍﻻﻤﺘﺩﺍﺩ‬
‫‪ DLL‬ﺃﻭ ‪. ( OCX‬‬
‫ﺘﺘﻤﻴﺯ ﺩﻟﻔﻲ ﻋﻥ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻷﺨﺭﻯ ﺒﺄﻨﻪ ﻻ ﺤﺎﺠﺔ ﻹﻀﺎﻓﺔ ﻤﻠﻔﺎﺕ ‪ Bpl‬ﺇﻟﻰ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻋﻥ ﺘﻭﺯﻴﻌﻪ ﺤﻴﺙ ﻴﺘﻡ ﺇﺩﺭﺍﺝ‬
‫ﻫﺫﻩ ﺍﻟﻤﻠﻔﺎﺕ ﺘﻠﻘﺎﺌﻴﹰﺎ ﻓﻲ ﺍﻟﻤﻠﻑ ﺍﻟﺘﻨﻔﻴﺫﻱ ‪ .Exe‬ﺒﻴﻨﻤﺎ ﻴﺠﺏ ﻋﻠﻴﻙ ﺇﺩﺭﺍﺝ ﻤﻠﻔﺎﺕ ﺍﻟـ ‪ .DLL‬ﻭ‪ Ocx‬ﻋﻨﺩ ﺍﺴﺘﺨﺩﺍﻡ ﻓﻴﺠﻭل‬
‫ﺴﻲ ﺃﻭ ﻓﻴﺠﻭل ﺒﻴﺴﻙ ‪.‬‬

‫ﺇﻨﺸﺎﺀ ﺍﻟﻌﻨﺎﺼﺭ ﻓﻲ ﺩﻟﻔﻲ ‪:‬‬

‫‪1‬ـ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻷﻭﻟﻰ ‪ :‬ﺴﻭﻑ ﻨﺘﻌﺭﻑ ﺍﻵﻥ ﻋﻠﻰ ﺃﺴﻬل ﻁﺭﻴﻘﺔ ﻹﻨﺸﺎﺀ ﺍﻟﻌﻨﺎﺼﺭ ﻓﻲ ﺩﻟﻔﻲ ‪:‬‬
‫ﺴﻭﻑ ﻨﻘﻭﻡ ﺒﺈﻨﺸﺎﺀ ﻋﻨﺼﺭ ﺘﺤﺭﻴﺭ ﻻ ﻴﻘﺒل ﺇﺩﺨﺎل ﺍﻷﺤﺭﻑ ﻭﻟﻌﻤل ﺫﻟﻙ ‪:‬‬
‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﺍﻟﻌﻨﺼﺭ ‪ Edit‬ﻭﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺍﻟﺤﺩﺙ ‪: OnKeyPress‬‬
‫;])‪const s= [ '1','2','3','4','5','6','7','8','9','0',char(Vk_back‬‬
‫‪begin‬‬
‫‪if not (key in s ) then‬‬
‫) ‪key := char(VK_CAPITAL‬‬
‫;‪end‬‬
‫ﺤﺩﺩ ﺒﻌﺩﻫﺎ ﺍﻟﻌﻨﺼﺭ ‪ Edit1‬ﻭﺍﺨﺘﺭ ‪ Component Æ Create Component Template‬ﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺍﻟﻨﺎﻓﺫﺓ‬
‫ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﺃﻜﺘﺏ ﻓﻲ ﺍﻟﺤﻘل ‪ Component name‬ﺍﺴﻡ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺘﻲ ﺘﺭﻴﺩ‬
‫) ‪ ( TNumEdit‬ﻭﺤﺩﺩ ﻓﻲ ﺍﻟﺤﻘل ‪ Palette Page‬ﺍﺴﻡ‬
‫ﺍﻟﺼﻔﺤﺔ ﺍﻟﺘﻲ ﺘﺭﻴﺩ ﺃﻥ ﻴﻅﻬﺭ ﻓﻴﻬﺎ ﺍﻟﻌﻨﺼﺭ ) ﺒﺈﻤﻜﺎﻨﻙ ﺃﻥ ﺘﻜﺘﺏ‬
‫ﺍﺴﻡ ﺼﻔﺤﺔ ﺠﺩﻴﺩﺓ (‬
‫ﻜﻤﺎ ﻴﻤﻜﻨﻙ ﺘﺤﺩﻴﺩ ﺃﻴﻘﻭﻨﺔ ﻟﻠﻌﻨﺼﺭ ﺍﻟﺠﺩﻴﺩ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﻀﻐﻁ‬
‫ﻋﻠﻰ ﺍﻟﺯﺭ ‪. Change‬‬
‫ﺍﻀﻐﻁ ﻋﻠﻰ ‪ Ok‬ﺴﻴﻅﻬﺭ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺠﺩﻴﺩ ﻓﻲ ﺍﻟﺼﻔﺤﺔ ﺍﻟﺘﻲ ﺤﺩﺩﺘﻬﺎ ‪.‬‬
‫ﻴﻤﻜﻨﻙ ﻋﻨﺩﺌ ٍﺫ ﺍﺴﺘﺨﺩﺍﻤﻪ ﻓﻲ ﺠﻤﻴﻊ ﺒﺭﺍﻤﺠﻙ ﺍﻟﻼﺤﻘﺔ ‪.‬‬
‫‪ 2‬ـ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﺜﺎﻨﻴﺔ ‪ :‬ﺴﻨﻘﻭﻡ ﺒﻜﺘﺎﺒﺔ ﻨﻔﺱ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺴﺎﺒﻕ ﻭﻟﻜﻥ ﺒﻁﺭﻴﻕ ﺃﻓﻀل ‪.‬‬
‫ﺃﻏﻠﻕ ﺠﻤﻴﻊ ﺍﻟﻭﺤﺩﺍﺕ ﻓﻲ ﺩﻟﻔﻲ ‪File Æ Close All‬‬

‫‪161‬‬
http://www.alshater.net ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
: Component Æ New Component ‫ﺍﺨﺘﺭ ﺍﻷﻤﺭ‬
: ‫ﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﺎﻟﻴﺔ‬
TCustemEdit ‫ ﺍﻟﻘﻴﻤﺔ‬Ancestor type ‫ﺍﺨﺘﺭ ﻤﻥ ﺍﻟﻼﺌﺤﺔ‬
. ‫ﻭﻫﻲ ﺍﻟﻌﻨﺼﺭ ﺍﻷﺏ ﺍﻟﺫﻱ ﺴﻴﺭﺙ ﻋﻨﺼﺭﻨﺎ ﺍﻟﺠﺩﻴﺩ ﺨﻭﺍﺼﻪ‬
‫ ﺍﻜﺘﺏ ﺍﺴﻡ ﺍﻟﺼﻨﻑ ﺍﻟﺫﻱ ﺘﺭﻴﺩﻩ‬Class Name ‫ﻓﻲ ﺍﻟﺤﻘل‬
‫ﻟﻌﻨﺼﺭﻙ ﺃﻥ‬
TMyNumberEdit ( T ‫) ﻴﺠﺏ ﺃﻥ ﻴﺒﺩﺃ ﺒﺤﺭﻑ‬
‫ ﺍﻜﺘﺏ ﺍﺴﻡ ﺍﻟﺼﻔﺤﺔ ﺍﻟﺘﻲ ﺘﺭﻴﺩ ﺃﻥ‬Palette Page ‫ﻓﻲ ﺍﻟﺤﻘل‬
. ( MyComponent ) ‫ﻴﻅﻬﺭ ﺒﻬﺎ ﺍﻟﻌﻨﺼﺭ‬
: ‫ ﺒﺎﻟﺸﻜل ﺍﻟﺘﺎﻟﻲ‬MyNumEdit ‫ ﺴﺘﻅﻬﺭ ﺍﻟﻭﺤﺩﺓ‬ok ‫ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ‬

unit MyNumberEdit;
interface
uses
Windows, Messages, SysUtils, Classes, Controls, StdCtrls;
type
T MyNumberEdit = class(TCustomEdit)
private
{ Private declarations }

protected
{ Protected declarations }
public
{ Public declarations }
published
{ Published declarations }
end;
procedure Register;
implementation
procedure Register;
begin
RegisterComponents('Standard', [MyNumberEdit]);
end;
end.
: ‫ﺴﻨﺸﺭﺡ ﻜل ﺴﻁﺭ ﻤﻥ ﻫﺫﻩ ﺍﻷﺴﻁﺭ ﺒﺸﻜل ﻤﺒﺴﻁ‬
‫ ﻤﻥ‬TMyNumEdit ‫ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺘﻌﺭﻑ ﻨﻭﻉ ﺠﺩﻴﺩ ﺒﺎﺴﻡ‬TMyNumberEdit = class(TCustomEdit) ‫ ـ‬1
TEdit ‫ ﻫﻭ ﺍﻟﻨﻭﻉ‬TCustomEdit ‫ ) ﺍﻟﻨﻭﻉ‬TEdit ‫ ﻭﻫﻭ ﺍﻟﻨﻭﻉ ﺍﻟﻤﺸﺘﻕ ﻤﻨﻪ ﺍﻟﻨﻭﻉ‬TCustomEdit ‫ﺍﻟﻨﻭﻉ‬
. ( ‫ ﺤﻴﺙ ﺴﻨﻘﻭﻡ ﺒﺈﺩﺨﺎل ﺍﻷﺤﺩﺍﺙ ﻭﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﻤﻁﻠﻭﺒﺔ ﺒﻌﺩ ﻗﻠﻴل‬، ‫ﻭﻟﻜﻥ ﺒﺩﻭﻥ ﺃﻱ ﺨﺎﺼﺔ ﺃﻭ ﺤﺩﺙ‬

162
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ 2‬ـ ‪ : protected‬ﻴﺘﻡ ﻓﻲ ﻫﺫﺍ ﺍﻟﻘﺴﻡ ﺘﻌﺭﻴﻑ ﺒﻌﺽ ﺍﻟﻤﺘﺤﻭﻻﺕ ﻭﺍﻟﺘﻭﺍﺒﻊ ﻭﺍﻟﺨﺼﺎﺌﺹ ﻭﺍﻟﺘﻲ ﻴﻤﻜﻥ ﺍﻟﻭﺼﻭل ﺇﻟﻴﻬﺎ ﻤﻥ‬
‫ﻗﺒل ﻫﺫﻩ ﺍﻟﻭﺤﺩﺓ ) ﺍﻟﻭﺤﺩﺓ ﺍﻟﻤﻌﺭﻓﺔ ﺒﻬﺎ ( ﻭﻤﻥ ﺃﻱ ﻭﺤﺩﺓ ﻤﺸﺘﻘﺔ ) ﻤﻭﺭﻭﺜﺔ ( ﻤﻥ ﻫﺫﻩ ﺍﻟﻭﺤﺩﺓ ‪ .‬ﺃﻱ ﺃﻨﻨﺎ ﺇﺫﺍ ﻋﺭﻓﻨﺎ‬
‫ﻤﺘﺤﻭل ﻓﻲ ﻫﺫﻩ ﺍﻟﻤﻨﻁﻘﺔ ﻓﺈﻨﻨﺎ ﻴﻤﻜﻨﻨﺎ ﻗﺭﺍﺀﺓ ﻗﻴﻤﺘﻪ ﻭﺍﻟﻜﺘﺎﺒﺔ ﻓﻴﻪ ﻀﻤﻥ ﺃﻱ ﻭﺤﺩﺓ ﺘﺭﺘﺒﻁ ﻤﻊ ﺍﻟﻭﺤﺩﺓ‬
‫‪.MyNumberEdit‬‬
‫‪ 3‬ـ ‪ : published‬ﻴﺴﺘﺨﺩﻡ ﻫﺫﺍ ﺍﻟﻘﺴﻡ ﻟﺘﻌﺭﻴﻑ ﺍﻟﺨﺼﺎﺌﺹ ﻭﻫﻭ ﻴﺸﺒﻪ ﺍﻟﻘﺴﻡ ‪ Public‬ﻭﻴﺨﺘﻠﻑ ﻋﻨﻪ ﺃﻥ ﺍﻟﺨﺎﺼﺔ‬
‫ﺍﻟﻤﻌﺭﻓﺔ ﻫﻨﺎ ﺴﺘﻅﻬﺭ ﻓﻲ ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ) ‪ ( Object inspector‬ﻭﻓﻲ ﺼﻔﺤﺔ ‪ ... Event‬ﺴﻴﺘﻀﺢ ﻋﻤﻠﻪ ﻓﻴﻤﺎ‬
‫ﺒﻌﺩ ‪.‬‬
‫‪ 4‬ـ ‪: procedure Register‬‬
‫ﻤﻬﻤﺔ ﺍﻹﺠﺭﺍﺀ ﻫﻲ ﺍﺴﺘﺩﻋﺎﺀ ﺍﻹﺠﺭﺍﺀ ;)]‪ RegisterComponents('Standard', [MyNumberEdit‬ﻭﺍﻟﺫﻱ‬
‫ﻴﻘﻭﻡ ﺒﺈﻅﻬﺎﺭ ﺍﻟﻌﻨﺼﺭ ‪ MyNumberEdit‬ﻓﻲ ﺍﻟﺼﻔﺤﺔ ‪ Standard‬ﻤﻥ ﺼﻔﺤﺎﺕ ﺍﻟﻌﻨﺎﺼﺭ ‪.‬‬
‫ﺍﻵﻥ ﺴﻭﻑ ﻨﺒﺩﺃ ﺒﺈﻀﺎﻓﺔ ﺒﻌﺽ ﺍﻟﺨﺎﺼﺔ ‪ About‬ﻭﺍﻟﺘﻲ ﺴﺘﻅﻬﺭ ﻓﻲ ﺼﻔﺤﺔ ﺍﻟﺨﻭﺍﺹ ﺍﻟﺨﺎﺼﺔ ‪ About‬ﻭﻓﻴﻬﺎ ﺍﺴﻡ‬
‫ﻤﺒﺭﻤﺞ ﺍﻟﻌﻨﺼﺭ ‪.‬‬
‫ـ ﺃﻀﻑ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺍﻟﻘﺴﻡ ‪: Public‬‬
‫;‪constructor Create(AOwner: TComponent); override‬‬
‫ﺤﻴﺙ ‪ Constructor‬ﻫﻭ ﻤﻨﻬﺞ ﺨﺎﺹ ﻴﺴﺘﺨﺩﻡ ﻤﻊ ‪ Create‬ﻓﻘﻁ ﻭﻴﻘﻭﻡ ﺒﺈﻨﺸﺎﺀ ﺍﻟﻌﻨﺼﺭ ﻭﺘﻬﻴﺌﺘﻪ ﺃﻱ ﺇﻋﻁﺎﺀﻩ ﺍﻟﻘﻴﻡ‬
‫ﻻ ﻤﻥ ‪. Procedure‬‬
‫ﺍﻻﺒﺘﺩﺍﺌﻴﺔ ﻭﻴﻤﻜﻥ ﺍﻋﺘﺒﺎﺭﻩ ﺇﺠﺭﺍﺀ ﺘﺴﺘﺨﺩﻡ ﻓﻴﻪ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Constructor‬ﺒﺩ ﹰ‬
‫ـ ﺃﻀﻑ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Published‬ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪Property About : string Read FAbout Write Fabout‬‬
‫ﻀﻊ ﻤﺅﺸﺭ ﺍﻟﺘﺤﺭﻴﺭ ) ﻤﺅﺸﺭ ﻟﻭﺤﺔ ﺍﻟﻤﻔﺎﺘﻴﺢ ( ﻋﻨﺩ ﻫﺫﺍ ﺍﻟﺴﻁﺭ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﻤﻔﺎﺘﻴﺢ ‪ Ctrl + Shift + C‬ﺴﻴﻀﺎﻑ‬
‫ﻋﻨﺩﻫﺎ ﺍﻟﻤﺘﺤﻭل ‪ FAbout‬ﻤﻥ ﺍﻟﻨﻭﻉ ‪ String‬ﺇﻟﻰ ﺍﻟﻘﺴﻡ ‪. private‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺘﻌﺭﻴﻑ ﺨﺎﺼﺔ ﻤﻥ ﺍﺴﻤﻬﺎ ‪ About‬ﻤﻥ ﺍﻟﻨﻭﻉ ‪ String‬ﺘﺄﺨﺫ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﻗﻴﻤﺘﻬﺎ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ﻤﻥ‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ‬
‫‪ Read FAbout‬ﻭﺘﺄﺨﺫ ﻗﻴﻤﺘﻬﺎ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ﻤﻥ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪. Write FAbout‬‬
‫ـ ﻀﻊ ﻤﺅﺸﺭ ﺍﻟﺘﺤﺭﻴﺭ ﻋﻠﻰ ﺍﻟﻤﻨﻬﺞ ‪ Constructor‬ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﻤﻔﺎﺘﻴﺢ ‪ Ctrl + Shift + C‬ﺴﻴﻀﺎﻑ ﻋﻨﺩﻫﺎ‬
‫ﻫﺫﺍ ﺍﻟﻤﻨﻬﺞ ﺇﻟﻰ ﺍﻟﻘﺴﻡ ‪ Implementation‬ﻭﺍﻟﺫﻱ ﺴﻴﺒﺩﺃ ﺒﺎﻟﺘﻌﻠﻴﻤﺔ ‪ Inherited‬ﻭﺍﻟﺘﻲ ﺘﺠﻌل ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﻴﺭﺙ ﺠﻤﻴﻊ‬
‫ﺨﻭﺍﺹ ﺍﻟﺘﺎﺒﻊ ﺍﻷﺼل ﺍﻟﻤﻌﺭﻑ ﻓﻲ ﺍﻟﻭﺤﺩﺓ ‪. TCustomEdit‬‬
‫ـ ﺃﻀﻑ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﺒﻌﺩ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪: Inherited‬‬
‫;'‪FABout := 'M.Khaled Nasser Agha‬‬
‫ﻗﻡ ﺒﺤﻔﻅ ﺍﻟﻭﺤﺩﺓ ﺒﺎﺴﻡ ‪. MyNumberEdit‬‬
‫ـ ﺍﻓﺘﺢ ﺍﻟﻨﺎﻓﺫﺓ ‪ Component Æ install component‬ﺴﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻤﺸﺭﻭﺤﺔ ﻓﻲ ﺍﻟﻔﻘﺭﺓ ﺍﻟﺜﺎﻟﺜـﺔ ﻤـﻥ ﻁـﺭﻕ‬
‫ﺘﺭﻜﻴﺏ ﻋﻨﺼﺭ ﺠﺩﻴﺩ ﻋﻠﻰ ﻜل ﺤﺎل ﺍﻓـﺘﺢ ﺍﻟـﺼﻔﺤﺔ ‪ into new package‬ﻭﺍﻜﺘـﺏ ‪ Editnumber‬ﻓـﻲ ﺍﻟﺤﻘـل‬
‫‪ Package File Name‬ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ ok‬ﺴﺘﻔﺘﺢ ﻋﻨﺩﻫﺎ ﻨﺎﻓﺫﺓ ﺠﺩﻴﺩﺓ ﺍﻀﻐﻁ ﻓﻴﻬﺎ ﻋﻠﻰ ﺃﺤﺩ ﺍﻟﺯﺭﻴﻥ ‪ Install‬ﺃﻭ‬

‫‪163‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ ، Compile‬ﺴﻴﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺍﻟﻌﻨﺼﺭ ﻓﻲ ﺁﺨﺭ ﺍﻟﺼﻔﺤﺔ ‪ ) Standard‬ﺇﺫﺍ ﻜﻨﺕ ﻗﺩ ﻜﺘﺒﺕ ﺍﻟﺘﻌﻠﻴﻤـﺎﺕ ﺍﻟـﺴﺎﺒﻘﺔ ﺒـﺩﻭﻥ‬
‫ﺃﺨﻁﺎﺀ ( ﺃﻏﻠﻕ ﻨﺎﻓﺫﺓ ﻭﺍﺤﻔﻅ ﺍﻟﻤﻠﻔﺎﺕ ﺇﺫﺍ ﻁﹲﻠﺏ ﺫﻟﻙ ‪.‬‬
‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﻀﻊ ﻋﻠﻴﻪ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺠﺩﻴﺩ ﺴﺘﺠﺩ ﺃﻥ ﺃﻭل ﺨﺎﺼﺔ ﻟﻪ ﻓﻲ ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ﻫﻲ ﺍﻟﺨﺎﺼـﺔ ‪About‬‬
‫ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺃﻥ ﺍﻟﺨﻭﺍﺹ ﻤﺨﺘﺼﺭﺓ ﺒﺸﻜل ﻜﺒﻴﺭ ‪ ،‬ﺍﻓﺘﺢ ﺍﻟﺼﻔﺤﺔ ‪ Events‬ﻭﻻﺤﻅ ﻋﺩﻡ ﻭﺠﻭﺩ ﺃﻱ ﺤﺩﺙ ﻟﻬﺫﺍ ﺍﻟﻌﻨﺼﺭ‬
‫‪.‬‬
‫ﺴﻨﻘﻭﻡ ﺍﻵﻥ ﺒﺈﻀﺎﻓﺔ ﺍﻟﺨﺎﺼﺔ ‪ Num‬ﻟﻬﺫﺍ ﺍﻟﻌﻨﺼﺭ ﺤﻴﺙ ﺴﻴﺘﻡ ﺇﺩﺨﺎل ﺭﻗﻡ ﺇﻟﻰ ﺍﻟﻌﻨﺼﺭ ﻭ ﺍﻟﺤﺼﻭل ﻤﻨﻪ ﻋﻠﻰ ﺭﻗﻡ ﻤـﻥ‬
‫ﺨﻼل ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ) ﺴﺘﺤل ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﻤﺤل ﺍﻟﺨﺎﺼﺔ ‪ Text‬ﻓﻲ ﺍﻟﻌﻨﺼﺭ ﻤﻥ ﺍﻟﻨﻭﻉ ‪. ( TEdit‬‬
‫ﺃﻏﻠﻕ ﺍﻵﻥ ﺠﻤﻴﻊ ﺍﻟﻨﻭﺍﻓﺫ ﻭﻤﻥ ﺍﻟﻘﺎﺌﻤـﺔ ‪ File Æ ReOpen‬ﺍﺨﺘـﺭ‬
‫‪ Editnumber.dpk‬ﺴﺘﻅﻬﺭ ﺍﻵﻥ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻤﺠﺎﻭﺭﺓ‪ ،‬ﺍﻀﻐﻁ ﻤـﺭﺘﻴﻥ‬
‫‪ MyNumberEdit.pas‬ﺴﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﻫﺫﻩ ﺍﻟﻭﺤﺩﺓ ﻓـﻲ ﻤﺤـﺭﺭ‬
‫ﺍﻟﺸﻴﻔﺭﺓ ‪ ،‬ﻨﺴﺘﻁﻴﻊ ﺍﻵﻥ ﺇﺠﺭﺍﺀ ﺍﻟﺘﻌﺩﻴﻼﺕ ﺍﻟﺘﻲ ﻨﺭﻴﺩ ﻋﻠﻰ ﻫﺫﻩ ﺍﻟﻭﺤﺩﺓ‬
‫ﻭﻤﻥ ﺜﻡ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Compile‬ﻟﻠﺘﻨﻘل ﺍﻟﺘﻌﺩﻴﻼﺕ ﺇﻟﻰ ﺍﻟﻌﻨﺼﺭ‬
‫‪ TMyNumberEdit‬ﺍﻟﻤﻭﺠﻭﺩ ﻋﻠﻰ ﺍﻟﺼﻔﺤﺔ ‪... Standard‬‬
‫ﺃﻀﻑ ﺍﻵﻥ ﺍﻟﺴﻁﺭ ﺍﻟﺘﺎﻟﻲ ﺇﻟﻰ ﺍﻟﻘﺴﻡ ‪. Published‬‬

‫;‪property Num: Extended read FNum write SetFNum‬‬

‫ﻀﻊ ﻤﺅﺸﺭ ﺍﻟﺘﺤﺭﻴﺭ ﻋﻨﺩ ﻫﺫﺍ ﺍﻟﺴﻁﺭ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ‪ Ctrl + Shift + C‬ﺴﻴﺘﻡ ﻋﻨﺩﻫﺎ ﺘﻌﺭﻴﻑ ﺍﻟﻤﺘﺤﻭل ‪ FNum‬ﻓﻲ‬
‫ﺍﻟﻘﺴﻡ ‪ Private‬ﻭﺘﻌﺭﻴﻑ ﺍﻹﺠﺭﺍﺀ ‪ SetNum‬ﺃﻴﻀﹰﺎ ‪ ،‬ﻭﻓﻲ ﺍﻟﻘﺴﻡ ‪ Implementation‬ﺴﻴﺘﻡ ﺇﻀﺎﻓﺔ ﺠـﺴﻡ ﺍﻹﺠـﺭﺍﺀ‬
‫ﺃﻀﻑ ﺇﻟﻴﻬﺎ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬ ‫‪ SetNum‬ﻭﺴﺘﻭﺠﺩ ﻓﻴﻪ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪FNum := Value :‬‬
‫;)‪Text := floattostr(value‬‬
‫ﺍﺤﻔﻅ ﺍﻟﻭﺤﺩﺓ ﻭﻋﺩ ﺇﻟﻰ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺴﺎﺒﻘﺔ ) ﺴﺘﻜﻭﻥ ﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﺨﻠﻑ ﻋﺎﺩﺓ ( ﺍﻀﻐﻁ ﻤﻨﻬﺎ ﻋﻠﻰ ﺍﻟـﺯﺭ ‪ Compile‬ﺜـﻡ‬
‫ﺃﻏﻠﻕ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﻭﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﺃﻀﻑ ﺇﻟﻴﻪ ﺍﻟﻌﻨﺼﺭ ‪ MyNumberEdit‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪ Standard‬ﺴـﺘﻼﺤﻅ‬
‫ﺃﻥ ﻟﻬﺫﺍ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺨﺎﺼﺔ ‪ Num‬ﺃﺩﺨل ﻓﻴﻬﺎ ﺃﻱ ﻗﻴﻤﺔ ﻋﺩﺩﻴﺔ ﻟﺘﻅﻬﺭ ﻓﻲ ﺍﻟﻌﻨﺼﺭ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ‪ ،‬ﺃﺩﺨل ﻤﺠﻤﻭﻋﺔ ﻤـﻥ‬
‫ﺍﻷﺤﺭﻑ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Enter‬ﺴﺘﻼﺤﻅ ﻋﺩﻡ ﻗﺒﻭل ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﻹﺩﺨﺎل ﺍﻷﺤﺭﻑ ‪.‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺃﺩﺨل ﺤﺭﻭﻑ ﻓﻲ ﺍﻟﻌﻨﺼﺭ ﺴﺘﻼﺤﻅ ﻗﺒﻭل ﺍﻟﻌﻨﺼﺭ ﻟﻬﺎ ﻭﻫﺫﺍ ﻴﺩﻓﻌﻨﺎ ﺇﻟﻰ ﺍﻟﺨﻁﻭﺓ ﺍﻟﺘﺎﻟﻴـﺔ ﻓـﻲ ﺘﻁـﻭﻴﺭ‬
‫ﺍﻟﻌﻨﺼﺭ ﻭﻫﻲ ﻤﻨﻊ ﺇﺩﺨﺎل ﺍﻷﺤﺭﻑ ﺇﻟﻴﻪ ‪.‬‬
‫ﺍﻓﺘﺢ ﺍﻟﺤﺯﻤﺔ ‪ EditNumber.dpk‬ﺜﻡ ﺍﻓﺘﺢ ﺍﻟﻭﺤﺩﺓ ‪. MyNumberEdit.pas‬‬
‫ﺴﻭﻑ ﻨﻀﻴﻑ ﺍﻟﺘﺎﺒﻊ ‪ KeyPress‬ﺇﻟﻰ ﻭﺤﺩﺘﻨﺎ ﻭﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﻤﻌﺭﻑ ﻓﻲ ﺍﻟﻭﺤﺩﺓ ‪ TCustomEdit‬ﻭﻫﻭ ﺍﻟﻤـﺴﺅﻭل ﻋـﻥ‬
‫ﺍﺴﺘﻘﺒﺎل ﺃﺤﺭﻑ ﻟﻭﺤﺩﺓ ﺍﻟﻤﻔﺎﺘﻴﺢ ﻟﺫﻟﻙ ﺃﻀﻑ ﺍﻟﺴﻁﺭ ﺍﻟﺘﺎﻟﻲ ﻓﻲ ﺍﻟﻘﺴﻡ ‪: Public‬‬
‫;‪procedure KeyPress(var Key: Char); override‬‬
‫ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﻤﻔﺎﺘﻴﺢ ‪ Ctrl + Shift + C‬ﻟﻴﻀﺎﻑ ﺠﺴﻡ ﺍﻹﺠﺭﺍﺀ ﺘﻠﻘﺎﺌﻴﹰﺎ ﻭﺘﻀﺎﻑ ﻓﻴـﻪ ﺍﻟﺘﻌﻠﻴﻤـﺔ ‪ Inherited‬ﻟﻜـﻲ‬
‫ﻴﻭﺭﺙ ﺠﻤﻴﻊ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻹﺠﺭﺍﺀ ‪ KeyPress‬ﺍﻟﻤﻭﺠﻭﺩ ﻓﻲ ﺍﻟﻭﺤﺩﺓ ﺍﻷﺏ ﺍﻟﻤﻌﺭﻑ ﻓﻴﻬﺎ ‪TCustomEdit‬‬
‫ﺃﻀﻑ ﺍﻵﻥ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻭﻕ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ Implementation‬ﻤﺒﺎﺸﺭﺓ ‪:‬‬
‫‪164‬‬
http://www.alshater.net ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
const NumberChar = [ '1','2','3','4','5','6','7','8','9','0','.'];
: Inherited ‫ ﻭﺒﻌﺩ ﺍﻟﺘﻌﻠﻴﻤﺔ‬KeyPress ‫ﻭﺃﻀﻑ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺠﺴﻡ ﺍﻹﺠﺭﺍﺀ‬
If not (key in NumberChar ) Then key := char(VK_Capital);
. ‫ ﺜﻡ ﺃﻏﻠﻘﻬﺎ‬EditNumber.dpk ‫ ﻓﻲ ﻨﺎﻓﺫﺓ ﺍﻟﻤﺠﻤﻭﻋﺔ‬Compile ‫ﺍﺤﻔﻅ ﺍﻟﻭﺤﺩﺓ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ‬
. ‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﻋﻨﺼﺭﻨﺎ ﺍﻟﺠﺩﻴﺩ ﻭﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ‬
‫ ﺒﺎﻹﻀـﺎﻓﺔ‬Edit ‫ﺒﻘﻴﺕ ﻤﺸﻜﻠﺔ ﻭﺤﻴﺩﺓ ﻓﻲ ﻋﻨﺼﺭﻨﺎ ﻭﻫﻲ ﻋﺩﻡ ﻭﺠﻭﺩ ﻋﺩﺩ ﻜﺒﻴﺭ ﻤﻥ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﻌﻨﺼﺭ‬
‫ ﻭﺃﻜﺘﺏ ﺃﺴـﻤﺎﺀ ﺍﻟﺨـﻭﺍﺹ ﻭﺍﻷﺤـﺩﺍﺙ ﺍﻟﺘـﻲ‬Editnumber.dbk ‫ﺇﻟﻰ ﻋﺩﻡ ﻭﺠﻭﺩ ﺃﺤﺩﺍﺙ ﻭﻹﻀﺎﻓﺘﻬﺎ ﺍﻓﺘﺢ ﺍﻟﺤﺯﻤﺔ‬
: ‫ ﻜﻤﺎ ﻓﻲ ﺍﻟﺸﻜل‬Published ‫ﺘﺤﺘﺎﺠﻬﺎ ﻓﻲ ﻋﻨﺼﺭﻙ ﻓﻲ ﺍﻟﻘﺴﻡ‬
property BiDiMode;
property CharCase;
property Color;

property OnEnter;
property OnKeyPress;
property OnKeyDown;
property OnKeyUp;
‫ ﺜﻡ ﺃﻀﻑ ﻋﻨﺼﺭﻨﺎ ﺍﻟﺠﺩﻴﺩ ﺇﻟﻰ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ ﻟـﺘﻼﺤﻅ ﻭﺠـﻭﺩ ﻫـﺫﻩ‬Compile ‫ﻭﺍﺤﻔﻅ ﺍﻟﻭﺤﺩﺓ ﺒﻌﺩﻫﺎ ﻭﺍﻀﻐﻁ ﻋﻠﻰ‬
. ‫ﺍﻟﺨﻭﺍﺹ ﻓﻴﻪ‬
: MynumberEdit.pas ‫ﻭﻓﻴﻤﺎ ﻴﻠﻲ ﺍﻟﻨﺹ ﺍﻟﻜﺎﻤل ﻟﻠﻭﺤﺩﺓ‬
unit MyNumberEdit;
interface
uses
Windows, Messages, SysUtils, Classes, Controls, StdCtrls;
type
TMyNumberEdit = class(TCustomEdit)
private
FAbout: string;
FNum: Extended;
procedure SetFNum(const Value: Extended);
{ Private declarations }
protected
{ Protected declarations }
public
constructor Create(AOwner: TComponent); override;
procedure KeyPress(var Key: Char); override;
{ Public declarations }
published
Property About : string Read FAbout Write Fabout;
property Num: Extended read FNum write SetFNum;
property BiDiMode;
property CharCase;
property Color;
165
http://www.alshater.net ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
property Enabled;
property Font;
property ParentBiDiMode;
property ParentColor;
property ParentCtl3D;
property ParentFont;
property PasswordChar;
property ReadOnly;
property ShowHint;
property TabOrder;
property TabStop;
property Visible;
property OnChange;
property OnClick;
property OnDblClick;
property OnEnter;
property OnExit;
property OnKeyDown;
property OnKeyUp;
{ Published declarations }
end;
procedure Register;
const NumberChar = [ '1','2','3','4','5','6','7','8','9','0','.'];
implementation
procedure Register;
begin
RegisterComponents('Standard', [TMyNumberEdit]);
end;
{ TMyNumberEdit }
constructor TMyNumberEdit.Create(AOwner: TComponent);
begin
inherited;
FABout := 'M.Khaled Nasser Agha';
end;
procedure TMyNumberEdit.KeyPress(var Key: Char);
begin
inherited;
if not (key in NumberChar ) then
key := char(VK_Capital);
end;
procedure TMyNumberEdit.SetFNum(const Value: Extended);
begin
FNum := Value;
Text := floattostr(value);
end;
end.
166
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ‪25‬‬

‫ﺍﻟﺴﺤﺏ ﻭﺍﻹﻓﻼﺕ ‪: Drag and Drop :‬‬

‫‪ 1‬ـ ﻓﻬﻡ ﺍﻟﻭﺴﻴﻁ ‪: Sender‬‬
‫ﻻ ﺒﺩ ﺃﻨﻙ ﻻﺤﻅﺕ ﺃﻥ ﺍﻟﻭﺴﻴﻁ ‪ Sender‬ﻴﺩﺨل ﻓﻲ ﺠﻤﻴﻊ ﻤﻌﺎﻟﺠﺎﺕ ﺃﺤﺩﺍﺙ ﺍﻟﺼﻔﺤﺔ ‪ Event‬ﻓﻔﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠـﻰ‬
‫ﺍﻟﺯﺭ ﻴﻅﻬﺭ ﺍﻹﺠﺭﺍﺀ ﺍﻟﺘﺎﻟﻲ ﻭﺍﻟﺫﻱ ﻟﻪ ﻭﺴﻴﻁ ﻭﺍﺤﺩ ﻫﻭ ‪ Sender‬ﻤﻥ ﺍﻟﻨﻭﻉ ‪. TObject‬‬
‫;)‪procedure TForm1.Button1Click(Sender: TObject‬‬
‫ﻤﻬﻤﺔ ﻫﺫﺍ ﺍﻟﻭﺴﻴﻁ ﻫﻲ ﺇﺭﺠﺎﻉ ﺍﺴﻡ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺫﻱ ﻗﺎﻡ ﺒﺎﻟﺤﺩﺙ ﺃﻱ ﺃﻥ ﻗﻴﻤﺘﻪ ﻋﻥ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟـﺯﺭ ‪ Button1‬ﻫـﻲ‬
‫‪. Button1‬‬
‫ﻭﻟﻔﻬﻡ ﺃﻋﻤﻕ ﻟﻬﺫﺍ ﺍﻟﻭﺴﻴﻁ ﻨﻔﺫ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﺯﺭﻴﻥ ‪: Button‬‬
‫‪ 1‬ـ ﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Button1‬ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;)' ‪If sender = Button1 Then Showmessage ( ' You Click On Button1‬‬
‫;)' ‪If sender = Button2 Then Showmessage ( ' You Click on Button2‬‬
‫‪ 2‬ـ ﺤﺩﺩ ﺍﻟﺯﺭ ‪ Button2‬ﺜﻡ ﺍﻨﺘﻘل ﺇﻟﻰ ﺍﻟﺼﻔﺤﺔ ‪ Event‬ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺴﻬﻡ ﺍﻟﻤﺠﺎﻭﺭ ﻟﻠﺨﺎﺼﺔ ‪ OnClick‬ﻭﺍﺨﺘـﺭ‬
‫ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ‬
‫‪. Button1Click‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭﻴﻥ ﻭﻻﺤﻅ ﺍﻟﻨﺘﺎﺌﺞ ‪.‬‬
‫‪ 2‬ـ ﺍﻟﺴﺤﺏ ﻭﺍﻹﻓﻼﺕ ‪:‬‬
‫ﻤﺜﺎل ‪ : 1‬ﺃﻀﻑ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﻓﻲ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ ﺜﻼﺜﺔ ﻋﻨﺎﺼﺭ ‪ Label‬ﻭﻋﻨـﺼﺭ ‪ : ListBox‬ﺴـﻨﻘﻭﻡ ﺍﻵﻥ ﺒﻜﺘﺎﺒـﺔ‬
‫ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﺘﻲ ﺘﻤﻜﻨﻨﺎ ﻤﻥ ﺴﺤﺏ ﺍﻟﻌﻨﺎﺼﺭ ‪ Label‬ﻭﺇﻓﻼﺘﻬﺎ ﻓﻭﻕ ﺍﻟﻌﻨﺼﺭ ‪ ListBox‬ﺒﺤﻴـﺙ ﻴـﺼﺒﺢ ﻟـﻭﻥ‬
‫ﺍﻟﻌﻨﺼﺭ ﺍﻟﻼﺌﺤﺔ ‪ LIstBox1‬ﺒﻠﻭﻥ ﺍﻟﻌﻨﺼﺭ ‪ Label‬ﺍﻟﻤﺴﺤﻭﺏ‪ ،‬ﻟﺫﻟﻙ ﺃﻋﻁ ﻜل ﻤﻥ ﺍﻟﻌﻨﺎﺼﺭ ‪ Label‬ﻟـﻭﻥ ﻤﺨﺘﻠـﻑ‬
‫ﻭﺃﻋﻁﻬﻡ ﺠﻤﻴﻌﹰﺎ ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ DragMode‬ﺍﻟﻘﻴﻤﺔ ‪. dmAutomatic‬‬
‫ﺍﻜﺘﺏ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnDragOver‬ﻟﻠﻌﻨﺼﺭ ‪ ListBox1‬ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪Accept := Source is Tlabel‬‬
‫ﻴﺤﻭﻱ ﺍﻹﺠﺭﺍﺀ ‪ ListBox1DragOver‬ﺍﻟﻭﺴﻁﺎﺀ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ : Sender‬ﺍﻟﻌﻨﺼﺭ ﺍﻟﺫﻱ ﻴﺴﺘﺩﻋﻲ ﺍﻹﺠﺭﺍﺀ ﻭﻫﻭ ﻫﻨﺎ ﺍﻟﻌﻨﺼﺭ ‪. ListBox1‬‬
‫‪ : Source‬ﺍﻟﻌﻨﺼﺭ ﺍﻟﺫﻱ ﻴﺘﻡ ﺴﺤﺒﻪ ﻭﻫﻭ ﺃﺤﺩ ﺍﻟﻌﻨﺎﺼﺭ ‪ Label‬ﻓﻲ ﻤﺜﺎﻟﻨﺎ ‪.‬‬
‫‪ : X,Y‬ﺇﺤﺩﺍﺜﻴﺎﺕ ﻤﺅﺸﺭ ﺍﻟﻔﺄﺭﺓ ‪.‬‬
‫‪ : State‬ﻴﺤﺩﺩ ﻁﺭﻴﻘﺔ ﺘﺤﺭﻙ ﺍﻟﻔﺄﺭﺓ ﻓﻭﻕ ﺍﻟﻌﻨﺼﺭ ‪.‬‬
‫‪ : Accept‬ﻋﻨﺩﻤﺎ ﻴﺄﺨﺫ ﻫﺫﺍ ﺍﻟﻤﺘﺤﻭل ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻓﺈﻥ ﺍﻟﻌﻨﺼﺭ ﺴﻭﻑ ﻴﻜﻭﻥ ﺠﺎﻫﺯﹰﺍ ﻹﻓﻼﺕ ﺍﻟﻌﻨﺼﺭ ﻓﻭﻗﻪ ) ﺴـﻴﺘﻐﻴﺭ‬
‫ﺸﻜل ﻤﺅﺸﺭ ﺍﻟﻔﺄﺭﺓ ﻟﻴﻅﻬﺭ ﺒﺎﻟﺸﻜل ﺍﻟﺫﻱ ﻴﺒﻴﻥ ﺃﻥ ﺍﻹﻓﻼﺕ ﻤﻘﺒﻭل (ﻭﺇﻻ ﻓﺈﻥ ﺍﻟﻌﻨﺼﺭ ﺴﻴﺭﻓﺽ ﺇﻓﻼﺕ ﺍﻟﻌﻨﺼﺭ ﺍﻟﻤﺴﺤﻭﺏ‬
‫ﻓﻭﻗﻪ ‪.‬‬
‫‪167‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ : Source Is Tlabel‬ﺘﻌﻴﺩ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﺇﺫﺍ ﻜﺎﻥ ﺍﻟﻤﺘﺤﻭل ‪ Source‬ﻤﻥ ﺍﻟﻨﻭﻉ ‪. Tlabel‬‬
‫ﺍﻜﺘﺏ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnDragDrop‬ﻟﻨﻔﺱ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; ‪( sender as Tlistbox ).color := (Source as Tlabel ).color‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ Sender As TlistBox‬ﺘﺴﻤﺢ ﻟﻨﺎ ﺒﺎﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻭﺴﻴﻁ ‪ Sender‬ﻜﻤﺎ ﻨﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻌﻨﺼﺭ ‪ Tlistbox‬ﻨﻔﺴﻪ‬
‫‪.‬‬
‫ﻜﺫﻟﻙ ﺒﺎﻟﻨﺴﺒﺔ ﻟﻠﻌﻨﺼﺭ ‪. Source As Tlabel‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﺴﺤﺏ ﺃﺤﺩ ﺍﻟﻌﻨﺎﺼﺭ ‪ Label‬ﻭﺃﺘﺭﻜﻪ ﻓﻭﻕ ﺍﻟﻌﻨﺼﺭ ‪ ListBox1‬ﻭﻻﺤﻅ ﺍﻟﻨﺘﺎﺌﺞ ‪.‬‬
‫ﻤﺜﺎل ‪: 2‬‬
‫ﺃﻀﻑ ﻋﻨﺼﺭ ﺼﻭﺭﺓ ‪ Image‬ﺇﻟﻰ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﻭﺍﺠﻌﻠﻪ ﻴﻅﻬﺭ ﺼﻭﺭﺓ ﻤﺎ ﻋﻥ ﻁﺭﻴـﻕ ﺍﻟﺨﺎﺼـﺔ ‪ ،Picture‬ﺃﻋـﻁ‬
‫ﺍﻟﺨﺎﺼﺔ ‪ DragMode‬ﺍﻟﻘﻴﻤﺔ ‪ dmAutomatic‬ﺴﻨﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﻼﺯﻤﺔ ﺍﻟﺘﻲ ﺘﻤﻜﻨﻨﺎ ﻤﻥ ﻭﻀﻊ ﺍﻟﻌﻨﺼﺭ ‪Image1‬‬
‫ﻓﻲ ﻤﻜﺎﻥ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ‪.‬‬
‫ﺍﻜﺘﺏ ﻓﻲ ﺍﻟﺤﺩﺙ ﺍﻜﺘﺏ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnDragOver‬ﻟﻠﻨﻤﻭﺫﺝ ‪ Form1‬ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪accept := Source is Timage‬‬

‫ﺍﻜﺘﺏ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnDragDrop‬ﻟﻠﻨﻤﻭﺫﺝ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫;‪(Source as Timage).Top := y‬‬
‫;‪(Source as Timage).Left := X‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺤﺭﻙ ﺍﻟﻌﻨﺼﺭ ‪ Image1‬ﻭﻻﺤﻅ ﺘﻨﻘﻠﻪ ﻓﻭﻕ ﺃﻱ ﻤﻜﺎﻥ ﻤﻥ ﺍﻟﻨﻤﻭﺫﺝ ﻭﻻﺤﻅ ﺃﻴﻀﹰﺎ ﺃﻨﻪ ﻻ ﻴﻤﻜـﻥ ﺇﻓﻼﺘـﻪ‬
‫ﻓﻭﻕ ﺍﻟﻌﻨﺼﺭ ‪.ListBox‬‬

‫‪168‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺭﺴﻡ ﻓﻲ ﺩﻟﻔﻲ ‪:‬‬
‫ﻴﺘﻡ ﺍﻟﺭﺴﻡ ﻓﻲ ﺩﻟﻔﻲ ﻓﻭﻕ ﻋﻨﺼﺭ ﺍﻟﻜﻨﻔﺎ ‪ Canvas‬ﻭﻫﻭ ﺃﺤﺩ ﺨﺼﺎﺌﺹ ﺍﻟﻌﻨﺼﺭ ‪ TForm‬ﻭﺍﻟﻌﻨﺼﺭ ‪ Timage‬ﻭﻴﻤﻜﻨﻨﺎ‬
‫ﺭﺴﻡ ﻋﺩﺩ ﻤﻥ ﺍﻷﺸﻜﺎل ﺍﻟﻬﻨﺩﺴﻴﺔ ﺒﻭﺍﺴﻁﺔ ﺘﻭﺍﺒﻊ ﻤﻌﺭﻓﺔ ﻓﻭﻕ ﻋﻨﺼﺭ ﺍﻟﻜﻨﻔﺎ ‪.‬‬
‫ﺭﺴﻡ ﻤﺴﺘﻘﻴﻡ ‪:‬‬
‫ﻟﺭﺴﻡ ﻤﺴﺘﻘﻴﻡ ﻴﺠﺏ ﺘﺤﺩﻴﺩ ﻨﻘﻁﺔ ﺍﻟﺒﺩﺍﻴﺔ ﻭﻨﻘﻁﺔ ﻟﻠﻨﻬﺎﻴﺔ‬
‫ﺃ ـ ﻴﺘﻡ ﺘﺤﺩﻴﺩ ﻨﻘﻁﺔ ﺍﻟﺒﺩﺍﻴﺔ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﺘﻌﻠﻴﻤﺔ )‪ Form1.Canvas.MoveTo(x,y‬ﺤﻴﺙ ‪ x,y‬ﻫﻤﺎ ﺇﺤﺩﺍﺜﻴﺎﺕ ﻨﻘﻁﺔ‬
‫ﺍﻟﺒﺩﺍﻴﺔ‪ ،‬ﺇﺫﺍ ﺃﺭﺩﺕ ﻤﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺃﻥ ﻴﺤﺩﺩ ﻨﻘﻁﺔ ﺍﻟﺒﺩﺍﻴﺔ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺍﻟﻔﺄﺭﺓ ﻓﻭﻕ ﺍﻟﻨﻤﻭﺫﺝ ﻀـﻊ ﻫـﺫﻩ‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnMouseDown‬ﻟﻠﻨﻤﻭﺫﺝ ‪. Form1‬‬
‫ﺏ ـ ﻴﺘﻡ ﺘﺤﺩﻴﺩ ﻨﻘﻁﺔ ﺍﻟﻨﻬﺎﻴﺔ ﻟﻠﻤﺴﺘﻘﻴﻡ ﻀﻤﻥ ﺘﻌﻠﻴﻤﺔ ﺭﺴﻡ ﻤﺴﺘﻘﻴﻡ ﻭﻫﻲ )‪ Form1.Canvas.LineTo(x,y‬ﺤﻴﺙ ‪x,y‬‬
‫ﻫﻤﺎ ﺇﺤﺩﺍﺜﻴﺎﺕ ﻨﻘﻁﺔ ﺍﻟﻨﻬﺎﻴﺔ ﻟﻤﺴﺘﻘﻴﻡ ‪ ،‬ﻭﺇﺫﺍ ﺃﺭﺩﺕ ﺃﻥ ﻴﺘﻡ ﺭﺴﻡ ﺍﻟﻤﺴﺘﻘﻴﻡ ﻓﻲ ﺍﻟﻤﻜﺎﻥ ﺍﻟﺫﻱ ﻴﺤﺭﺭ ﻓﻴـﻪ ﺍﻟﻤـﺴﺘﺨﺩﻡ ﺯﺭ‬
‫ﺍﻟﻔﺄﺭﺓ ﻀﻊ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnMouseUp‬ﻟﻠﻨﻤﻭﺫﺝ ‪. Form1‬‬
‫ﻨﻔﺫ ﺍﻵﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﻤﺅﺸﺭ ﺍﻟﻔﺄﺭﺓ ﻭﺃﺒﻘﻪ ﻤﻀﻐﻭﻁﹰﺎ ﺜﻡ ﺤﺭﻙ ﺍﻟﻔﺄﺭﺓ ﺇﻟﻰ ﻤﻜﺎﻥ ﺠﺩﻴﺩ ﻭﺤـﺭﺭ ﺯﺭ ﺍﻟﻔـﺄﺭﺓ ‪،‬‬
‫ﺴﻴﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺨﻁ ﻤﺴﺘﻘﻴﻡ ﺒﻴﻥ ﻨﻘﻁﺘﻲ ﺍﻟﺒﺩﺍﻴﺔ ﻭﺍﻟﻨﻬﺎﻴﺔ ‪.‬‬
‫ـ ﻹﻅﻬﺎﺭ ﺍﻟﺨﻁ ﺃﺜﻨﺎﺀ ﺘﺤﺭﻴﻙ ﺍﻟﻔﺄﺭﺓ ﻀﻊ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻀﻤﻥ ﺍﻟﺤﺩﺙ ‪ OnMouseMove‬ﻭﺍﻟـﺫﻱ ﻴﺤـﺩﺙ ﺃﺜﻨـﺎﺀ‬
‫ﺘﺤﺭﻴﻙ ﺍﻟﻔﺄﺭﺓ ‪:‬‬
‫;)‪Form1.Canvas.LineTo(x,y‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺎﻟﺭﺴﻡ ﻓﻭﻕ ﺍﻟﻨﺎﻓﺫﺓ ﻋﻨﺩ ﺘﺤﺭﻴﻙ ﺍﻟﻔﺄﺭﺓ ‪ ،‬ﻭﺇﺫﺍ ﺃﺭﺩﻨﺎ ﺍﻟﺭﺴﻡ ﻓﻘﻁ ﻋﻨﺩﻤﺎ ﻴﻜﻭﻥ ﺯﺭ ﺍﻟﻔـﺄﺭﺓ ﻤـﻀﻐﻭﻁﹰﺎ‬
‫ﻴﺠﺏ ﺇﻀﺎﻓﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬
‫ﺃ ـ ﻋﺩل ﺍﻟﻘﺴﻡ ‪ Var‬ﻟﻠﻭﺤﺩﺓ ﺒﺤﻴﺙ ﻴﺼﺒﺢ ﺒﺎﻟﺸﻜل ‪:‬‬
‫‪var‬‬
‫;‪Form1: TForm1; Drawing : boolean = false‬‬
‫ﺏ ـ ﻋﺩل ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnMouseDown‬ﻟﺘﺼﺒﺢ ﺒﺎﻟﺸﻜل ‪:‬‬
‫;‪Drawing := True‬‬
‫;)‪Canvas.MoveTo(x,y‬‬
‫ﺝ ـ ﻋﺩل ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnMouseMove‬ﻟﺘﺼﺒﺢ ﺒﺎﻟﺸﻜل ‪:‬‬
‫;)‪if Drawing Then Form1.Canvas.LineTo(x,y‬‬
‫ﺩ ـ ﻋﺩل ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnMouseUp‬ﻟﺘﺼﺒﺢ ﺒﺎﻟﺸﻜل ‪:‬‬
‫;‪Drawing := false‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺍﻟﻔﺄﺭﺓ ﻭﺍﺭﺴﻡ ﺍﻟﺨﻁ ‪.‬‬
‫ﺇﻥ ﻤﺸﻜﻠﺔ ﺍﻟﺤﺩﺙ ‪ OnMouseMove‬ﻫﻭ ﺃﻨﻪ ﻴﺭﺴﻡ ﺨﻁ ﻤﻨﺤﻨﻲ ﻭﻻ ﻴﺭﺴﻡ ﻤﺴﺘﻘﻴﻡ ﺒﻴﻥ ﻨﻘﻁﺘﻴﻥ ﻴﺤـﺩﺩﻫﻤﺎ ﺍﻟﻤـﺴﺘﺨﺩﻡ‬
‫ﻭﻟﺫﻟﻙ ﻨﻀﻴﻑ ﻤﺘﺤﻭل ﺠﺩﻴﺩ ﻋﻠﻰ ﺍﻟﻭﺤﺩﺓ ﻴﻘﻭﻡ ﺒﺤﻔﻅ ﺍﻟﻨﻘﻁﺔ ﺍﻟﺘﻲ ﻀﻐﻁ ﻋﻠﻴﻬﺎ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻭﻫﺫﺍ ﺍﻟﻤﺘﺤـﻭل ﻤـﻥ ﺍﻟﻨـﻭﻉ‬
‫‪ TPoint‬ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻋﺒﺎﺭﺓ ﻋﻥ ﺴﺠل ﻴﺤﻭﻱ ﻤﺘﺤﻭﻟﻴﻥ ‪ X,y‬ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Integer‬ﻴﺨﺯﻥ ﻓﻴﻬﻤﺎ ﺇﺤﺩﺍﺜﻴﺎﺕ ﺍﻟﻨﻘﻁﺔ ‪.‬‬
‫ﺃ ـ ﺃﻀﻑ ﺘﻌﺭﻴﻑ ﺍﻟﻤﺘﺤﻭل ﻋﻠﻰ ﺍﻟﻘﺴﻡ ‪ private‬ﻜﻤﺎ ﻴﻠﻲ ‪:‬‬
‫;‪Origin : TPoint‬‬
‫‪169‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺏ ـ ﻋﺩل ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnMouseDown‬ﻟﺘﺼﺒﺢ ﺒﺎﻟﺸﻜل ‪:‬‬
‫;)‪Drawing := True; Canvas.MoveTo(x,y‬‬
‫;)‪Origin := point(x,y‬‬

‫ﺝ ـ ﻋﺩل ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnMouseMove‬ﻟﺘﺼﺒﺢ ﺒﺎﻟﺸﻜل ‪:‬‬

‫‪If Drawing then Begin‬‬
‫;)‪Canvas.MoveTo(origin.X,origin.y) ; Form1.Canvas.LineTo(x,y‬‬
‫;‪end‬‬
‫ﺩ ـ ﻋﺩل ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnMouseUp‬ﻟﺘﺼﺒﺢ ﺒﺎﻟﺸﻜل ‪:‬‬
‫;)‪Canvas.MoveTo(origin.X,origin.Y‬‬
‫;)‪canvas.LineTo(x,y‬‬
‫;‪Drawing := false‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺍﻟﻔﺄﺭﺓ ﻭﺤﺭﻜﻬﺎ ﺴﻴﺘﻡ ﺭﺴﻡ ﺍﻟﻌﺩﻴﺩ ﻤﻥ ﺍﻟﻤﺴﺘﻘﻴﻤﺎﺕ ﻤﻥ ﻨﻘﻁﺔ ﺍﻟﺘﻲ ﻀﻐﻁﺕ ﻋﻠﻴﻬﺎ ﺇﻟـﻰ‬
‫ﺍﻟﻨﻘﻁﺔ ﺍﻟﺘﻲ ﻴﺘﺤﺭﻙ ﻤﺅﺸﺭ ﺍﻟﻔﺄﺭﺓ ﻓﻭﻗﻬﺎ ‪ ،‬ﻭﻟﻜﻨﻨﺎ ﻨﺭﻴﺩ ﻓﻘﻁ ﺃﻥ ﻴﻅﻬﺭ ﻓﻲ ﺍﻟﻨﻬﺎﻴـﺔ ﺍﻟﻤـﺴﺘﻘﻴﻡ ﺍﻟـﺫﻱ ﻴﺭﺴـﻤﻪ ﺍﻟﺤـﺩﺙ‬
‫‪، OnMouseUp‬ﻟﺫﻟﻙ ﺴﻨﻘﻭﻡ ﺒﻤﺴﺢ ﺍﻟﻤﺴﺘﻘﻴﻤﺎﺕ ﺍﻟﺘﻲ ﺘﺭﺴﻡ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ ، OnMouseMove‬ﻟﻜﻥ ﻻﺘﻭﺠـﺩ ﺘﻌﻠﻴﻤـﺔ‬
‫ﻟﺤﺫﻑ ﻤﺴﺘﻘﻴﻡ ﻤﻌﻴﻥ ﻟﺫﻟﻙ ﺴﻨﻘﻭﻡ ﺒﺭﺴﻡ ﺨﻁ ﺠﺩﻴﺩ ﻓﻭﻕ ﺍﻟﺨﻁ ﺍﻟﺫﻱ ﻴﺭﺴﻡ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnMouseMove‬ﻭﻟﻜﻥ ﺒﻠـﻭﻥ‬
‫ﺍﻷﺭﻀﻴﺔ ﻭﺒﻬﺫﺍ ﻴﺒﺩﻭﺍ ﻋﻤﻠﻴﹰﺎ ﺃﻥ ﺍﻟﺨﻁ ﻗﺩ ﺘﻡ ﻤﺴﺤﻪ‪ ،‬ﻭﻟﺘﺤﻘﻴﻕ ﺫﻟﻙ ﻋﺩل ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻓﻲ ﺍﻟﻭﺤﺩﺓ ﻟﺘﻐﺩﻭ ﺒﺎﻟﺸﻜل ‪:‬‬
‫ﺃ ـ ﺃﻀﻑ ﻋﻠﻰ ﺍﻟﻘﺴﻡ ‪ Private‬ﺍﻟﻤﺘﺤﻭل ‪ Movept‬ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Tpoint‬ﺍﻟﺫﻱ ﺴﻨﺨﺯﻥ ﻓﻴﻪ ﻗﻴﻤﺔ ﺁﺨﺭ ﻨﻘﻁﺔ ﻤﺭ ﻋﻠﻴﻬﺎ‬
‫ﺍﻟﺤﺩﺙ ‪ OnMoseMove‬ﻭﺒﺎﻟﺘﺎﻟﻲ ﻫﻲ ﻨﻔﺴﻬﺎ ﺇﺤﺩﺍﺜﻴﺎﺕ ﻨﻬﺎﻴﺔ ﺍﻟﺨﻁ ﺍﻟﺫﻱ ﺭﺴﻡ ﺒﺎﺴﺘﺨﺩﺍﻡ ﻫﺫﺍ ﺍﻟﺤﺩﺙ ‪.‬‬
‫;‪Origin,Movept :Tpoint‬‬
‫ﺏ ـ ﺃﻀﻑ ﺍﻟﺘﻌﻠﻴﻤﺔ ﻓﻲ ﻨﻬﺎﻴﺔ ﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺤﺩﺙ ﺍﻟﺤﺩﺙ ‪: OnMouseDown‬‬
‫;)‪Movept := Point(x,y‬‬
‫ﺝ ـ ﻋﺩل ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnMouseMove‬ﻟﺘﺼﺒﺢ ﺒﺎﻟﺸﻜل ‪:‬‬
‫‪If Drawing then begin‬‬
‫;‪canvas.Pen.Mode := pmNotXor‬‬
‫; )‪canvas.MoveTo(origin.X,origin.y‬‬
‫;)‪Canvas.LineTo(Movept.x,movept.y‬‬ ‫‪1‬‬
‫; )‪Canvas.moveto(origin.X,origin.y‬‬
‫;)‪Canvas.LineTo(x,y‬‬ ‫‪2‬‬
‫;‪end‬‬
‫;)‪movept := point(x,y‬‬
‫;‪Canvas.Pen.Mode := pmCopy‬‬
‫;‪end‬‬
‫ﻋﻨﺩﻤﺎ ﻏﻴﺭﻨﺎ ﺍﻟﺨﺎﺼﺔ ‪ Mode‬ﻟﻠﻘﻠﻡ ‪ pen‬ﻭﺃﻋﻁﻴﻨﺎﻫﺎ ﺍﻟﻘﻴﻤﺔ ‪ pmNotXor‬ﻓﺈﻨﻨﺎ ﺒﺫﻟﻙ ﻁﻠﺒﻨﺎ ﺩﻤﺞ ﺍﻟﺨﻁ ﻤﻊ ﻋﻨﺼﻭﺭﺍﺕ‬
‫ﺍﻷﺭﻀﻴﺔ ﻭﺒﺫﻟﻙ ﺴﻴﺭﺴﻡ ﺍﻟﺨﻁ ﺒﻨﻔﺱ ﻟﻭﻥ ﺍﻷﺭﻀﻴﺔ ﻭﺴﻴﺒﺩﻭ ﻭﻜﺄﻨﻪ ﻤﻤﺴﻭﺡ ﻭﻗﺩ ﺃﻋﺩﻨﺎ ﺍﻟﻘﻴﻤﺔ ‪ PmCopy‬ﻓـﻲ ﺁﺨـﺭ‬
‫ﺘﻌﻠﻴﻤﺔ ﻟﻜﻲ ﻴﻜﻭﻥ ﺍﻟﻘﻠﻡ ﺠﺎﻫﺯ ﻟﺭﺴﻡ ﺍﻟﺨﻁ ﺍﻟﻨﻬﺎﺌﻲ ﻋﻨﺩﻤﺎ ﻨﺤﺭﺭ ﺯﺭ ﺍﻟﻔﺄﺭﺓ ‪.‬‬

‫‪170‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ـ ﺍﻟﺘﻌﻠﻴﻤﺘﺎﻥ ‪ 1‬ﺘﻘﻭﻤﺎﻥ ﺒﺭﺴﻡ ﺨﻁ ﺒﻴﻥ ﺍﻟﻨﻘﻁﺔ ﺍﻟﺘﻲ ﺤﺩﺩﻫﺎ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻭﺒﻴﻥ ﺁﺨﺭ ﻨﻘﻁﺔ ﻤﺭﺕ ﻓﻭﻗﻬﺎ ﺍﻟﻔـﺄﺭﺓ ) ﺍﻟﻨﻘﻁـﺔ‬
‫ﺍﻟﻤﺨﺯﻨﺔ ﻓﻲ ﺍﻟﻤﺘﺤﻭل ‪ ( Movept‬ﻭﺴﻴﻜﻭﻥ ﻟﻭﻥ ﺍﻟﺨﻁ ﺒﻠﻭﻥ ﺍﻷﺭﻀﻴﺔ ) ﺒﻤﺎ ﺃﻨﻨﺎ ﻨﺭﺴﻡ ﺨﻁ ﺠﺩﻴﺩ ﻓﻭﻕ ﺨﻁ ﺴﺎﺒﻕ ﻟﻭﻨﻪ‬
‫ﺃﺴﻭﺩ ﻓﺈﻥ ﺍﻟﺨﺎﺼﺔ ‪ mode‬ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ ‪ pmNotXor‬ﺴﺘﻘﻭﻡ ﺒﻁﺭﺡ ﺍﻟﻠﻭﻨﻴﻥ ﻤﻥ ﺒﻌﻀﻬﻤﺎ ﻭﺇﻋﺎﺩﺓ ﻟﻭﻥ ﺍﻟﺨﻠﻔﻴﺔ (‬
‫ـ ﺍﻟﺘﻌﻠﻴﻤﺘﺎﻥ ‪ 2‬ﺘﻘﻭﻤﺎﻥ ﺒﺭﺴﻡ ﺨﻁ ﺠﺩﻴﺩ ﺒﻴﻥ ﺍﻟﻨﻘﻁﺔ ﺍﻟﺘﻲ ﻀﻐﻁ ﻋﻠﻴﻬﺎ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻭﺍﻟﻨﻘﻁﺔ ﺍﻟﺘﻲ ﺘﺘﺤﺭﻙ ﺍﻟﻔـﺄﺭﺓ ﻓﻭﻗﻬـﺎ‬
‫ﻭﺴﻴﻅﻬﺭ ﺍﻟﺨﻁ ﺒﺎﻟﻠﻭﻥ ﺍﻷﺴﻭﺩ‪.‬‬
‫ﺇﺫﺍ ﺃﺭﺩﺕ ﺃﻥ ﺘﺘﺄﻗﻠﻡ ﻤﻊ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺴﺎﺒﻘﺔ ) ﺃﻥ ﺘﻔﻬﻤﻬﺎ ﺒﺸﻜل ﺠﻴﺩ ( ﻋﺩل ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻓﻲ ﺍﻟﺤـﺩﺙ ‪OnMouseMove‬‬
‫ﻟﺘﺼﺒﺢ ﺒﺎﻟﺸﻜل ‪:‬‬

‫‪If Drawing then begin‬‬

‫; ‪canvas.Pen.Color := form1.Color‬‬
‫; )‪canvas.MoveTo(origin.X,origin.y‬‬
‫;)‪Canvas.LineTo(Movept.x,movept.y‬‬
‫;‪canvas.Pen.Color := clblack‬‬
‫; )‪canvas.moveto(origin.X,origin.y‬‬
‫;)‪Form1.Canvas.LineTo(x,y‬‬
‫;‪end‬‬
‫;)‪movept := point(x,y‬‬
‫ﻟﻜﻥ ﻋﻠﻴﻙ ﺃﻥ ﺘﻌﻴﺩﻫﺎ ﻋﻠﻰ ﺸﻜﻠﻬﺎ ﺍﻟﺴﺎﺒﻕ ﻟﻜﻲ ﻨﻜﻤل ﺒﺭﻨﺎﻤﺠﻨﺎ ﺒﺎﻟﻁﺭﻴﻘﺔ ﺍﻟﺼﺤﻴﺤﺔ ‪...‬‬
‫ﺤﺘﻰ ﺍﻵﻥ ﺍﺴﺘﻁﻌﻨﺎ ﺃﻥ ﻨﺭﺴﻡ ﻤﺴﺘﻘﻴﻡ ﻭﻟﺭﺴﻡ ﺒﻘﻴﺔ ﺍﻷﺸﻜﺎل ﺍﻟﻬﻨﺩﺴﻴﺔ ﺴﻨﻘﻭﻡ ﺒﺈﻀﺎﻓﺔ ﺸﺭﻴﻁ ﺃﺩﻭﺍﺕ ﻟﻠﺒﺭﻨﺎﻤﺞ ﻟﻠﺘﻤﻜﻥ ﻤـﻥ‬
‫ﺍﺨﺘﻴﺎﺭ ﺍﻟﺸﻜل ﺍﻟﺫﻱ ﻨﺭﻴﺩ ﺭﺴﻤﻪ ‪:‬‬
‫ﺇﻀﺎﻓﺔ ﺸﺭﻴﻁ ﺃﺩﻭﺍﺕ ﻟﻠﺸﻜل ‪:‬‬
‫ﺃﻀﻑ ﺍﻟﻌﻨﺼﺭ ‪ Toolbar‬ﺇﻟﻰ ﺍﻟﺸﻜل ﻭﺍﻀﻐﻁ ﻋﻠﻴﻪ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﻤﻴﻨﻲ ﻭﺍﺨﺘﺭ ‪ New Button‬ﻤﻥ ﺍﻟﻘﺎﺌﻤـﺔ ‪ ،‬ﻜـﺭﺭ‬
‫ﺍﻟﻌﻤﻠﻴﺔ ﻹﻀﺎﻓﺔ ﺃﺭﺒﻊ ﺃﺯﺭﺍﺭ‪.‬‬
‫ﻴﺠﺏ ﺇﻋﻁﺎﺀ ﻜل ﺯﺭ ﻤﻥ ﺍﻷﺯﺭﺍﺭ ﺍﻟﺴﺎﺒﻘﺔ ﺼﻭﺭ ﻤﺎ ﺘﺩل ﻋﻠﻰ ﺍﻟﻌﻤل ﺍﻟﺫﻱ ﺴﻴﻘﻭﻡ ﺒﻪ ﺍﻟﺯﺭ‪ ،‬ﻓﺈﺫﺍ ﻜﻨﺕ ﺘﻤﻠـﻙ ﺃﻴﻘﻭﻨـﺎﺕ‬
‫ﺠﺎﻫﺯﺓ ﻓﺒﺈﻤﻜﺎﻨﻙ ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﻭﺇﻻ ﻓﻌﻠﻴﻙ ﺃﻥ ﺘﺭﺴﻡ ﻫﺫﻩ ﺍﻷﻴﻘﻭﻨﺎﺕ ﺒﻨﻔﺴﻙ ‪ ،‬ﻗﺒل ﺍﻟﺒﺩﺀ ﺒﺈﻨـﺸﺎﺀ ﺍﻹﻴﻘﻭﻨـﺎﺕ ﻗـﻡ ﺒﺤﻔـﻅ‬
‫ﺍﻟﻤﺸﺭﻭﻉ ) ﺍﺤﻔﻅ ﺍﻟﻭﺤﺩﺓ ﺒﺎﺴﻡ ‪ Gragh‬ﻭﺍﺤﻔﻅ ﺍﻟﻤﺸﺭﻭﻉ ﺒﺎﺴﻡ ‪. ( Painting‬‬
‫ﺇﻨﺸﺎﺀ ﺃﻴﻘﻭﻨﺎﺕ ﺠﺩﻴﺩﺓ ‪:‬‬
‫ﺍﺨﺘﺭ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪ Tools‬ﺍﻷﻤـﺭ ‪ Image Editor‬ﺴـﻴﻅﻬﺭ‬
‫ﻋﻨﺩﻫﺎ ﺒﺭﻨﺎﻤﺞ ﺘﺤﺭﻴﺭ ﺍﻟﺼﻭﺭ ﻜﻤﺎ ﻓﻲ ﺍﻟﺸﻜل ‪:‬‬
‫ﺍﺨﺘﺭ ‪File ÆNew Æ icon File‬‬
‫ﺴﺘﻅﻬﺭ ﻟﻙ ﻨﺎﻓﺫﺓ ﺍﺨﺘﺭ ﻤﻨﻬﺎ ‪ Small Icon‬ﻭ ‪16 Color‬‬
‫ﺴﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺍﻟﻨﺎﻓﺫﺓ ‪ Icon1.ico‬ﻜﻤﺎ ﻓﻲ ﺍﻟﺸﻜل ﺍﻟﻤﺠﺎﻭﺭ‬
‫ﻓﻴﻬﺎ ﻤﺭﺒﻊ ﺍﻷﺨﻀﺭ ﻭﻫﻭ ﻴﺩل ﻋﻠﻰ ﺍﻟﻤـﺴﺎﺤﺔ ﺍﻟـﺸﻔﺎﻓﺔ ﻓـﻲ‬
‫ﺍﻷﻴﻘﻭﻨﺔ‬

‫‪171‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﺴﺘﺨﺩﻡ ﺃﺩﺍﺓ ﺭﺴﻡ ﺨﻁ ﻟﺭﺴﻡ ﺨﻁ ﺒﻴﻥ ﺍﻟﺯﺍﻭﻴﺔ ﺍﻟﻴﺴﺭﻯ ﺍﻟﻌﻠﻭﻴﺔ ﻭﺍﻟﺯﺍﻭﻴﺔ ﺍﻟﻴﻤﻨﻰ ﺍﻟﺴﻔﻠﻴﺔ ﻭﺒﻬﺫﺍ ﻨﻜﻭﻥ ﻗﺩ ﺭﺴﻤﻨﺎ ﺃﻴﻘﻭﻨـﺔ‬
‫ﻟﺯﺭ ﺭﺴﻡ ﺨﻁ ﺍﺤﻔﻅ ﺍﻟﻤﻠﻑ ﺒﺎﺴﻡ ‪ Line.ico‬ﻭﺃﻏﻠﻘﻪ ‪ ،‬ﺜﻡ ﺃﻨﺸﺄ ﺍﻷﻴﻘﻭﻨﺎﺕ ﺍﻷﺨﺭﻯ ﺠﺩﻴﺩﺓ ﺒﻨﻔﺱ ﺍﻟﻁﺭﻴﻘﺔ ﺒﺤﻴﺙ ﺘﻅﻬـﺭ‬
‫ﺍﻷﺸﻜﺎل ﺍﻟﺘﺎﻟﻴﺔ ﻓﻴﻬﺎ ‪:‬‬

‫ﻻﺘﻨﺱ ﺃﻥ ﺘﺤﻔﻅ ﻜل ﺃﻴﻘﻭﻨﺔ ﺒﺎﺴﻡ ﻤﻨﺎﺴﺏ ‪.‬‬

‫ﻨﻌﻭﺩ ﺍﻵﻥ ﺇﻟﻰ ﻤﺸﺭﻭﻋﻨﺎ ‪:‬‬
‫ﺃﻀﻑ ﺍﻟﻌﻨﺼﺭ ‪ ImageList‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪ Win32‬ﻭﺍﻀﻐﻁ ﻋﻠﻴﻪ ﻤﺭﺘﻴﻥ ﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﻨﺎﻓﺫﺓ ﺃﺨﺘﺭ ﻤﻨﻬﺎ ‪ Add‬ﻭﺃﻀﻑ‬
‫ﺍﻷﻴﻘﻭﻨﺎﺕ ﺍﻷﺭﺒﻌﺔ ﺍﻟﺘﻲ ﺭﺴﻤﺘﻬﺎ ‪.‬‬
‫ﺍﺨﺘﺭ ﺍﻟﻌﻨﺼﺭ ‪ Toolbar1‬ﻭﺍﻋﻁ ﺍﻟﻘﻴﻤﺔ ‪ Imagelist1‬ﻟﻠﺨﺎﺼﺔ ‪ Images‬ﺜﻡ ﻋﺩل ﺍﻟﺨﺎﺼﺔ ‪ ImageIndex‬ﻟﻜـل ﺯﺭ‬

‫ﻋﻠﻰ ﻟﻜﻲ ﺘﻅﻬﺭ ﺍﻷﻴﻘﻭﻨﺎﺕ ﺒﺎﻟﺘﺭﺘﻴﺏ ﺍﻟﺘﺎﻟﻲ ‪:‬‬

‫ﺤﺩﺩ ﺍﻟﻌﻨﺼﺭ ‪ ToolBars‬ﻭﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ Flat‬ﺍﻟﻘﻴﻤﺔ ‪. True‬‬
‫ﺤﺩﺩ ﺍﻷﺯﺭﺍﺭ ﺍﻷﺭﺒﻌﺔ ﺴﻭﻴﺔ ﻭﺃﻋﻁﻬﺎ ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ Grouped‬ﺍﻟﻘﻴﻤﺔ ‪ ،True‬ﻟﺘﺠﻤﻴﻊ ﻫﺫﻩ ﺍﻷﺯﺭﺍﺭ ﻤﻊ ﺒﻌﻀﻬﺎ‬
‫ﻭﺃﻋﻁﻬﺎ ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ Style‬ﺍﻟﻘﻴﻤﺔ ‪ ، tbsCheck‬ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺴﺘﺠﻌل ﺃﺤﺩ ﺍﻷﺯﺭﺍﺭ ﻤﻀﻐﻭﻁﹰﺎ ﻓﻘﻁ ﻭﻻﻴﻤﻜﻥ ﺃﻥ ﻨﺒﻘﻲ‬
‫ﺯﺭﻴﻥ ﻤﻀﻐﻭﻁﻴﻥ ﺒﻨﻔﺱ ﺍﻟﻭﻗﺕ ‪.‬‬
‫ﻋﻨﺩﻤﺎ ﻨﻀﻐﻁ ﻋﻠﻰ ﺃﺤﺩ ﺍﻷﺯﺭﺍﺭ ﻓﺈﻨﻨﺎ ﺴﻨﺤﺩﺩ ﺍﻟﺸﻜل ﺍﻟﺫﻱ ﺴﺘﺭﺴﻤﻪ ﺍﻟﻔﺄﺭﺓ ﺃﺜﻨﺎﺀ ﺘﺤﺭﻴﻜﻬﺎ ﻟﺫﻟﻙ ﺴﻨﻌﺭﻑ ﻤﺘﺤﻭل ﻴﺄﺨـﺫ‬
‫ﻗﻴﻤﺔ ﻤﺨﺘﻠﻔﺔ ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﻜل ﺯﺭ ﻤﻥ ﺍﻷﺯﺭﺍﺭ ﻭﺃﻓﻀل ﻁﺭﻴﻘﺔ ﻫﻲ ﺘﻌﺭﻴﻑ ﻨﻭﻉ ﻤﻌﻁﻴﺎﺕ ﺘﻌﺩﺍﺩﻱ ‪ ،‬ﻫـﺫﺍ ﺍﻟﻨـﻭﻉ‬
‫ﺴﻴﺭﺒﻁ ﺒﻴﻥ ﺴﻠﺴﻠﺔ ﺭﻤﺯﻴﺔ ﻭﺒﻴﻥ ﺭﻗﻡ ﺩﺍﺨﻠﻲ ﻭﻴﺴﺘﺒﺩﻟﻪ ﺘﻠﻘﺎﺌﻴﹰﺎ ‪،‬ﻟﺫﻟﻙ ﺼﺭﺡ ﻋﻥ ﻨﻭﻉ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻟﺘﺎﻟﻲ ﻓﻲ ﺍﻟﻘﺴﻡ ‪Type‬‬
‫ﻤﻥ ﺍﻟﻭﺤﺩﺓ ‪: Gragh‬‬
‫‪type‬‬
‫;)‪TDrawingTool = (dtLine, dtRectangle, dtEllipse, dtRoundRect‬‬
‫)‪TForm1 = class(TForm‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﺘﻌﺭﻴﻑ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻴﻜﺎﻓﺊ ﺍﻟﺘﻌﺭﻴﻑ ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫‪const‬‬
‫;‪dtLine = 0‬‬
‫;‪dtRectangle = 1‬‬
‫;‪dtEllipse = 2‬‬
‫;‪dtRoundRect = 3‬‬
‫ﺒﻤﺎ ﺃﻨﻨﺎ ﻋﺭﻓﻨﺎ ﻨﻭﻉ ﻓﻌﻠﻴﻨﺎ ﺘﻌﺭﻴﻑ ﻤﺘﺤﻭل ﻤﻥ ﻫﺫﺍ ﺍﻟﻨﻭﻉ‪ ،‬ﻟﺫﻟﻙ ﺃﻀﻑ ﺘﻌﺭﻴﻑ ﺍﻟﻤﺘﺤﻭل ﺍﻟﺘﺎﻟﻲ ﻟﻠﻘﺴﻡ ‪: Private‬‬
‫;‪DrawingTool: TDrawingTool‬‬
‫ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻷﻭل ‪:‬‬
‫;‪DrawingTool := dtLine‬‬
‫ﻭﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺜﺎﻨﻲ ‪:‬‬
‫;‪DrawingTool := dtRectangle‬‬
‫ﻭﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺜﺎﻟﺙ ‪:‬‬
‫‪172‬‬
http://www.alshater.net ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
DrawingTool := dtEllipse;
: ‫ﻭﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺭﺍﺒﻊ‬
DrawingTool := dtRoundRect;
. ‫ ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﻜل ﺯﺭ ﻤﻥ ﺍﻷﺯﺭﺍﺭ‬DrawingTool ‫ﻭﺒﻬﺫﺍ ﻨﻜﻭﻥ ﻗﺩ ﺃﻋﻁﻴﻨﺎ ﻗﻴﻤﺔ ﻤﺤﺩﺩﺓ ﻟﻠﻤﺘﺤﻭل‬
OnMouseUp ‫ ﻋﻨﺩ ﺭﺴﻡ ﺍﻷﺸﻜﺎل ﻟﺫﻟﻙ ﻨﻌﺩل ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻓﻲ ﺍﻟﺤـﺩﺙ‬DrawingTool ‫ﺍﻵﻥ ﻋﻠﻴﻨﺎ ﺃﻥ ﻨﻔﺤﺹ ﻗﻴﻤﺔ‬
‫ﻟﻠﻨﻤﻭﺫﺝ ﻜﻤﺎ ﻴﻠﻲ‬
case DrawingTool of
dtLine:
begin
Canvas.MoveTo(Origin.X, Origin.Y);
Canvas.LineTo(X, Y)
end;
dtRectangle: Canvas.Rectangle(Origin.X, Origin.Y, X, Y);
dtEllipse: Canvas.Ellipse(Origin.X, Origin.Y, X, Y);
dtRoundRect: Canvas.RoundRect(Origin.X, Origin.Y, X, Y,
(Origin.X - X) div 2, (Origin.Y - Y) div 2);
end;
Drawing := False;
End;
‫ ﻟﺘـﺼﺒﺢ‬OnMuseMove ‫ﻭﻟﻜﻲ ﻨﺴﺘﻁﻴﻊ ﻤﺸﺎﻫﺩﺓ ﺍﻟﺸﻜل ﺍﻟﺫﻱ ﻴﺭﺴﻡ ﺃﺜﻨﺎﺀ ﺘﺤﺭﻴﻙ ﺍﻟﻔﺄﺭﺓ ﻨﻌﺩل ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻓﻲ ﺍﻟﺤﺩﺙ‬
: ‫ﺒﺎﻟﺸﻜل‬
if Drawing then
begin
Canvas.Pen.Mode := pmNotXor;
case DrawingTool of
dtLine: begin
Canvas.MoveTo(Origin.X, Origin.Y);
Canvas.LineTo(MovePt.X, MovePt.Y);
Canvas.MoveTo(Origin.X, Origin.Y);
Canvas.LineTo(X, Y);
end;
dtRectangle: begin
Canvas.Rectangle(Origin.X, Origin.Y, MovePt.X, MovePt.Y);
Canvas.Rectangle(Origin.X, Origin.Y, X, Y);
end;
dtEllipse: begin
Canvas.Ellipse(Origin.X, Origin.Y, X, Y);
Canvas.Ellipse(Origin.X, Origin.Y, X, Y);
end;
dtRoundRect: begin
Canvas.RoundRect(Origin.X, Origin.Y, X, Y,
(Origin.X - X) div 2, (Origin.Y - Y) div 2);
Canvas.RoundRect(Origin.X, Origin.Y, X, Y,
173
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫;)‪(Origin.X - X) div 2, (Origin.Y - Y) div 2‬‬
‫;‪end‬‬
‫;‪end‬‬
‫;‪end‬‬
‫;)‪MovePt := Point(X, Y‬‬
‫;‪Canvas.Pen.Mode := pmCopy‬‬
‫;‪end‬‬
‫ﺸﺭﺡ ﺒﻌﺽ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﻭﺍﺭﺩﺓ ﻓﻲ ﺍﻟﺤﺩﺜﻴﻥ ﺍﻟﺴﺎﺒﻘﻴﻥ ‪:‬‬
‫ﺘﻌﻠﻴﻤﺔ ﺭﺴﻡ ﻤﺴﺘﻁﻴل ) ‪: ( Rectangle‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺭﺴﻡ ﻤﺴﺘﻁﻴل ﺒﻤﻌﺭﻓﺔ ﺇﺤﺩﺍﺜﻴﺎﺕ ﻨﻘﻁﺘﻲ ﺍﻟﺒﺩﺍﻴﺔ ﻭﺍﻟﻨﻬﺎﻴﺔ ﻷﺤﺩ ﺃﻗﻁﺎﺭﻩ ‪.‬‬
‫ﺘﻌﻠﻴﻤﺔ ﺭﺴﻡ ﻗﻁﻊ ﻨﺎﻗﺹ )‪: ( Ellipse‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺭﺴﻡ ﻗﻁﻊ ﻨﺎﻗﺹ ﺃﻭ ﺩﺍﺌﺭﺓ ﺒﻤﻌﺭﻓﺔ ‪:‬ﺇﺤﺩﺍﺜﻴﺎﺕ ﻨﻘﻁﺘﻲ ﻗﻁﺭ ﺍﻟﻤﺴﺘﻁﻴل ﺍﻟﺫﻱ ﻴﻤﺱ ﺍﻟﻘﻁـﻊ ﺍﻟﻨـﺎﻗﺹ‬
‫ﺃﻗﻁﺎﺭﻩ ﺍﻷﺭﺒﻌﺔ ﺃﻀﻼﻉ‬
‫ﺘﻌﻠﻴﻤﺔ ﺭﺴﻡ ﻤﺴﺘﻁﻴل ﺫﻭ ﺯﻭﺍﻴﺎ ﻤﺴﺘﺩﻴﺭﺓ ) ‪: ( RoundRect‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺭﺴﻡ ﻤﺴﺘﻁﻴل ﺫﻭ ﺯﻭﺍﻴﺎ ﻤﺴﺘﺩﻴﺭﺓ ﺒﻤﻌﺭﻓﺔ ﻨﻘﻁﻲ ﺍﻟﻘﻁﺭ ﻜﻤﺎ ﻓﻲ ﺭﺴﻡ ﻤﺭﺒﻊ ) ﺍﻟﻭﺴـﻁﺎﺀ ﺍﻷﺭﺒﻌـﺔ‬
‫ﺍﻷﻭﻟﻰ ( ﻭﻤﻌﺭﻓﺔ ﺍﻟﻁﻭل ﺍﻟﺫﻱ ﺴﻴﺄﺨﺫﻩ ﺍﻟﻘﻭﺱ ﻤﻥ ﺍﺭﺘﻔﺎﻉ ﻭﻋﺭﺽ ﺍﻟﻤﺴﺘﻁﻴل ‪.‬‬
‫ﺘﻐﻴﺭ ﺸﻜل ﺍﻟﺨﻁ ‪:‬‬
‫ﻴﻤﻜﻨﻨﺎ ﺍﻟﺘﺤﻜﻡ ﺒﺸﻜل ﺍﻟﺨﻁ‪ ،‬ﺤﻴﺙ ﻴﻤﻜﻥ ﺃﻥ ﻴﻅﻬﺭ ﺒﺸﻜل ﻤﻨﻘﻁ ﺃﻭ ﺨﻁﻭﻁ ﻤﺘﺘﺎﻟﻴﺔ ﺃﻭ ﺨﻁ ﻭﻨﻘﻁـﺔ ‪ ، ...‬ﻜﻤـﺎ ﻴﻤﻜﻨﻨـﺎ‬
‫ﺍﻟﺘﺤﻜﻡ ﺒﻠﻭﻥ ﺍﻟﺨﻁ ﻭﻋﺭﻀﻪ‪.‬‬
‫ﺴﻨﻀﻴﻑ ﺍﻵﻥ ﺸﺭﻴﻁ ﺃﺩﻭﺍﺕ ﺠﺩﻴﺩ ﻟﻠﺘﺤﻜﻡ ﺒﺸﻜل ﺍﻟﺨﻁ‪ ،‬ﻫﺫﺍ ﺍﻟﺸﺭﻴﻁ ﺴﻴﺒﻘﻰ ﻤﺨﻔﻴﹰﺎ ﺤﺘﻰ ﻴﻀﻐﻁ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻠﻰ ﺯﺭ ﻓﻲ‬
‫ﺸﺭﻴﻁ ﺍﻷﺩﻭﺍﺕ ﺍﻟﺴﺎﺒﻕ ﻭﻟﺘﺤﻘﻴﻕ ﺫﻟﻙ ‪:‬‬
‫ﺃ ـ ﺃﻀﻑ ﺸﺭﻴﻁ ﺍﺩﻭﺍﺕ ‪ Toolbar‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪ Win32‬ﻭﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ Visible‬ﺍﻟﻘﻴﻤﺔ ‪. False‬‬
‫ﺏ ـ ﺃﻀﻑ ﺍﻵﻥ ﺴﺘﺔ ﺃﺯﺭﺍﺭ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﻤﻴﻨﻲ ﻭﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪. New Button‬‬
‫ﺝ ـ ﺃﻀﻑ ﻋﻨﺼﺭ ‪ ImageList1‬ﺠﺩﻴﺩ ﻭﺍﺭﺒﻁ ﺍﻟﻌﻨﺼﺭ ‪ Toolbar2‬ﻤﻌﻪ ﻭﺃﻀﻑ ﻤﺠﻤﻭﻋـﺔ ﻤـﻥ ﺍﻷﻴﻘﻭﻨـﺎﺕ ﺃﻭ‬
‫ﺍﻟﺼﻭﺭ ﺇﻟﻰ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ )‬
‫ﺍﺫﻫﺏ ﺇﻟﻰ ﺍﻟﻤﺠﻠﺩ‬
‫‪C:\Program Files\Borland\Delphi6\Demos\Doc\Graphex‬‬
‫ﻭﺍﻀﻑ ﺍﻟﺼﻭﺭ ﺍﻟﺘﺎﻟﻴﺔ ﻤﻨﻪ ﻋﻠﻰ ﺍﻟﺘﺭﺘﻴﺏ ‪:‬‬
‫‪solid.bmp - dashed.bmp - dotted.bmp - dashdot.bmp - dashdot2.bmp - clear.bmp‬‬
‫ﺒﺤﻴﺙ ﻴﺼﺒﺢ ﻓﻲ ﺍﻟﻨﻬﺎﻴﺔ ﺒﺎﻟﺸﻜل ‪:‬‬

‫ﺤﺩﺩ ﺍﻷﺯﺭﺍﺭ ﺍﻟﺴﺘﺔ ﻭﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ Grouped‬ﻟﻬﺎ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻭﺍﻟﺨﺎﺼﺔ ‪ Style‬ﺍﻟﻘﻴﻤﺔ ‪tbsCheck‬‬
‫ﺩ ـ ﺍﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﻤﻴﻨﻲ ﻋﻠﻰ ﺍﻟﻌﻨﺼﺭ ‪ toolbar1‬ﻭﺍﺨﺘﺭ ‪ New Separator‬ﺜﻡ ﺃﻀﻑ ﺯﺭ ﺠﺩﻴـﺩ ﻭﺃﻀـﻑ‬
‫ﺍﻟﺼﻭﺭ ﺍﻟﺘﺎﻟﻴﺔ ﺇﻟﻰ ﺍﻟﻌﻨﺼﺭ ‪ ImageList1‬ﻤﻥ ﺍﻟﻤﺠﻠﺩ ﺍﻟﺴﺎﺒﻕ ‪:‬‬

‫‪174‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪pen.bmp - brush.bmp‬‬
‫ﺃﻋﻁ ﻫﺫﺍ ﺍﻟﺯﺭ ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ Style‬ﺍﻟﻘﻴﻤﺔ ‪tbsCheck‬‬
‫ﻫـ ـ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﻫﺫﺍ ﺍﻟﺯﺭ ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; ‪toolbar2.Visible := not toolbar2.Visible‬‬
‫ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻫﺫﺍ ﺍﻟﺯﺭ ﻓﺴﻴﻅﻬﺭ ﺸﺭﻴﻁ ﺍﻷﺩﻭﺍﺕ ﺍﻟﺜﺎﻨﻲ ﻭﺴﻴﺨﺘﻔﻲ ﺇﺫﺍ ﻜﺎﻥ ﻅﺎﻫﺭﹰﺍ ‪.‬‬
‫ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻷﻭل ﻓﻲ ﺸﺭﻴﻁ ﺍﻷﺩﻭﺍﺕ ﺍﻟﺜﺎﻨﻲ ‪: Toolbar2‬‬
‫;‪canvas.Pen.Style := pssolid‬‬
‫ﻭﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺫﻱ ﻴﻠﻴﻪ ‪:‬‬
‫;‪canvas.Pen.Style := psDash‬‬
‫ﻭﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺫﻱ ﻴﻠﻴﻪ ‪:‬‬
‫;‪canvas.Pen.Style := psdot‬‬
‫ﻭﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺫﻱ ﻴﻠﻴﻪ ‪:‬‬
‫; ‪canvas.Pen.Style := psdashdot‬‬
‫ﻭﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺫﻱ ﻴﻠﻴﻪ ‪:‬‬
‫; ‪canvas.Pen.Style := psdotdot‬‬
‫ﻭﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺫﻱ ﻴﻠﻴﻪ ‪:‬‬
‫; ‪canvas.Pen.Style := psclear‬‬

‫ﺘﻐﻴﺭ ﻟﻭﻥ ﺍﻟﻘﻠﻡ ‪:‬‬

‫ﻴﻤﻜﻥ ﺃﻥ ﻨﺭﺴﻡ ﺒﺄﻟﻭﺍﻥ ﻤﺨﺘﻠﻔﺔ ﺒﺎﺴﺘﺨﺩﺍﻡ ﻋﻨﺼﺭ ﺍﻟﻘﻠﻡ ‪ Tpen‬ﻭﻟﺘﺤﻘﻴﻕ ﺫﻟﻙ ‪:‬‬
‫ﺃ ـ ﺃﻀﻑ ﺍﻟﻌﻨﺼﺭ ‪ ColorDialog‬ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ‪.‬‬
‫ﺏ ـ ﺃﻀﻑ ﺇﻟﻰ ‪ Toolbar2‬ﻓﺎﺼل ) ‪ ( Separator‬ﻭﻤﻥ ﺜﻡ ﺯﺭ ﺠﺩﻴﺩ ﻭﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﻫﺫﺍ ﺍﻟـﺯﺭ ﺃﻜﺘـﺏ‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪if ColorDialog1.Execute then‬‬
‫;‪Canvas.Pen.Color := ColorDialog1.Color‬‬
‫ﺝ ـ ﺃﻋﻁ ﻫﺫﺍ ﺍﻟﺯﺭ ﺃﻴﻘﻭﻨﺔ ﻤﻨﺎﺴﺒﺔ ) ﺍﻷﻴﻘﻭﻨﺔ ‪ colors.bmp‬ﻤﻥ ﺍﻟﻔﻬﺭﺱ ﺍﻟﺴﺎﺒﻕ ( ‪.‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻻﺤﻅ ﺍﻟﻨﺘﺎﺌﺞ ‪.‬‬
‫ﺘﻐﻴﺭ ﻋﺭﺽ ﺍﻟﻘﻠﻡ ‪:‬‬
‫ﻟﻜﻲ ﻴﺘﻤﻜﻥ ﺒﺭﻨﺎﻤﺠﻨﺎ ﺒﺎﻟﺘﺤﻜﻡ ﺒﻌﺭﺽ ﺍﻟﺨﻁ ﺍﻟﻤﺭﺴﻭﻡ ﺃﻀﻑ ﻤﺎ ﻴﻠﻲ ‪:‬‬
‫ﺃ ـ ﻋﻨﺼﺭ ‪ Edit‬ﻀﻌﻪ ﻓﻭﻕ ﺍﻟﻌﻨﺼﺭ ‪. ToolBar2‬‬
‫ﺏ ـ ﻋﻨﺼﺭ ‪ UpDown‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪ Win32‬ﺃﻋﻁﻪ ﻓﻲ ﺍﻟﻘﻴﻤﺔ ‪ Edit1‬ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪: Associate‬‬
‫ﺝ ـ ﺃﻀﻑ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnChange‬ﻟﻠﻌﻨﺼﺭ ‪:Edit1‬‬
‫;) ‪canvas.Pen.Width := strtoint(edit1.Text‬‬
‫ﺘﻐﻴﺭ ﻨﻭﻉ ﺍﻟﻔﺭﺸﺎﺓ ‪:‬‬
‫ﺘﺴﺘﺨﺩﻡ ﺍﻟﻔﺭﺸﺎﺓ ﻓﻲ ﺩﻟﻔﻲ ﻟﺘﺤﺩﻴﺩ ﺍﻟﻨﻤﻁ ﺍﻟﺫﻱ ﺴﺘﻤﺘﻠﺊ ﺒﻪ ﺍﻷﺸﻜﺎل ﻓﻲ ﺩﻟﻔﻲ ‪:‬‬
‫‪175‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺴﻨﻀﻴﻑ ﺍﻵﻥ ﺸﺭﻴﻁ ﺃﺩﻭﺍﺕ ﺠﺩﻴﺩ ﻟﻠﺘﺤﻜﻡ ﺒﺎﻟﻔﺭﺸﺎﺓ ﻋﻠﻰ ﻏﺭﺍﺭ ﺸﺭﻴﻁ ﺍﻷﺩﻭﺍﺕ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻟﻠﺘﺤﻜﻡ ﺒﺎﻟﻘﻠﻡ ﻭﻟﺘﺤﻘﻴﻕ ﺫﻟﻙ ‪:‬‬
‫ﺃ ـ ﺃﻀﻑ ﺸﺭﻴﻁ ﺃﺩﻭﺍﺕ ﺠﺩﻴﺩ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ‪.‬‬
‫ﺏ ـ ﺃﻀﻑ ﺯﺭ ﺠﺩﻴﺩ ﺇﻟﻰ ﺸﺭﻴﻁ ﺍﻷﺩﻭﺍﺕ ‪ Toolbar1‬ﻭﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ Style‬ﻟﻬﺫﺍ ﺍﻟﺯﺭ ﺍﻟﻘﻴﻤﺔ ‪ tbsCheck‬ﻭﺍﻜﺘـﺏ‬
‫ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻴﻪ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; ‪Toolbar3.Visible := Not Toolbar3.Visible‬‬
‫ﺝ ـ ﺃﻀﻑ ﺇﻟﻰ ﺸﺭﻴﻁ ﺍﻷﺩﻭﺍﺕ ﺍﻟﺠﺩﻴﺩ ﺘﺴﻌﺔ ﺃﺯﺭﺍﺭ ‪ ،‬ﺤﺩﺩ ﺍﻷﺯﺭﺍﺭ ﺍﻟﺜﻤﺎﻨﻴﺔ ﺍﻷﻭﻟﻰ ﻤﻨﻬﺎ ﻭﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪Grouped‬‬
‫ﻟﻬﺎ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻭﺍﻟﺨﺎﺼﺔ ‪ Style‬ﺍﻟﻘﻴﻤﺔ ‪ tbsCheck‬ﻭﺃﻋﻁﻬﺎ ﺼﻭﺭ ﻤﻥ ﺍﻟﻤﺠﻠﺩ ﺍﻟﺴﺎﺒﻕ ﺒﺤﻴﺙ ﺘﻅﻬﺭ ﺒﺎﻟﺸﻜل ‪:‬‬

‫ﺃﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻷﻭل ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫;‪canvas.Brush.Style := bssolid‬‬
‫ﻭﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺘﺎﻟﻲ ﺍﻟﻘﻴﻤﺔ ‪:‬‬
‫;‪canvas.Brush.Style := bsclear‬‬
‫ﻭﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺘﺎﻟﻲ ﺍﻟﻘﻴﻤﺔ ‪:‬‬
‫;‪canvas.Brush.Style := bshorizontal‬‬
‫ﻜﺭﺭ ﺍﻟﺘﻌﻠﻴﻤﺔ ﻭﻏﻴﺭ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﺤﻠﻘﺔ ﺒﺎﻟﻤﻨﻬﺞ ‪ Style‬ﻟﻸﺯﺭﺍﺭ ﺍﻟﺒﺎﻗﻴﺔ ﻋﻠﻰ ﺍﻟﺘﻭﺍﻟﻲ ‪:‬‬
‫‪bsVertical – bsFdiagonal – bsbdiaognal – bsColor – bsDiagCross‬‬
‫ﺘﻐﻴﻴﺭ ﻟﻭﻥ ﺍﻟﻔﺭﺸﺎﺓ ‪:‬‬
‫ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺘﺎﺴﻊ ﻓﻲ ﺸﺭﻴﻁ ﺍﻷﺩﻭﺍﺕ ‪: ToolBar3‬‬
‫; ‪If ColorDialog1.Excetue then canvas.Brush.Color := ColorDialog1.Color‬‬

‫ﺇﻀﺎﻓﺔ ﺸﺭﻴﻁ ﺍﻟﺤﺎﻟﺔ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ‪:‬‬

‫ﻴﺴﺘﺨﺩﻡ ﺸﺭﻴﻁ ﺍﻟﺤﺎﻟﺔ ‪ Status bar‬ﻹﻅﻬﺎﺭ ﻤﻌﻠﻭﻤﺎﺕ ﻋﻥ ﺤﺎﻻﺕ ﻤﻌﻴﻨﺔ ﻀﻤﻥ ﺍﻟﺘﻁﺒﻴﻕ‪ ،‬ﺴﻴﻅﻬﺭ ﺒﺭﻨﺎﻤﺠﻨﺎ ﻤﻌﻠﻭﻤـﺎﺕ‬
‫ﻋﻥ ﻤﻭﻗﻊ ﺍﻟﻤﺸﻴﺭﺓ ﺍﻟﺤﺎﻟﻲ ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺍﻟﻨﻘﻁﺔ ﺍﻟﺒﺩﺍﺌﻴﺔ ﺍﻟﺘﻲ ﻀﻐﻁ ﻋﻠﻴﻬﺎ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻭﻟﺘﺤﻘﻴﻕ ﺫﻟﻙ ‪:‬‬
‫ﺃ ـ ﺃﻀﻑ ﺍﻟﻌﻨﺼﺭ ‪ StatusBar‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪. Win32‬‬
‫‪ 2‬ـ ﺇﻀﻐﻁ ﻋﻠﻴﻪ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﻤﻴﻨﻲ ﻭﺍﺨﺘﺭ ‪ Panel Editor‬ﺴﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﻨﺎﻓﺫﺓ ﺘﺤﺭﻴﺭ ﺍﻟﻠﻭﺤﺎﺕ ﺍﻀﻐﻁ ﻓﻴﻬﺎ ﻋﻠﻰ‬
‫ﺍﻟﺯﺭ ‪ Add New‬ﻤﺭﺘﻴﻥ ﻹﻀﺎﻓﺔ ﻟﻭﺤﺘﻴﻥ ‪.‬‬
‫‪ 3‬ـ ﺤﺩﺩ ﺍﻟﻠﻭﺤﺔ ‪ 0‬ﻭﺃﻋﻁﻬﺎ ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ Width‬ﺍﻟﻘﻴﻤﺔ ‪. 150‬‬
‫‪ 4‬ـ ﺃﻀﻑ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ‪ OnMouseDown‬ﻟﻠﻨﻤﻭﺫﺝ ‪:‬‬
‫;)]‪StatusBar1.Panels[0].Text := Format ('origin = %d , %d',[x,y‬‬
‫‪ 5‬ـ ﺃﻀﻑ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnMouseMove‬ﻟﻠﻨﻤﻭﺫﺝ ‪:‬‬
‫;)]‪StatusBar1.Panels[1].Text := Format ('Point = %d , %d',[x,y‬‬

‫‪176‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ‪26‬‬

‫ﺍﻟﺭﺴﻡ ﻋﻠﻰ ﻋﻨﺼﺭ ﺼﻭﺭﺓ ‪:‬‬

‫ﺒﻤﺎ ﺃﻨﻨﺎ ﻨﺭﺴﻡ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﻤﺒﺎﺸﺭﺓ ﻓﻠﻥ ﻨﺴﺘﻁﻴﻊ ﺇﺠﺭﺍﺀ ﻋﻤﻠﻴﺎﺕ ﻋﻠﻰ ﺍﻟﺼﻭﺭ ﺍﻟﻤﺭﺴﻭﻤﺔ ﻜﺎﻟﻨﺴﺦ ﻭﺍﻟﻠـﺼﻕ ﻭﺍﻟﺤﻔـﻅ‬
‫ﻭﺍﻟﻁﺒﺎﻋﺔ‪ ،‬ﻟﺫﻟﻙ ﻋﻠﻴﻨﺎ ﺘﻁﻭﻴﺭ ﺒﺭﻨﺎﻤﺠﻨﺎ ﻟﻴﻜﻭﻥ ﻗﺎﺩﺭﹰﺍ ﻋﻠﻰ ﺍﻟﺭﺴﻡ ﻓﻭﻕ ﻋﻨﺼﺭ ﺍﻟﺼﻭﺭﺓ ‪ ،‬ﻗﺒل ﺇﻀﺎﻓﺔ ﻋﻨﺼﺭ ﺍﻟـﺼﻭﺭﺓ‬
‫ﺇﻟﻰ ﺍﻟﺸﻜل ﻋﻠﻴﻙ ‪.‬‬
‫‪ 1‬ـ ﺇﻀﺎﻓﺔ ﻤﺴﺎﺤﺔ ﻗﺎﺒﻠﺔ ﻟﻠﺘﺩﺭﺝ ‪:‬‬
‫ﺒﻤﺎ ﺃﻨﻙ ﺴﺘﺭﺴﻡ ﻓﻭﻕ ﻋﻨﺼﺭ ﺼﻭﺭﺓ ﻓﻘﺩ ﻴﻜﻭﻥ ﺤﺠﻡ ﺍﻟﺼﻭﺭﺓ ﺃﻜﺒﺭ ﻤﻥ ﺤﺠﻡ ﺍﻟﻨﻤﻭﺫﺝ ﻭﺒﺎﻟﺘﺎﻟﻲ ﻋﻠﻴﻨﺎ ﺇﻀـﺎﻓﺔ ﺃﺸـﺭﻁﺔ‬
‫ﺘﻤﺭﻴﺭ ﻟﻜﻲ ﻴﻤﻜﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻤﻥ ﺍﻟﻭﺼﻭل ﺇﻟﻰ ﺃﺠﺯﺍﺀ ﺍﻟﺼﻭﺭﺓ ﺍﻟﻐﻴﺭ ﻅﺎﻫﺭﺓ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﻭﻟﺘﺤﻘﻴﻕ ﺫﻟﻙ‪:‬‬
‫ﺃﻀﻑ ﺍﻟﻌﻨﺼﺭ ‪ ScrollBox‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪ Win32‬ﻭﺃﻋﻁ ﺍﻟﺨﺎﺼﺔ ‪ Align‬ﺍﻟﻘﻴﻤﺔ ‪. alClient‬‬
‫‪ 2‬ـ ﺇﻀﺎﻓﺔ ﻋﻨﺼﺭ ﺼﻭﺭﺓ ‪ Image‬ﻓﻭﻕ ﺍﻟﻌﻨﺼﺭ ‪ ScrollBox1‬ﻭﺃﻋﻁﺎﻩ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ‬
‫‪True‬‬ ‫‪AutoSize‬‬
‫‪0‬‬ ‫‪Left‬‬
‫‪True‬‬ ‫‪Stretch‬‬
‫‪0‬‬ ‫‪Right‬‬
‫ﺘﺤﺩﻴﺩ ﺍﻟﺤﺠﻡ ﻭﺍﻟﺼﻭﺭﺓ ﺍﻻﺒﺘﺩﺍﺌﻴﺔ ﻟﻌﻨﺼﺭ ﺍﻟﺼﻭﺭﺓ ‪:‬‬
‫ﻋﻨﺩﻤﺎ ﻭﻀﻌﻨﺎ ﺼﻭﺭ ﻋﻠﻰ ﺍﻟﺸﻜل ﻓﺈﻨﻨﺎ ﻟﻡ ﻨﺤﺩﺩ ﺼﻭﺭﺓ ﻟﻌﺭﻀﻬﺎ ﻭﻟﻜﻨﻨﺎ ﺤﺩﺩﻨﺎ ﻤﻜﺎﻥ ﻟﺘﻌﺭﺽ ﻓﻴﻪ ﺍﻟﺼﻭﺭﺓ‪ ،‬ﻭﻤﺎ ﻋﻠﻴﻨـﺎ‬
‫ﺍﻵﻥ ﺇﻻ ﻭﻀﻊ ﺼﻭﺭﺓ ﻓﺎﺭﻏﺔ ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ Picture‬ﻟﻠﻌﻨﺼﺭ ‪ Image1‬ﻭﻴﻤﻜﻥ ﺘﺤﻘﻴﻕ ﺫﻟﻙ ﺒﻁﺭﻴﻘﺘﻴﻥ ‪:‬‬
‫‪ 1‬ـ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ‪ :‬ﺇﻀﺎﻓﺔ ﺼﻭﺭﺓ ﻓﺎﺭﻏﺔ ﺫﺍﺕ ﻟﻭﻥ ﺃﺒﻴﺽ ﺫﺍﺕ ﺍﻤﺘﺩﺍﺩ ‪ .Bmp‬ﺇﻟـﻰ ﺍﻟﺨﺎﺼـﺔ ‪ Picture‬ﻟﻌﻨـﺼﺭ‬
‫ﺍﻟﺼﻭﺭﺓ ‪.‬‬
‫‪ 2‬ـ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ‪ :‬ﺇﻨﺸﺎﺀ ﻋﻨﺼﺭ ﺼﻭﺭﺓ ﻨﻘﻁﻴﺔ ‪ Bitmap‬ﻭﺇﻟﺤﺎﻗﺔ ﺒﺎﻟﺼﻭﺭﺓ ‪ Image1‬ﻭﻟﺘﺤﻘﻴﻕ ﺫﻟﻙ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ‬
‫ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnCreate‬ﻟﻠﻨﻤﻭﺫﺝ ‪:‬‬
‫‪Var‬‬
‫; ‪Bitmap : TBitmap‬‬
‫‪Begin‬‬
‫; ‪Bitmap := Tbitmap.Create‬‬
‫;‪Bitmap.Width := 200‬‬
‫;‪Bitmap.Height := 200‬‬
‫;‪Image1.Picture.Graphic := Bitmap‬‬
‫; ‪Bitmap.Free‬‬
‫ﺍﻟﺭﺴﻡ ﻋﻠﻰ ﻋﻨﺼﺭ ﺍﻟﺼﻭﺭﺓ ‪:‬‬
‫ﻟﻥ ﻴﺨﺘﻠﻑ ﺍﻟﺭﺴﻡ ﻋﻠﻰ ﻋﻨﺼﺭ ﺍﻟﺼﻭﺭﺓ ﻋﻥ ﺍﻟﺭﺴﻡ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ‪ ،‬ﻓﻌﻨﺼﺭ ﺍﻟﺼﻭﺭﺓ ﻴﻤﻠﻙ ﺍﻟﺨﺎﺼﺔ ‪ Canvas‬ﻭﻟﺘﺤﻘﻴﻕ‬
‫ﺍﻟﺭﺴﻡ ﺒﺩﻭﻥ ﺇﺠﺭﺍﺀ ﺘﻐﻴﺭﺍﺕ ﻜﺒﻴﺭﺓ ﻓﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻨﻔﺫ ﻤﺎﻴﻠﻲ ‪:‬‬

‫‪177‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ 1‬ـ ﻀﻊ ﻤﺅﺸﺭ ﺍﻟﺘﺤﺭﻴﺭ ﻓﻲ ﺃﻭل ﺍﻟﻭﺤﺩﺓ ‪ Graph‬ﻭﺍﺨﺘـﺭ ﻤـﻥ‬
‫ﺍﻷﻤﺭ ‪ Search Æ Replace‬ﻓﺘﻅﻬﺭ ﺍﻟﻨﺎﻓﺫﺓ ‪:‬‬
‫ﺍﻜﺘﺏ ﻓﻲ ﺍﻟﺤﻘل ‪ Text To Find‬ﺍﻟﻘﻴﻤﺔ ‪Canvas‬‬
‫ﻭﺍﻜﺘﺏ ﻓﻲ ‪ Replace With‬ﺍﻟﻘﻴﻤﺔ ‪Image1.Canvas‬‬
‫ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪Replace All‬‬
‫ﻼ‬
‫ﺴﻴﺘﻐﻴﺭ ﺍﻵﻥ ﻜل ﺴﻁﺭ ﻓﻲ ﺍﻟﻭﺤﺩﺓ ﻤﻥ …‪ Canvas.pen‬ﻤﺜ ﹰ‬
‫ﺇﻟﻰ ‪Image1.Canvas.pen..‬‬
‫‪ 2‬ـ ﺤﺩﺩ ﻋﻨﺼﺭ ﺍﻟﺼﻭﺭﺓ ﻭﺃﺫﻫﺏ ﺇﻟﻰ ﺍﻟﺼﻔﺤﺔ ‪ Event‬ﻭﺍﻀﻐﻁ‬
‫ﺍﻟﺴﻬﻡ ﺍﻟﻤﺠﺎﻭﺭ ﻟﻠﺤﺩﺙ ‪ OnMousemove‬ﻭﺍﺨﺘﺭ ﻤـﻥ ﺍﻟﻘﺎﺌﻤـﺔ‬
‫‪ ، FormMouseMove‬ﻜﺫﻟﻙ ﺃﺭﺒﻁ ﺍﻟﺤﺩﺙ ‪ OnMouseup‬ﻟﻠﺼﻭﺭﺓ ﻤﻊ ﺍﻟﺤـﺩﺙ ‪ Form1MouseUp‬ﻟﻠﻨﻤـﻭﺫﺝ‬
‫ﻭﻜﺫﻟﻙ ﺍﻷﻤﺭ ﺒﺎﻟﻨﺴﺒﺔ ﻟﻠﺤﺩﺙ ‪.. OnmouseDown‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻻﺤﻅ ﺍﻟﻨﺘﺎﺌﺞ ‪.‬‬

‫‪178‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺇﻀﺎﻓﺔ ﻗﺎﺌﻤﺔ ﺇﻟﻰ ﺒﺭﻨﺎﻤﺞ ﺍﻟﺭﺴﻡ ‪:‬‬
‫ﺴﻨﻀﻴﻑ ﺍﻵﻥ ﻗﺎﺌﻤﺔ ﺇﻟﻰ ﺒﺭﻨﺎﻤﺞ ﺍﻟﺭﺴﻡ ﻟﻠﺘﺤﻜﻡ ﺒﻌﻨﺼﺭ ﺍﻟﺼﻭﺭﺓ ‪:‬‬
‫ﺃﻀﻑ ﺍﻟﻌﻨﺼﺭ ‪ MainMenu‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪ Standard‬ﻭﺃﻨﺸﺄ ﺍﻟﻘﺎﺌﻤﺔ ‪ File‬ﺘﺤﻭﻱ ﺍﻷﻭﺍﻤﺭ‬
‫ﺍﻟﻤﻭﻀﺤﺔ ﺒﺎﻟﺸﻜل ‪:‬‬
‫ﻭﺃﻨﺸﺄ ﻓﻴﻬﺎ ﺍﻟﻘﺎﺌﻤﺔ ‪ Edit‬ﺍﻟﺘﻲ ﻴﺠﺏ ﺃﻥ ﺘﻅﻬﺭ ﻜﻤﺎ ﻓﻲ ﺍﻟﺸﻜل ‪:‬‬

‫ﺴﻨﻜﺘﺏ ﺍﻵﻥ ﺍﻷﻭﺍﻤﺭ ﺍﻟﺘﻲ ﻴﺠﺏ ﺘﻨﻔﻴﺫﻫﺎ ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﻜل ﺯﺭ ﻤﻥ ﺃﺯﺭﺍﺭ ﺍﻟﻘﺎﺌﻤﺔ ‪:‬‬
‫‪ 1‬ـ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Exit‬ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ‪ File‬ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; ‪Close‬‬
‫‪ 2‬ـ ﻋﻨﺩﻤﺎ ﻴﻀﻐﻁ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ New‬ﺴﺘﻅﻬﺭ ﻨﺎﻓﺫﺓ ﺘﻁﻠﺏ ﻤﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺘﺤﺩﻴﺩ ﺍﺭﺘﻔﺎﻉ ﻭﻋﺭﺽ ﺍﻟﺼﻭﺭﺓ‬
‫ﺍﻟﺠﺩﻴﺩﺓ ﻭﻋﻨﺩﻤﺎ ﻴﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﻤﻭﺍﻓﻕ ﺴﻴﺘﻡ ﺇﻨﺸﺎﺀ ﺼﻭﺭﺓ ﻓﺎﺭﻏﺔ ‪:‬‬
‫ﺃﻨﺸﺄ ﻨﻤﻭﺫﺝ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻋﻁﻪ ﺍﻟﺨﻭﺍﺹ ﺍﻟﻤﻨﺎﺴﺒﺔ ﺒﺤﻴﺙ ﻴﺒﺩﻭ ﻜﻤﺎ ﻓﻲ‬
‫ﺍﻟﺸﻜل ‪:‬‬
‫ﺃﻀﻑ ﺍﻟﻤﺘﺤﻭل ﺍﻟﺘﺎﻟﻲ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Public‬ﻟﻠﻭﺤﺩﺓ ‪ ) Graph‬ﺍﻟﻭﺤﺩﺓ‬
‫ﺍﻷﻭﻟﻰ (‬

‫;‪CurrentFile : String‬‬
‫ﺴﻨﺴﺘﺨﺩﻡ ﻫﺫﺍ ﺍﻟﻤﺘﺤﻭل ﻟﺤﻔﻅ ﺍﻟﻤﻠﻑ ﻻﺤﻘﹰﺎ ‪.‬‬
‫ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ New‬ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪Form2.ShowModal‬‬
‫ﻭﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﻤﻭﺍﻓﻕ ﻓﻲ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺜﺎﻨﻲ ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪var bitmap : tbitmap‬‬
‫‪begin‬‬
‫; ‪Bitmap := Tbitmap.Create‬‬
‫;) ‪Bitmap.Width := strtoint(edit1.Text‬‬
‫;) ‪Bitmap.Height := strtoint(edit2.Text‬‬
‫;‪form1.Image1.Picture.Graphic := Bitmap‬‬
‫; ‪bitmap.Free‬‬
‫; '' =‪Form1.CurrentFile :‬‬
‫;‪close‬‬
‫ﻭﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺇﻟﻐﺎﺀ ﺍﻷﻤﺭ ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪Close; :‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺃﻨﺸﺄ ﺼﻭﺭﺓ ﺠﺩﻴﺩﺓ ‪.‬‬

‫‪179‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ 4‬ـ ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Open‬ﺴﻴﻘﻭﻡ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒﻔﺘﺢ ﺼﻭﺭﺓ ﻓﻲ ﺍﻟﻌﻨﺼﺭ ‪ Image‬ﻭﺒﺎﻟﺘﺎﻟﻲ ﻴﻤﻜﻥ ﺘﺤﺭﻴﺭ ﻫﺫﻩ‬
‫ﺍﻟﺼﻭﺭﺓ ﺃﻭ ﺍﻟﺭﺴﻡ ﻓﻭﻗﻬﺎ ‪:‬‬
‫ـ ﺃﻀﻑ ﺍﻟﻌﻨﺼﺭ ‪ OpenPictureDialog‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪. Dialog‬‬
‫ـ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Open‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪ File‬ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪if OpenPictureDialog1.Execute then‬‬
‫‪begin‬‬
‫;‪CurrentFile := OpenPictureDialog1.FileName‬‬
‫;‪Image1.Picture.LoadFromFile(CurrentFile); end‬‬
‫‪ 3‬ـ ﻋﻨﺩﻤﺎ ﻴﻀﻐﻁ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Save‬ﺴﻨﻘﻭﻡ ﺒﺤﻔﻅ ﺍﻟﺼﻭﺭﺓ ﻓﻲ ﺍﺴﻡ ﺍﻟﻤﻠﻑ ﺍﻟﻤﺨﺯﻥ ﻓﻲ ﺍﻟﻤﺘﺤﻭل‬
‫‪ CurrentFile‬ﺃﻤﺎ ﺇﺫﺍ ﻜﺎﻥ '' = ‪ CurrentFile‬ﻓﻬﺫﺍ ﻴﻌﻨﻲ ﺃﻥ ﺍﻟﺼﻭﺭﺓ ﺠﺩﻴﺩﺓ ﻭﺒﺎﻟﺘﺎﻟﻲ ﻨﺴﺘﺩﻋﻲ ﺍﻷﺠﺭﺍﺀ‬
‫‪: Saveas1Click‬‬
‫ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪. Save‬‬
‫‪if CurrentFile <> '' then‬‬
‫)‪Image1.Picture.SaveToFile(CurrentFile‬‬
‫;)‪else SaveAs1Click(Sender‬‬
‫‪ 4‬ـ ﻋﻨﺩﻤﺎ ﻴﺭﻴﺩ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺃﻥ ﻴﺤﻔﻅ ﺍﻟﺼﻭﺭﺓ ﻓﻲ ﻤﻠﻑ ﺠﺩﻴﺩ ﻓﺈﻨﻪ ﺴﻴﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪: Save As‬‬
‫ﺍﻀﻑ ﺍﻟﻌﻨﺼﺭ ‪ SavePictureDialog‬ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﻭﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Save As‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ‬
‫‪ File‬ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ‬
‫‪if SavePictureDialog1.Execute then‬‬
‫‪begin‬‬
‫;‪CurrentFile := SavePictureDialog1.FileName‬‬
‫;‪Image1.Picture.SaveToFile(CurrentFile); end‬‬
‫‪ 5‬ـ ﻁﺒﺎﻋﺔ ﺍﻟﺼﻭﺭﺓ ‪:‬‬
‫ﺘﻌﺎﻤﻠﻨﺎ ﺴﺎﺒﻘﹰﺎ ﻤﻊ ﺍﻟﺼﺒﺎﻋﺔ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺼﻔﺤﺔ ﺍﻟﻌﻨﺎﺼﺭ ‪ ،QReport‬ﻭﺒﺈﻤﻜﻨﻨﺎ ﺍﺴﺘﺨﺩﺍﻡ ﻫﺫﻩ ﺍﻟﺼﻔﺤﺔ ﻟﻠﺼﺒﺎﻋﺔ ﻫﻨﺎ ﻭﻟﻜﻥ‬
‫ﺴﻨﺴﺘﺨﺩﻡ ﺃﺴﻠﻭﺒﹰﺎ ﺠﺩﻴﺩﹰﺍ ) ﻋﻠﻤﹰﺎ ﺃﻥ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ‪ Qreport‬ﻴﺒﻘﻰ ﺃﻓﻀل ( ‪:‬‬
‫ﺃ ـ ﺃﻀﻑ ﺍﻟﻭﺤﺩﺓ ‪ Printers‬ﺇﻟﻰ ﺍﻟﻘﺴﻡ ‪ Uses‬ﻟﻠﻭﺤﺩﺓ ‪ Graph‬ﻭﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Print‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ‬
‫‪ File‬ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; ‪printer.BeginDoc‬‬
‫;) ‪printer.Canvas.Draw(0,0,image1.Picture.Graphic‬‬
‫; ‪printer.EndDoc‬‬
‫ﻴﺴﺘﺨﺩﻡ ﺍﻟﻤﻨﻬﺞ ‪ BeginDoc‬ﻹﻋﻁﺎﺀ ﺍﻟﻁﺎﺒﻌﺔ ﺇﻴﻌﺎﺯ ﺘﺒﺩﺃ ﻋﻤﻠﻴﺎﺕ ﺍﻟﻁﺒﺎﻋﺔ ‪.‬‬
‫ﻴﺴﺘﺨﺩﻡ ﺍﻟﻤﻨﻬﺞ ‪ Canvas.Draw‬ﻟﻨﺴﺦ ) ﺭﺴﻡ ( ﺍﻟﺼﻭﺭﺓ ‪ Image1‬ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ Canvas‬ﻟﻌﻨﺼﺭ ﺍﻟﻁﺎﺒﻌﺔ‬
‫ﺘﺴﺘﺨﺩﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ EndDoc‬ﻹﻨﻬﺎﺀ ﺘﻜﻠﻴﻑ ﺍﻟﻁﺎﺒﻌﺔ ﻭﻋﻨﺩ ﻫﺫﺍ ﺍﻷﻤﺭ ﺘﺒﺩﺃ ﻋﻤﻠﻴﺔ ﺍﻟﻁﺒﺎﻋﺔ ‪.‬‬
‫ﻻ ﻤﻥ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ Draw‬ﻤﺜﺎل ‪:‬‬
‫ﺇﺫﺍ ﺃﺭﺩﺕ ﺃﻥ ﺘﺘﺤﻜﻡ ﺒﺤﺠﻡ ﺍﻟﺼﻭﺭﺓ ﺍﺴﺘﺨﺩﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ StretchDraw‬ﺒﺩ ﹰ‬
‫;) ‪printer.Canvas.StretchDraw(rect(0,0,4000,4000),image1.Picture.Graphic‬‬
‫ﺤﻴﺙ ﺍﻟﺘﺎﺒﻊ ‪ Rect‬ﻴﺤﺩﺩ ﺍﻟﻤﺴﺘﻁﻴل ﺍﻟﺫﻱ ﺴﺘﺘﻤﺩﺩ ﺍﻟﺼﻭﺭﺓ ﻓﻴﻪ ‪.‬‬

‫‪180‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺤﺎﻓﻅﺔ ‪ Clipboard‬ﻓﻲ ﺒﺭﻨﺎﻤﺠﻨﺎ ‪:‬‬
‫ﺴﻨﺴﺘﺨﺩﻡ ﺍﻟﺤﺎﻓﻅﺔ ﻟﻜﻲ ﻨﺘﻤﻜﻥ ﻤﻥ ﻨﺴﺦ ﺼﻭﺭﺓ ﻭﻟﺼﻘﻬﺎ ﺒﻺﻀﺎﻓﺔ ﺇﻟﻰ ﻗﺼﻬﺎ ﻓﻲ ﺒﺭﻨﺎﻤﺠﻨﺎ ‪:‬‬
‫ﺍﺴﺘﺨﺩﻤﻨﺎ ﺍﻟﺤﺎﻓﻅﺔ ﺴﺎﺒﻘﹰﺎ ﻟﻠﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻌﻨﺼﺭ ‪ DbImage‬ﺤﻴﺙ ﻜﺎﻥ ﻟﻬﺫﺍ ﺍﻟﻌﻨﺼﺭ ﺍﻟﻤﻨﻬﺠﻴﻥ ‪ CopyToClipbord‬ﻭ‬
‫‪ CutToClipord‬ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ‪ PasteFromClipboard‬ﻭﻟﻜﻥ ﻟﻸﺴﻑ ﺍﻟﻌﻨﺼﺭ ‪ Image‬ﺍﻟﻤﺴﺘﺨﺩﻡ ﻓﻲ ﺒﺭﻨﺎﻤﺠﻨـﺎ‬
‫ﻻ ﻴﻤﻠﻙ ﻫﺫﻩ ﺍﻟﻤﻨﺎﻫﺞ ﻭﻟﺫﻟﻙ ﻋﻠﻴﻨﺎ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻭﺤﺩﺓ ‪ ClipBrd‬ﻟﻠﺘﻌﺎﻤل ﻓﻲ ﺒﺭﻨﺎﻤﺠﻨﺎ ﻤﻊ ﺍﻟﺤﺎﻓﻅﺔ ‪ ،‬ﻟـﺫﻟﻙ ﺃﻀـﻑ‬
‫ﺍﻟﻭﺤﺩﺓ ‪ ClipBrd‬ﺇﻟﻰ ﺍﻟﻘﺴﻡ ‪ Uses‬ﻟﻠﻭﺤﺩﺓ ‪Graph‬‬
‫‪ 1‬ـ ﻨﺴﺦ ﺍﻟﺼﻭﺭﺓ ﺇﻟﻰ ﺍﻟﺤﺎﻓﻅﺔ ‪:‬‬
‫ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪Copy‬‬
‫;)‪Clipboard.Assign(Image.Picture‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺈﻟﺤﺎﻕ ﻫﺩﻑ ﺍﻟﺼﻭﺭﺓ ﺒﻬﺩﻑ ﺍﻟﺤﺎﻓﻅﺔ ‪. Clipboard‬‬

‫‪ 2‬ـ ﻗﺹ ﺍﻟﺼﻭﺭﺓ ﺇﻟﻰ ﺍﻟﺤﺎﻓﻅﺔ ‪:‬‬

‫ﻻ ﺒﻨﺴﺦ ﺍﻟﺼﻭﺭﺓ ﺇﻟﻰ ﺍﻟﺤﺎﻓﻅﺔ ﻭﻤﻥ ﺜﻡ ﻤﺴﺢ ﺍﻟﺼﻭﺭﺓ ‪:‬‬
‫ﻟﻘﺹ ﺍﻟﺼﻭﺭﺓ ﺇﻟﻰ ﺍﻟﺤﺎﻓﻅﺔ ﻨﻘﻭﻡ ﺃﻭ ﹰ‬
‫ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪: Cut‬‬
‫; ‪Var ARect :TRect‬‬
‫;)‪Clipboard.Assign(Image.Picture‬‬
‫;‪image1.Canvas.CopyMode := cmwhiteness‬‬
‫;)‪ARect :=rect(0,0,image1.Width,image1.Height‬‬
‫;)‪image1.Canvas.CopyRect( ARect,image1.Canvas,ARect‬‬
‫;‪image1.canvas.copymode := cmsrccopy‬‬
‫ﺍﻟﻨﻭﻉ ‪ TRect‬ﻋﺒﺎﺭﺓ ﻋﻥ ﻨﻭﻉ ﻤﺴﺘﻁﻴل ﻭﻫﻭ ﻴﻌﺭﻑ ﻤﺴﺘﻁﻴل ﻤﻥ ﺨﻼل ﻤﻌﺭﻓﺔ ﺇﺤﺩﺍﺜﻴﺎﺕ ﺍﻟﺒﺩﺍﻴﺔ ﻭﺍﻟﻨﻬﺎﻴـﺔ ﻟﻠﻤـﺴﺘﻘﻴﻡ‬
‫ﺍﻟﺫﻱ ﻴﻤﺜل ﺃﺤﺩ ﺍﻷﻗﻁﺎﺭ‪.‬‬
‫‪ : Canvas.CopyMode := cmWhiteness‬ﺘﻌﻨﻲ ﺃﻥ ﻋﻤﻠﻴﺔ ﻨﺴﺦ ﺼﻭﺭﺓ ﺇﻟﻰ ﺍﻟﺤﺎﻓﻅﺔ ﺴﺘﺘﻡ ﺒﺎﻟﻠﻭﻥ ﺍﻷﺒﻴﺽ ) ﺃﻱ‬
‫ﺃﻥ ﺍﻟﺼﻭﺭﺓ ﺴﺘﺼﺒﺢ ﺒﻴﻀﺎﺀ ( ‪.‬‬
‫)…‪ : ARect := Rect ( 0,0,‬ﺘﺤﺩﺩ ﺃﺒﻌﺎﺩ ﺍﻟﻤﺴﺘﻁﻴل ﺒﺄﺒﻌﺎﺩ ﺍﻟﻌﻨﺼﺭ ‪ Image‬ﺍﻟﺤﺎﻟﻴﺔ ‪.‬‬
‫)‪ : Canvas.CopyRect( ARect,Image.Canvas,ARect‬ﻋﻤﻠﻴﺔ ﻨﺴﺦ ﺇﻟﻰ ﺍﻟﻤﺴﺘﻁﻴل ﺍﻟﻤﺤﺩﺩ ﺒﺎﻟﻭﺴـﻴﻁ ﺍﻷﻭل‬
‫‪ ARect‬ﻤﻥ ﺍﻟﻜﻨﻔﺎ ﺍﻟﻤﺤﺩﺩﺓ ﺒﺎﻟﻭﺴﻴﻁ ﺍﻟﺜﺎﻨﻲ ﻭﺍﻟﻭﺴﻴﻁ ﺍﻟﺜﺎﻟﺙ ﻴﺤﺩﺩ ﺃﺒﻌﺎﺩ ﺍﻟﻤﺴﺘﻁﻴل ﺍﻟﺫﻱ ﺴﻴﻨﺴﺦ ﻤﻥ ﺍﻟﻜﻨﻔﺎ ﺍﻷﺼل ‪.‬‬
‫ﺒﻜﻠﻤﺎﺕ ﺃﺨﺭﻯ ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﻨﺴﺦ ﻤﺴﺘﻁﻴل ﺒﺤﺠﻡ ﺍﻟﺼﻭﺭﺓ ﻤﻥ ﻋﻨﺼﺭ ﺍﻟﻜﻨﻔﺎ ﺇﻟﻰ ﻋﻨﺼﺭ ﺍﻟﻜﻨﻔﺎ ﻨﻔـﺴﻪ ﻭﺴـﺘﻜﻭﻥ‬
‫ﺍﻟﻨﺘﻴﺠﺔ ﺼﻭﺭﺓ ﺒﻴﻀﺎﺀ ﻷﻨﻨﺎ ﺍﻟﺨﺎﺼﺔ ‪. CopyMode := cmWhiteness‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻷﺨﻴﺭﺓ ‪ : Canvas.CopyMode := cmsrcCopy‬ﺘﻌﻴﺩ ﺍﻟﺨﺎﺼﺔ ‪ CopyMode‬ﺇﻟﻰ ﻗﻴﻤﺘﻬﺎ ﺍﻻﻓﺘﺭﺍﻀﻴﺔ‬
‫‪.‬‬
‫ﻟﺼﻕ ﺍﻟﺭﺴﻭﻤﺎﺕ ﻤﻥ ﺍﻟﺤﺎﻓﻅﺔ ‪:‬‬
‫ﻋﻤﻠﻴﺔ ﻟﺼﻕ ﺼﻭﺭﺓ ﻤﻥ ﺍﻟﺤﺎﻓﻅﺔ ﻫﻲ ﻋﻤﻠﻴﺔ ﻤﻌﺎﻜﺴﺔ ﻟﻌﻤﻠﻴﺔ ﻨﺴﺦ ﺼﻭﺭﺓ ﺇﻟﻰ ﺍﻟﺤﺎﻓﻅﺔ ﻭﺘﺘﻡ ﺒﺎﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪181‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫; )‪image1.Picture.Bitmap.Assign(clipboard‬‬
‫ﻭﻟﻜﻥ ﺘﻅﻬﺭ ﻟﺩﻴﻨﺎ ﻫﻨﺎ ﺍﻟﻤﺸﻜﻠﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪ :‬ﺘﺼﻭﺭ ﺃﻥ ﺍﻟﺤﺎﻓﻅﺔ ﺘﺤﻭﻱ ﻋﻨﺼﺭ ﻨﺹ ) ﻗﺩ ﺘﻜﻭﻥ ﻨﻘﻠﺕ ﻨﺹ ﺇﻟﻰ ﺍﻟﺤﺎﻓﻅﺔ ﻓﻲ‬
‫ﺃﻱ ﺒﺭﻨﺎﻤﺞ ﺘﺤﺭﻴﺭ ﻨﺼﻭﺹ ( ﻭﺒﺎﻟﺘﺎﻟﻲ ﺴﺘﻜﻭﻥ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺴﺎﺒﻘﺔ ﺘﻁﻠﺏ ﻟﺼﻕ ﻨﺹ ﻓﻭﻕ ﻋﻨﺼﺭ ﺼﻭﺭﺓ ﺍﻷﻤـﺭ ﺍﻟـﺫﻱ‬
‫ﺴﻴﻅﻬﺭ ﺭﺴﺎﻟﺔ ﺨﻁﺄ ﻭﻟﺫﻟﻙ ﻋﻠﻴﻨﺎ ﻓﺤﺹ ﻨﻭﻉ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﻓﻲ ﺍﻟﺤﺎﻓﻅﺔ ﻗﺒل ﺇﺠﺭﺍﺀ ﻋﻤﻠﻴﺔ ﺍﻟﻠﺼﻕ ‪:‬‬
‫ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪: Paste‬‬

‫‪if Clipboard.HasFormat(cf_BITMAP) then‬‬

‫; )‪image1.Picture.Bitmap.Assign(clipboard‬‬
‫ﺘﻌﻴﺩ ﺍﻟﺘﻌﻠﻴﻤﺔ )‪ HasFormat (CF_BITMAP‬ﺇﺫﺍ ﻜﺎﻨﺕ ﻫﻨﺎﻙ ﺼﻭﺭﺓ ﻓﻲ ﺍﻟﺤﺎﻓﻅﺔ ‪.‬‬
‫ﺒﻬﺫﺍ ﻨﻜﻭﻥ ﻗﺩ ﺍﻨﻬﻴﻨﺎ ﺒﺭﻨﺎﻤﺞ ﺍﻟﺭﺴﻡ ﻭﺴﻨﻨﺘﻘل ﺍﻵﻥ ﻟﻠﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻭﺴﺎﺌﻁ ﺍﻟﻤﺘﻌﺩﺩﺓ ) ﺍﻟﻤﻠﺘﻤﻴﺩﻴﺎ ( ﻓﻲ ﺩﻟﻔﻲ ‪:‬‬

‫ﺒﺭﻤﺠﺔ ﺍﻷﻭﺴﺎﻁ ﺍﻟﻤﺘﻌﺩﺩﺓ ‪:‬‬

‫ﺇﻥ ﻤﺼﻁﻠﺢ ﺍﻷﻭﺴﺎﻁ ﺍﻟﻤﺘﻌﺩﺩﺓ ﻴﺸﻴﺭ ﺇﻟﻰ ﺃﻱ ﺸﻜل ﻤﻥ ﺃﺸﻜﺎل ﺍﻟﻌﺭﻭﺽ ﺍﻟﻤﺘﺤﺭﻜﺔ ) ﺍﻷﻓﻼﻡ ( ﻭﺍﻟﺼﻭﺕ ﻭﺍﻟﻤﺴﺘﺨﺩﻤﺔ‬
‫ﻓﻲ ﺍﻟﺤﺎﺴﺏ ‪،‬‬
‫ﻴﺴﺘﺨﺩﻡ ﺍﻟﻌﻨﺼﺭ ‪ MediaPlayer‬ﻓﻲ ﺍﻟﺼﻔﺔ ‪ System‬ﻟﻠﺘﻌﺎﻤل ﻤﻊ ﺍﻷﻭﺴﺎﻁ ﺍﻟﻤﺘﻌﺩﺩ ﻓﻲ ﺩﻟﻔﻲ ‪:‬‬
‫ﺍ ـ ﺘﺸﻐﻴل ﻤﻠﻔﺎﺕ ﺍﻷﺼﻭﺍﺕ ‪:‬‬
‫ﻤﺜﺎل ‪: 1‬‬
‫ﺃﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﺍﻟﻌﻨﺼﺭ ‪ MediaPlayer‬ﻭﺃﻋﻁﻪ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﺘﺤﺩﻴﺩ ﺍﻟﻤﻠﻑ ﺍﻟﺼﻭﺘﻲ ﺍﻟﺫﻱ ﺴﻴﻌﺭﻀﻪ‬ ‫‪C:\WINDOWS\MEDIA\ CHORD.WAV‬‬ ‫‪Filename‬‬
‫ﺍﻟﻌﻨﺼﺭ‬
‫ﺇﻤﻜﺎﻨﻴﺔ ﺍﻟﺘﺸﻐﻴل ﺍﻟﺘﻠﻘﺎﺌﻲ‬ ‫‪True‬‬ ‫‪Autoopen‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻷﺨﻀﺭ ﻭﺴﺘﺴﻤﻊ ﺍﻟﺼﻭﺕ ﺇﺫﺍ ﻜﺎﻨﺕ ﺃﺠﻬﺯﺓ ﺍﻟﺼﻭﺕ ﻓﻲ ﺤﺎﺴﻭﺒﻙ ﺠﺎﻫﺯﺓ ‪.‬‬
‫ﻤﺜﺎل‪ : 2‬ﺘﺤﺩﻴﺩ ﺍﻟﻤﻠﻑ ﺍﻟﺼﻭﺘﻲ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ‪:‬‬
‫ﺃﻀﻑ ﺯﺭ ﻭﻋﻨﺼﺭ ‪ OpenDialog‬ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺴﺎﺒﻕ ﻭﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻋﺩل ﺍﻟﺨﺎﺼﺔ ‪ Filter‬ﻟﻠﻌﻨﺼﺭ ‪ OpenDialog1‬ﺒﺤﻴﺙ ﻴﻌﺭﺽ ﻤﻠﻔﺎﺕ ﻤﻥ ﺍﻻﻤﺘﺩﺍﺩ ‪ .WAV‬ﻭ ﺍﻻﻤﺘﺩﺍﺩ ‪ .MP3‬ﻓﻘﻁ‬
‫‪.‬‬
‫ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ‬
‫; ‪MediaPlayer1.Close‬‬
‫‪if openDialog1.Execute then begin‬‬
‫; ‪MediaPlayer1.FileName := Opendialog1.FileName‬‬
‫; ‪MediaPlayer1.Open‬‬
‫;‪end‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻷﻭﻟﻰ ﺘﻌﻤل ﻋﻠﻰ ﺇﻴﻘﺎﻑ ﻋﻤل ﺍﻟﻌﻨﺼﺭ ‪ MediaPlayer‬ﺇﺫﺍ ﻜﺎﻥ ﻴﻌﺭﺽ ﻤﻠﻑ ﺼﻭﺘﻲ ﻋﻨﺩ ﻀﻐﻁ ﺍﻟﺯﺭ ‪.‬‬

‫‪182‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻭﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻷﺨﺭﻯ ﺘﺴﻨﺩ ﺃﺴﻡ ﻤﻠﻑ ﺠﺩﻴﺩ ﺇﻟﻰ ﺍﻟﻌﻨﺼﺭ ‪، MediaPlayer‬ﺃﻤﺎ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ Mediaplayer.Open‬ﻓﻤﻬﻤﺘﻬﺎ‬
‫ﻻ ‪ ،‬ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺤﺩﺩ ﻤﻠﻑ ﻤﺎ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻷﺨﻀﺭ ‪.‬‬
‫ﺠﻌل ﺍﻟﻌﻨﺼﺭ ﻓﻌﺎ ﹰ‬
‫ﻋﺭﺽ ﻤﻠﻔﺎﺕ ﺍﻟﻔﻴﺩﻴﻭ ‪:‬‬
‫ﻟﻌﺭﺽ ﻤﻠﻔﺎﺕ ﺍﻟﻔﻴﺩﻴﻭ ﺃﻀﻑ ﺍﻟﻌﻨﺼﺭ ‪ Panel‬ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺴﺎﺒﻕ ﻭﺃﻋﻁ ﺍﻟﻌﻨﺼﺭ ‪ MediaPlayer‬ﻓﻲ ﺍﻟﺨﺎﺼﺔ‬
‫‪ Display‬ﺍﻟﻘﻴﻤﺔ ‪، Panel1‬ﺜﻡ ﻋﺩل ﺍﻟﺨﺎﺼﺔ ‪ Filter‬ﻟﻠﻌﻨﺼﺭ ‪ OpenDialog1‬ﺒﺤﻴﺙ ﻴﻌﺭﺽ ﻤﻠﻔﺎﺕ ‪ .AVI‬ﻭ‬
‫‪ .DAT‬ﻭ ‪. .MPG‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻵﻥ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﻭﺤﺩﺩ ﺍﻟﻤﻠﻑ ) ﻁﺒﻌﹰﺎ ﺇﺫﺍ ﻜﻨﺕ ﻻ ﺘﻤﻠﻙ ﻏﻴﺭﻩ ( ‪:‬‬
‫‪C:\Program Files\Borland\Delphi6\Demos\CoolStuf\ speedis.avi‬‬
‫ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪ Play‬ﻭﺸﺎﻫﺩ ﺍﻟﻌﺭﺽ ‪.‬‬
‫ﺴﻤﺎﻉ ﺍﻟﺼﻭﺕ ﺒﺩﻭﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻌﻨﺼﺭ ‪: MediaPlayer‬‬
‫ﺍﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﺍﻟﺯﺭ ‪: SpeedButton‬‬
‫ﺃﻀﻑ ﺍﻟﻭﺤﺩﺓ ‪ MMSystem‬ﻟﻠﻘﺴﻡ ‪ Uses‬ﻭﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnMouseUP‬ﻟﻠﻌﻨﺼﺭ‬
‫‪SpeedButton‬‬
‫)‪PlaySound('C:\WINDOWS\MEDIA\DING.WAV',0,0‬‬
‫ﻁﺒﻌﹰﺎ ﺒﺈﻤﻜﺎﻨﻙ ﺘﺤﺩﻴﺩ ﺍﺴﻡ ﺍﻟﻤﻠﻑ ﺍﻟﺫﻱ ﺘﺭﻴﺩ ﻓﻲ ﺍﻟﻭﺴﻴﻁ ﺍﻷﻭل ‪.‬‬

‫‪183‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ‪27‬‬

‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻤﻠﻔﺎﺕ ‪:‬‬

‫ﺍ ـ ﻨﺴﺦ ﻤﻠﻑ ‪:‬‬
‫ﻤﺜﺎل ‪:‬‬
‫ﺃﻨﺸﺊ ﺼﻭﺭﺓ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺒﺭﻨﺎﻤﺞ ﺍﻟﺭﺴﺎﻡ ﻭﺍﺤﻔﻅﻬﺎ ﻋﻠﻰ ﺍﻟﻘﺭﺹ \‪ C:‬ﺒﺎﺴﻡ ‪ Test.Bmp‬ﻭﺃﻨـﺸﺄ ﺍﻟﻤﺠﻠـﺩ ‪،C:\temp‬‬
‫ﻭﺃﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﻼﺯﻤﺔ ﻟﻨﺴﺦ ﻫﺫﺍ ﺍﻟﻤﻠﻑ ﺇﻟﻰ ﺍﻟﻤﺠﻠﺩ ‪: C:\temp‬‬
‫; )‪copyfile('c:\Test.bmp','c:\Temp\Test.bmp',False‬‬
‫ﺍﻟﻭﺴﻴﻁ ﺍﻷﻭل ‪ :‬ﻫﻭ ﺍﻟﻤﻠﻑ ﺍﻟﻤﺼﺩﺭ ) ﺍﻟﻤﻠﻑ ﺍﻟﺫﻱ ﺴﻴﺘﻡ ﻨﺴﺨﻪ ( ‪.‬‬
‫ﺍﻟﻭﺴﻴﻁ ﺍﻟﺜﺎﻨﻲ ‪ :‬ﻫﻭ ﺍﻟﻤﻠﻑ ﺍﻟﻬﺩﻑ ) ﺍﻟﻤﻠﻑ ﺍﻟﺫﻱ ﺴﻴﺘﻡ ﺇﻨﺸﺎﺀﻩ ﻭﺴﻴﻜﻭﻥ ﻨﺴﺨﺔ ﻋﻥ ﺍﻷﺼل ﻓﻲ ﺍﻟﻤﻠﻑ ﺍﻷﻭل ( ﻴﻤﻜـﻥ‬
‫ﺃﻴﻀﹰﺎ ﺘﻐﻴﺭ ﺍﺴﻡ ﺍﻟﻤﻠﻑ ﺍﻟﻬﺩﻕ ﺃﻱ ﻴﻤﻜﻥ ﺃﻥ ﻴﻜﻭﻥ ﺍﻟﻭﺴﻴﻁ ﺍﻟﺜﺎﻨﻲ '‪ 'C:\Temp\Des.bmp‬ﻭﺒﻬﺫﺍ ﺴﻴﺘﻡ ﻨـﺴﺦ ﺍﻟﻤﻠـﻑ‬
‫‪ C:\test.bmp‬ﺇﻟﻰ ﺍﻟﻤﻠﻑ ‪ C:\temp\des.bmp‬ﻭﺒﺎﻟﺘﺎﻟﻲ ﺴﻴﻜﻭﻥ ﻟﻠﻤﻠﻔﻴﻥ ﺃﺴﻤﻴﻥ ﻤﺨﺘﻠﻔﻴﻥ ﻭﻟﻜﻨﻬﻤﺎ ﺴـﻴﺤﻭﻴﺎﻥ ﻨﻔـﺱ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ‪.‬‬
‫ﺍﻟﻭﺴﻴﻁ ﺍﻟﺜﺎﻟﺙ ‪ :‬ﻓﻲ ﺤﺎل ﺃﻋﻁﻴﺕ ﻫﺫﺍ ﺍﻟﻭﺴﻴﻁ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻓﺈﻥ ﺍﻟﺘﺎﺒﻊ ﺴﻴﻔﺸل ﻓﻲ ﺤﺎل ﻜﺎﻥ ﻫﻨﺎﻙ ﻤﻠﻑ ﺒﻨﻔﺱ ﺍﻷﺴـﻡ‬
‫ﻓﻲ ﺍﻟﻤﺠﻠﺩ ﺍﻟﻬﺩﻑ ﻭﺃﻤﺎ ﺃﻥ ﻜﺎﻨﺕ ﻗﻴﻤﺘﻪ ‪ False‬ﻓﻬﺫﺍ ﻴﻌﻨﻲ ﺃﻨﻪ ﺴﺘﺘﻡ ﺍﻟﻜﺘﺎﺒﺔ ﻓﻭﻕ ﺍﻟﻤﻠﻑ ﺍﻟﻬﺩﻑ ﺇﺫﺍ ﻜﺎﻥ ﻤﻭﺠﻭﺩﹰﺍ ‪.‬‬
‫‪ 2‬ـ ﻨﻘل ﻤﻠﻑ ‪:‬‬
‫ﺘﻘﻭﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﺒﻨﻘل ﺍﻟﻤﻠﻑ ﻤﻥ ﻤﻜﺎﻥ ﺇﻟﻰ ﺁﺨﺭ ﻤﻊ ﺇﻤﻜﺎﻨﻴﺔ ﺘﻐﻴﻴﺭ ﺃﺴﻤﻪ ‪ ) :‬ﺃﻀﻑ ﺯﺭ ﺇﻟـﻰ ﺍﻟﻤـﺸﺭﻭﻉ ﺍﻟـﺴﺎﺒﻕ‬
‫ﻭﺍﻜﺘﺏ ﻓﻴﻪ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;)'‪Movefile('c:\temp\test.bmp','c:\movetest.bmp‬‬
‫ﺍﻟﻭﺴﻴﻁ ﺍﻷﻭل ﻫﻭ ﺍﻟﻤﻠﻑ ﺍﻷﺼل ‪ ،‬ﻭﺍﻟﻭﺴﻴﻁ ﺍﻟﺜﺎﻨﻲ ﻫﻭ ﺍﻟﻤﻠﻑ ﺍﻟﻬﺩﻑ ‪ ،‬ﺴﻴﻔﺸل ﺍﻟﺘﺎﺒﻊ ﻓﻲ ﺤﺎل ﻜﺎﻥ ﺍﻟﻤﻠﻑ ﺍﻷﺼل ﻏﻴﺭ‬
‫ﻤﻭﺠﻭﺩ ﺃﻭ ﻓﻲ ﺤﺎل ﻜﺎﻥ ﺍﻟﻤﻠﻑ ﺍﻟﻭﺠﻬﺔ ﻤﻭﺠﻭﺩﹰﺍ ) ﻟﻴﺱ ﻫﻨﺎﻙ ﻫﻨﺎ ﺍﻜﺎﻨﻴﺔ ﻟﻠﻜﺘﺎﺒﺔ ﻓﻭﻕ ﺍﻟﻤﻠﻑ ( ‪.‬‬
‫‪ 3‬ـ ﺤﺫﻑ ﻤﻠﻑ ‪:‬‬
‫ﻟﺤﺫﻑ ﻤﻠﻑ ﻤﺎ ﺍﺴﺘﺨﺩﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;)'‪DeleteFile('c:\movetest.bmp‬‬
‫‪ 4‬ـ ﻁﺭﻕ ﺃﻨﺸﺎﺀ ﺍﻟﻤﻠﻔﺎﺕ ﻭﺍﻟﺘﻌﺎﻤل ﻤﻌﻬﺎ ﻓﻲ ﺩﻟﻔﻲ ‪:‬‬
‫‪ 1‬ـ ﻤﻠﻔﺎﺕ ﻟﻐﺔ ﺍﻟﺒﺎﺴﻜل ‪ :‬ﻴﻤﻜﻨﻙ ﺇﻨﺸﺎﺀ ﺍﻟﻤﻠﻔﺎﺕ ﺍﻟﻨﺼﻴﺔ ﻭﺍﻟﻤﻠﻔﺎﺕ ﻤﺤﺩﺩﺓ ﺍﻟﻨﻭﻉ ﻭﺍﻟﻤﻠﻔـﺎﺕ ﻏﻴـﺭ ﻤﺤـﺩﺩﺓ ﺍﻟﻨـﻭﻉ )‬
‫‪ ( Untyped File‬ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﻤﻌﺭﻭﻓﺔ ﻓﻲ ﻟﻐﺔ ﺘﺭﺒﻭ ﺒﺎﺴﻜل ﻤﺜل) ‪ AssignFile‬ﻭ ‪ Reset‬ﻭ ‪ Rewrite‬ﻭ‬
‫‪ Readln‬ﻭ ‪ Writeln‬ﻭ ‪ ،( .. CloseFile‬ﺘﻌﺘﺒﺭ ﻫﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﻏﻴﺭ ﻤﺘﻭﺍﻓﻘﺔ ﻤﻊ ﻭﻴﻨﺩﻭﺯ ﻭﻟﻜﻨﻬﺎ ﺘﻌﻤل ﻋﻠﻰ ﺃﻴﺔ ﺤﺎل‬
‫ﻭﻟﻜﻥ ﺘﻔﻀل ﺍﻟﻁﺭﻕ ﺍﻷﺨﺭﻯ ‪.‬‬
‫‪ 2‬ـ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻤﻘﺎﺒﺽ ﺍﻟﻤﻠﻑ ﻓﻲ ﻭﻴﻨﺩﻭﺯ ) ‪ : ( File Handles‬ﻴﺘﻡ ﺘﻌﻴﻥ ﻤﻘﺒﺽ ﻟﻠﻤﻠﻑ ﻋﻨﺩ ﺇﻨﺸﺎﺀﻩ ﺃﻭ ﻓﺘﺤﺔ ﻭﻤﻥ‬
‫ﺜﻡ ﻴﺘﻡ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻫﺫﺍ ﺍﻟﻤﻘﺒﺽ ﺤﻴﺙ ﺘﺴﺘﺩﻋﻲ ﺍﻟﺘﻭﺍﺒﻊ ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ ﺘﻭﺍﺒﻊ ‪ Windows Api‬ﻹﺘﻤﺎﻡ ﻋﻤﻠﻬﺎ‬
‫ﻭﺠﻤﻴﻊ ﻫﺫﻩ ﺍﻟﺘﻭﺍﺒﻊ ﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﻭﺤﺩﺓ ‪. SysUtils‬‬

‫‪184‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ 3‬ـ ﻤﻠﻔﺎﺕ ﺴﺘﺭﻴﻡ ‪) : File Streams‬ﻤﻌﻨﻰ ﻜﻠﻤﺔ ‪ Stream‬ﻫﻭ ﻨﻬﺭ ﺃﻭ ﺠﺩﻭل ﺃﻭ ﺴﻴل ﻭﻻ ﺃﻋﺭﻑ ﻜﻴﻑ ﺃﺘﺭﺠﻤﻬـﺎ‬
‫ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ ﻭﻗﺩ ﺠﺭﺕ ﺍﻟﻌﺎﺩﺓ ﺒﻴﻥ ﺍﻟﻤﺒﺭﻤﺠﻥ ﺍﻟﺤﺩﻴﺙ ﻋﻨﻬﺎ ﺒـ ﺴﺘﺭﻴﻡ ﻓﻴل ( ﻫﺫﻩ ﺍﻟﻤﻠﻔﺎﺕ ﻤﻥ ﺍﻟﻨﻭﻉ ‪TFileStream‬‬
‫ﻭﻫﻲ ﻤﻠﻔﺎﺕ ﺘﺴﺘﻁﻴﻊ ﺃﻥ ﺘﺨﺯﻥ ﻓﻴﻬﺎ ﺃﻱ ﻨﻭﻉ ﻤﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻜﻤﺎ ﻴﻤﻜﻥ ﺃﻥ ﺘﺤﻔﻅ ﻓﻴﻬﺎ ﺒﻴﺎﻨﺎﺘﻙ ﺒﻁﺭﻴﻘﺔ ﻤـﺸﻔﺭﺓ ﺒﺤﻴـﺙ ﻻ‬
‫ﻴﺴﺘﻁﻴﻊ ﺃﺤﺩ ﻏﻴﺭﻙ ﺍﻹﻁﻼﻉ ﻋﻠﻴﻬﺎ ﺘﺘﻌﺎﻤل ﻫﺫﻩ ﺍﻟﻤﻠﻔﺎﺕ ﻤﻊ ﺍﻟﻨﻭﻋﻴﻥ ‪ TStream‬ﻭ ‪ TMemoryStream‬ﻭﻫﺫﺍ ﻴﻤﻜﻨﻙ‬
‫ﻤﻥ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺫﺍﻜﺭﺓ ﺒﺸﻜل ﻤﺒﺎﺸﺭ ﻭﻴﻤﻜﻨﻙ ﺘﺤﻤﻴل ﺒﻴﺎﻨﺎﺘﻙ ﺇﻟﻰ ﺍﻟﺫﺍﻜﺭﺓ ﻭﻤﻥ ﺜﻡ ﺘﺨﺯﻴﻨﻬﺎ ﻓﻲ ﻤﻠﻑ ﺃﻭ ﻴﻤﻜﻨﻙ ﺘﺤﻤﻴﻠﻬﺎ‬
‫ﺒﻴﺎﻨﺎﺘﻙ ﺇﻟىﺎﻟﺫﺍﻜﺭﺓ ﻟﻴﺘﺸﺎﺭﻙ ﻋﻠﻴﻬﺎ ﺃﻜﺜﺭ ﻤﻥ ﺠﺯﺀ ﻤﻥ ﺒﺭﻨﺎﻤﺠﻙ ‪.‬‬

‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻤﻠﻔﺎﺕ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﻤﻘﺒﺽ ) ‪: ( Working With File Handles‬‬

‫ﺴﻨﻭﻀﺢ ﻤﺜﺎ ﹰﻻ ﻴﺒﻴﻥ ﻁﺭﻴﻘﺔ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻫﺫﻩ ﺍﻟﻤﻠﻔﺎﺕ ‪:‬‬
‫ﺃ ـ ﺍﻟﻜﺘﺎﺒﺔ ﺇﻟﻰ ) ﻓﻲ ( ﻤﻠﻑ ‪:‬‬
‫ﺃﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪var FileHandle:integer‬‬
‫;‪S:string‬‬
‫‪Begin‬‬
‫‪if Not FileExists('c:\MyFile.mka') then‬‬
‫‪FileHandle:= FileCreate('c:\MyFile.mka') Else‬‬
‫; )‪FileHandle:= FileOpen('c:\MyFile.mka',fmOpenReadWrite‬‬
‫; '‪s:= 'khaled Nassr Agha‬‬
‫;)) ‪FileWrite(FileHandle,Pointer(s)^,length(s‬‬
‫;)‪Fileclose(FileHandle‬‬
‫;‪end‬‬
‫ﻓﻲ ﺍﻟﺒﺩﺍﻴﺔ ﻨﺴﺘﺨﺩﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ FileExists‬ﺍﻟﺘﻲ ﺘﻌﻴﺩ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻓﻲ ﺤﺎل ﻜﺎﻥ ﺍﻟﻤﻠﻑ ﻤﻭﺠﻭﺩﹰﺍ ﻭﻓﻲ ﺤﺎل ﻋﺩﻡ ﻭﺠـﻭﺩ‬
‫ﺍﻟﻤﻠﻑ ﻨﺴﺘﺨﺩﻡ ﺍﻟﺘﺎﺒﻊ ‪ FileCreate‬ﺍﻟﺘﻲ ﻴﻨﺸﺄ ﺍﻟﻤﻠﻑ ﻭﻴﻌﻴﺩ ﺭﻗﻡ ﻤﻘﺒﺽ ﻫﺫﺍ ﺍﻟﻤﻠﻑ ﻓﻲ ﺍﻟﻤﺘﺤﻭل ‪ ، FileHandle‬ﺃﻤـﺎ‬
‫ﻓﻲ ﺤﺎل ﻭﺠﻭﺩ ﺍﻟﻤﻠﻑ ﺴﺎﺒﻘﹰﺎ ﻓﻨﺴﺘﺨﺩﻡ ﺍﻟﺘﺎﺒﻊ ‪ FileOpen‬ﺍﻟﺫﻱ ﻴﻘﻭﻡ ﺒﻔﺘﺢ ﺍﻟﻤﻠﻑ ﻭﻴﻌﻴﺩ ﺭﻗﻡ ﻤﻘﺒﺽ ﻫـﺫﺍ ﺍﻟﻤﻠـﻑ ﻓـﻲ‬
‫ﺍﻟﻤﺘﺤﻭل ‪ ، FileHandle‬ﻭﺍﻟﻭﺴﻴﻁ ﺍﻟﺜﺎﻨﻲ ‪ fmOpenReadWrite‬ﻫﻭ ﺃﺤﺩ ﺍﻟﻘﻴﻡ ﺍﻟﺘﻲ ﻴﺄﺨﺫﻫﺎ ﻫﺫﺍ ﺍﻟﻤﻠﻑ ﻭﻴﻌﻨﻲ ﺍﻨـﻪ‬
‫ﺴﻨﺴﺘﺨﺩﻡ ﺍﻟﻤﻠﻑ ﻟﻠﻘﺭﺍﺀﺓ ﻭﺍﻟﻜﺘﺎﺒﺔ ﻭﻫﻨﺎﻙ ﻋﺩﺓ ﻗﻴﻡ ﺃﺨﺭﻯ ﺭﺍﺠﻊ ﻤﻠﻔﺎﺕ ﺍﻟﻤﺴﺎﻋﺩﺓ ﻟﻠﺤﺼﻭل ﻋﻠﻰ ﻤﻌﻠﻭﻤﺎﺕ ﻋﻨﻬﺎ‪.‬‬
‫ﺍﻟﺘﺎﺒﻊ ‪ FileWrite‬ﻴﻘﻭﻡ ﺒﻜﺘﺎﺒﺔ ﺍﻟﻘﻴﻤﺔ ‪ S‬ﻭﺍﻟﺘﻲ ﻫﻲ ﻤﻥ ﻨﻭﻉ ﻤﺅﺸﺭ ﻓﻲ ﺍﻟﻤﻠﻑ ﺫﻭ ﺍﻟﻤﻘـﺒﺽ ‪ FileHandle‬ﻭﺒﻁـﻭل‬
‫ﺍﻟﻤﺘﺤﻭل ﺍﻟﺜﺎﻟﺙ ﻭﺍﻟﺫﻱ ﻴﺸﻴﺭ ﻫﻨﺎ ﺇﻟﻰ ﻁﻭل ﺍﻟﺴﻠﺴﻠﺔ ‪. S‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻷﺨﻴﺭﺓ ‪ FileClose‬ﺘﻘﻭﻡ ﺒﺈﻏﻼﻕ ﺍﻟﻤﻠﻑ ﺍﻟﻤﻔﺘﻭﺡ ‪.‬‬
‫ﺏ ـ ﺍﻟﻘﺭﺍﺀﺓ ﻤﻥ ﻤﻠﻑ ‪:‬‬
‫ﺃﻀﻑ ﻋﻨﺼﺭ ‪ Memo‬ﻭ ﺯﺭﹰﺍ ﺠﺩﻴﺩﹰﺍ ﻭﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻴﻪ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪var FileHandle,FileSize : integer‬‬
‫;‪s:string‬‬
‫‪begin‬‬
‫‪if FileExists ('c:\MyFile.mka') then begin‬‬
‫; )‪FileHandle:= FileOpen('c:\MyFile.mka',fmOpenReadWrite‬‬

‫‪185‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫;)‪FileSize:=getfilesize(FileHandle,nil‬‬
‫;)‪setlength(s,FileSize‬‬
‫;)‪Fileread(FileHandle,pointer(s)^,FileSize‬‬
‫;‪Memo1.Text := s‬‬
‫;)‪Fileclose(FileHandle‬‬
‫;‪end‬‬
‫ﻟﻠﺘﻨﻘل ﻀﻤﻥ ﺍﻟﻤﻠﻑ ﺘﺴﺘﺨﺩﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ )‪ : SeekFile ( Handle, Offset ,origin‬ﺤﻴﺙ ‪ Handle‬ﻫﻭ ﻤﻘﺒﺽ ﺍﻟﻤﻠﻑ‬
‫ﻭ ‪ Offset‬ﻤﻘﺩﺍﺭ ﺍﻹﺯﺍﺤﺔ ﻋﻥ ‪ Origin‬ﻭﻴﺄﺨﺫ ‪ Origin‬ﺍﻟﻘﻴﻡ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫ﻴﺘﻡ ﺍﻋﺘﺒﺎﺭ ﺍﻹﺯﺍﺤﺔ ‪ Offset‬ﻤﻥ ﺃﻭل ﺍﻟﻤﻠﻑ ‪.‬‬ ‫‪0‬‬

‫ﻴﺘﻡ ﺍﻋﺘﺒﺎﺭ ﺍﻹﺯﺍﺤﺔ ‪ Offset‬ﻤﻥ ﻤﻭﻗﻊ ﺍﻟﻤﺅﺸﺭ ﺍﻟﺤﺎﻟﻲ ‪.‬‬ ‫‪1‬‬
‫ﻴﺘﻡ ﺍﻋﺘﺒﺎﺭ ﺍﻹﺯﺍﺤﺔ ‪ Offset‬ﻤﻥ ﺁﺨﺭ ﺍﻟﻤﻠﻑ ‪.‬‬ ‫‪2‬‬
‫ﻼ ﺍﻟﺘﻌﻠﻴﻤــﺔ )‪ SeekFile(FileHandle,0,0‬ﺘــﻀﻊ ﻤﺅﺸــﺭ ﺍﻟﻤﻠــﻑ ﻓــﻲ ﺒﺩﺍﻴــﺔ ﺍﻟﻤﻠــﻑ ﻭ ﺍﻟﺘﻌﻠﻴﻤــﺔ‬
‫ﻤــﺜ ﹰ‬
‫)‪ Seekfile(FileHandle,12,2‬ﺘﻀﻊ ﻤﺅﺸﺭ ﺍﻟﻤﻠﻑ ﻋﻠﻰ ﺒﻌﺩ ‪ 12‬ﺤﺭﻑ ﻤﻥ ﺁﺨﺭ ﺍﻟﻤﻠﻑ ‪.‬‬
‫ﺍﻟﻤﻠﻔﺎﺕ ﺴﺘﺭﻴﻡ ‪: File Stream‬‬
‫ﺴﻨﺄﺨﺫ ﻤﺜﺎ ﹰﻻ ﺒﺴﻴﻁ ﹰﺎ ﻋﻥ ﻜﻴﻔﻴﺔ ﺃﻨﺸﺎﺀ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﻠﻔﺎﺕ ﺯﻤﻥ ﺍﻟﻘﺭﺍﺀﺓ ﻭﺍﻟﻜﺘﺎﺒﺔ ﺇﻟﻴﻬﺎ ‪:‬‬
‫ﺇﻨﺸﺎﺀ ﻤﻠﻑ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ TFileStream‬ﻭﺍﻟﻜﺘﺎﺒﺔ ﺇﻟﻴﻪ ‪:‬‬
‫ﺃﻀﻑ ﺯﺭ ﺇﻟﻰ ﻨﻤﻭﺫﺝ ﺠﺩﻴﺩ ﻭﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; ‪Var FileStream : TFileStream‬‬
‫;‪buffer : String‬‬
‫‪begin‬‬
‫; )‪FileStream := TFileStream.Create('c:\MyStream.tst',fmCreate‬‬
‫; ' ‪Buffer := ' This Line Will Be Save to File‬‬
‫;))‪FileStream.Write(pointer(Buffer)^,Length(Buffer‬‬
‫; ‪FileStream.Free‬‬
‫;‪end‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ TFileStream.Create‬ﺘﻨﺸﺄ ﺍﻟﻤﻠﻑ ‪ MyStream.Tst‬ﻋﻠﻰ ﺍﻟﻘﺭﺹ ‪ C‬ﺃﻤﺎ ﺍﻟﻭﺴﻴﻁ ‪ fmCreate‬ﻓﺈﻨﻪ ﻴﻘﻭﻡ‬
‫ﺒﺈﻨﺸﺎﺀ ﺍﻟﻤﻠﻑ ﺇﺫﺍ ﻟﻡ ﻴﻜﻥ ﻤﻭﺠﺩﹰﺍ ﻭﻓﻲ ﺤﺎل ﻜﺎﻥ ﻤﻭﺠﻭﺩﹰﺍ ﻴﻔﺘﺢ ﺍﻟﻤﻠﻑ ﻓﻲ ﻭﻀﻊ ﻟﻠﻜﺘﺎﺒﺔ ﻓﻘﻁ ‪.‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ : FileStream.Write‬ﺘﻘﻭﻡ ﺒﻜﺘﺎﺒﺔ ﺍﻟﻨﺹ ﻓﻲ ﺍﻟﻤﺘﺤﻭل ‪ ) Buffer‬ﻻ ﺘﺘﻌﺎﻤل ﺇﻻ ﻤﻊ ﺍﻟﻤﺅﺸﺭﺍﺕ (‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ : FileStream.Free‬ﺘﻘﻭﻡ ﺒﺘﺤﺭﻴﺭ ﺍﻟﻤﺘﺤﻭل ‪ FileStream‬ﻭﺇﻏﻼﻕ ﺍﻟﻤﻠﻑ ﺍﻟﻤﺭﺘﺒﻁ ﻤﻌﻪ ‪.‬‬
‫ﺍﻟﻘﺭﺍﺀﺓ ﻤﻥ ﻤﻠﻑ ‪: TFileStream‬‬
‫ﺃﻀﻑ ﻋﻨﺼﺭ ‪ Memo‬ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺴﺎﺒﻕ ﻭﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺠﺩﻴﺩ ‪:‬‬
‫; ‪Var FileStream : TFileStream‬‬
‫;‪buffer : String‬‬
‫;‪FileSize : integer‬‬
‫‪begin‬‬
‫; )‪FileStream := TFileStream.Create('c:\MyStream.tst',fmOpenRead‬‬
‫;) ‪FileSize := (FileStream.size‬‬
‫‪186‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫;)‪Setlength(Buffer,FileSize‬‬
‫;)‪FileStream.read(pointer(Buffer)^,FileSize‬‬
‫;‪memo1.text := Buffer‬‬
‫; ‪FileStream.Free‬‬
‫;‪end‬‬
‫ﻻ ﺒﻔﺘﺢ ﺍﻟﻤﻠﻑ ﻟﻠﻘﺭﺍﺀﺓ ﻓﻘﻁ ﻓﻲ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ Create‬ﻭﻤﻥ ﺜﻡ ﺍﺴﺘﺨﺩﻤﻨﺎ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ FileStream.Size‬ﻟﺘﺤﺩﻴﺩ ﺤﺠـﻡ‬
‫ﻗﻤﻨﺎ ﺍﻭ ﹰ‬
‫ﺍﻟﻤﻠﻑ ﻭﺃﻋﻁﻴﻨﺎ ﺍﻟﻤﺘﺤﻭل ‪ Buffer‬ﺤﺠﻡ ﻫﺫﺍ ﺍﻟﻤﻠﻑ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ SetLength‬ﺜﻡ ﻗﺭﺃﻨﺎ ﻤﻥ ﺍﻟﻤﻠﻑ ﺇﻟﻰ ﺍﻟﻤﺘﺤﻭل‬
‫‪ Buffer‬ﻭﻭﻀﻌﻨﺎ ﺍﻟﻨﺘﻴﺠﺔ ﻓﻲ ﺍﻟﻌﻨﺼﺭ ‪. Memo1‬‬

‫ﻤﻼﺤﻅﺎﺕ ‪:‬‬
‫‪ 1‬ـ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ : FieStream.Seek‬ﺘﻘﻭﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ Seek‬ﻟﻨﻘل ﻤﺅﺸﺭ ﺍﻟﻤﻠﻑ ﻟﻤﺴﺎﻓﺔ ﻤﺤﺩﺩﺓ ﺘﺒﻌﹰﺎ ﻟﻠﻭﺴـﻴﻁ ‪( Origin‬‬
‫ﺭﺍﺠﻊ ﺍﻟﻭﺴﻴﻁ ‪ Origin‬ﻟﻠﺘﻌﻠﻴﻤﺔ ‪ SeekFile‬ﻟﻺﻁﻼﻉ ﺃﻜﺜﺭ ﻋﻠﻰ ﻭﺴﻁﺎﺀ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ (‪.‬‬

‫ﻤﻌﻠﻭﻤﺎﺕ ﻤﻔﻴﺩﺓ ‪:‬‬

‫ﺍ ـ ﺘﺸﻐﻴل ﺒﺭﻨﺎﻤﺞ ﺁﺨﺭ ﻤﻥ ﺩﺍﺨل ﺒﺭﻨﺎﻤﺠﻙ ‪:‬‬
‫ﺒﻔﺭﺽ ﺃﻨﻙ ﺘﺭﻴﺩ ﺘﺴﺘﺩﻋﻲ ﺒﺭﻨﺎﻤﺞ ﺍﻵﻟﺔ ﺍﻟﺤﺎﺴﺒﺔ ﻀﻤﻥ ﺒﺭﻨﺎﻤﺞ ‪ :‬ﻤﻥ ﺍﻟﻤﻌﻠﻭﻡ ﺃﻥ ﺒﺭﻨﺎﻤﺞ ﺍﻟﺤﺎﺴﺒﺔ ﻴﺘﻡ ﺘﻨﻔﻴﺫﺓ ﻋﻥ ﻁﺭﻴﻕ‬
‫ﺍﻟﻤﻠﻑ ‪ Calc.exe‬ﺍﻟﻤﻭﺠﻭﺩ ﻀﻤﻥ ﻓﻬﺭﺱ ﺍﻟﻭﻴﻨﺩﻭﺯ ﻭﻻﺴﺘﺩﻋﺎﺀ ﻫﺫﺍ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻤﻥ ﺒﺭﻨﺎﻤﺞ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴـﺔ ﻓـﻲ‬
‫ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ‪:‬‬
‫; )‪WinExec('C:\Windows\Calc.exe' ,Sw_Show‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺈﻅﻬﺎﺭ ﺒﺘﺸﻐﻴل ﺒﺭﻨﺎﻤﺞ ﺍﻵﻟﺔ ﺍﻟﺤﺎﺴﺒﺔ ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﺘﻔﺘﺭﺽ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺃﻥ ﻤﺠﻠﺩ ﺍﻟﻭﻴﻨﺩﻭﺯ ﻋﻠﻰ ﺠﻬﺎﺯﻙ ﻫﻭ ‪ C:\Windows‬ﻭﻫﺫﺍ ﻴﺤﺼل ﺒﺸﻜل ﺍﻓﺘﺭﺍﻀـﻲ‬
‫ﻋﻨﺩ ﺘﻨﺼﻴﺏ ‪ Windows 98‬ﻭ‪ Windows Me‬ﺃﻤﺎ ﺍﻟﻔﻬﺭﺱ ﺍﻻﻓﺘﺭﺍﻀﻲ ﻟــ ‪ Windows 2000‬ﻭ ‪Windows‬‬
‫‪ Xp‬ﻓﻬﻭ ‪ C:\Win32‬ﻭﻜﻤﺎ ﺘﻌﻠﻡ ﻴﻤﻜﻥ ﻟﻠﻤﺴﺘﺨﺩﻡ ﺘﻐﻴﺭ ﻫﺫﻩ ﺍﻟﻔﻬﺎﺭﺱ ﺃﺜﻨﺎﺀ ﺘﻨﺼﻴﺏ ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ﻟﺫﻟﻙ ﺘﺴﺘﺨﺩﻡ ﻋـﺎﺩﺓ‬
‫‪GetWindowsDirectoy‬‬ ‫ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ GetWindowsDirectory‬ﻟﻠﻭﺼﻭل ﺇﻟﻰ ﻓﻬﺭﺱ ﻨﻅﺎﻡ ﺍﻟﺘـﺸﻐﻴل ﻤﺜـﺎل ‪:‬‬
‫;)‪ (p,200‬ﺤﻴﺙ ‪ p‬ﻤـﻥ ﺍﻟﻨـﻭﻉ ‪ Pchar‬ﻭﺴـﻴﻜﻭﻥ ﻓﻴـﻪ ﺍﺴـﻡ ﻤﺠﻠـﺩ ﺍﻟﻭﻴﻨـﺩﻭﺯ ) ﻻﺘـﻨﺱ ﺍﺴـﺘﺨﺩﺍﻡ ﺍﻟﺘﻌﻠﻴﻤـﺔ‬
‫)‪ GetMem(p,200‬ﻗﺒل ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﻭﺍﻟﺘﻌﻠﻴﻤﺔ )‪ FreeMem(p,200‬ﺒﻌﺩﻫﺎ ‪.‬‬
‫‪ 2‬ـ ﺘﺸﻐﻴل ﻤﻠﻑ ﺘﺎﺒﻊ ﻟﺒﺭﻨﺎﻤﺞ ﺁﺨﺭ ﻤﻥ ﺒﺭﻨﺎﻤﺞ ‪:‬‬
‫ﺒﻘﺭﺽ ﺃﻨﻙ ﺘﺭﻴﺩ ﻤﻥ ﺒﺭﻨﺎﻤﺠﻙ ﺃﻥ ﻴﺸﻐل ﺒﺭﻨﺎﻤﺞ ﻤﺎﻴﻜﺭﻭﺴﻭﻓﺕ ﻭﻭﺭﺩ ) ‪ ( Microsoft Word‬ﻭﻴﻌﺭﺽ ﺃﺤﺩ ﺍﻟﻤﻠﻔﺎﺕ‬
‫ﻟﺘﺤﻘﻴﻕ ﺫﻟﻙ ﺍﺴﺘﺨﺩﻡ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻻ ﺍﻟﻭﺤﺩﺓ ‪ ShellApi‬ﺇﻟﻰ ﺍﻟﻘﺴﻡ ‪ Uses‬ﻭﻤﻥ ﺜﻡ ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ‪.‬‬
‫ﺃﻀﻑ ﺃﻭ ﹰ‬
‫; )‪shellapi.ShellExecute(0 ,'Open','C:\My Documents\Test.doc',Nil,Nil,0‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﻔﺘﺢ ﺍﻟﻤﻠﻑ ‪ Test.doc‬ﺍﻟﻤﻭﺠﻭﺩ ﻓﻲ ﺍﻟﻤﺠﻠﺩ ‪. My Document‬‬
‫ﺇﺫﺍ ﺃﺭﺩﺕ ﻤﻥ ﺒﺭﻨﺎﻤﺠﻙ ﻓﺘﺢ ﺍﻟﻤﻠﻑ ﻭﻁﺒﺎﻋﺘﻪ ﻤﺒﺎﺸﺭﺓ ﺍﺴﺘﺒﺩل ﺍﻟﻭﺴﻴﻁ '‪ 'Open‬ﺒﺎﻟﻭﺴﻴﻁ '‪. 'Print‬‬
‫‪187‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺎﻟﻌﻭﺩﺓ ﺇﻟﻰ ﺒﻴﺌﺔ ﻭﻴﻨﺩﻭﺯ ﻟﻤﻌﺭﻓﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻻﻓﺘﺭﺍﻀﻲ ﺍﻟﺫﻱ ﺘﺴﺘﺨﺩﻤﻪ ﻟﻔﺘﺢ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﺍﻟﻤﻠﻔﺎﺕ ﻭﻤـﻥ‬
‫ﺜﻡ ﺘﻘﻭﻡ ﺒﺘﺸﻐﻴل ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻓﺘﺢ ﺍﻟﻤﻠﻑ ﺒﺩﺍﺨﻠﻪ ﻓﺈﺫﺍ ﺍﺨﺘﺭﺕ ﺍﺴﺘﺨﺩﻤﺕ ﻓﻲ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﻤﻠﻑ ‪ C:\Mypicture.jpg‬ﺴﺘﻘﻭﻡ‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺎﻟﺒﺤﺙ ﻋﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻻﻓﺘﺭﺍﻀﻲ ﺍﻟﺫﻱ ﻴﻔﺘﺢ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﺼﻭﺭ ﻓﻘﺩ ﻴﻜﻭﻥ ﻓﻭﺘﻭﺸﻭﺏ ﺃﻭ ‪Internet‬‬
‫‪. Explorer‬‬
‫ـ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺴﺎﺒﻘﺔ ﻟﻔﺘﺢ ﻤﺠﻠﺩ ﻤﺎ ‪:‬‬
‫ﺇﺫﺍ ﺃﺭﺩﺕ ﻓﺘﺢ ﻤﺠﻠﺩ ﻤﺎ ﻓﻲ ﻤﺴﺘﻜﺸﻑ ﻭﻴﻨﺩﻭﺯ ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; )‪shellapi.ShellExecute(0 ,'Open','C:\My Documents',Nil,Nil,0‬‬
‫ﺘﻘﻭﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺴﺎﺒﻘﺔ ﺒﻔﺘﺢ ﻤﺠﻠﺩ ‪. C:\My Document‬‬

‫‪188‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺠﻠﺴﺔ ‪27‬‬
‫ﺒﺭﻨﺎﻤﺞ ﺍﻟﻤﻔﻜﺭﺓ ‪:‬‬
‫ﺴﻨﻘﻭﻡ ﺍﻵﻥ ﺒﻜﺘﺎﺒﺔ ﺒﺭﻨﺎﻤﺞ ﻴﺸﺎﺒﻪ ﺒﺭﻨﺎﻤﺞ ﺍﻟﻤﻔﻜﺭﺓ ﻓﻲ ﻭﻴﻨﺩﻭﺯ ) ‪ ( Notepad‬ﻭﻴﺨﺘﻠﻑ ﻋﻨﻪ ﺒﺄﻨﻪ ﺴﻴﺘﻌﺎﻤل ﻤﻊ ﻤﻠﻔﺎﺕ‬
‫ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Rtf‬ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺍﻟﻤﻠﻔﺎﺕ ‪ ، Txt‬ﻜﻤﺎ ﺃﻨﻪ ﺴﻴﻜﻭﻥ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ MDI‬ﺒﺤﻴﺙ ﻴﻤﻜﻨﻨﺎ ﺃﻥ ﻨﻔﺘﺢ ﺃﻜﺜﺭ ﻤﻥ ﻤﻠﻑ‬
‫ﺒﻨﻔﺱ ﺍﻟﻭﻗﺕ ‪.‬‬
‫ﺃﺒﺩﺃ ﻤﺸﺭﻭﻋﹰﺎ ﺠﺩﻴﺩﹰﺍ ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﺍﻟﻌﻨﺼﺭ ‪ MainMenu‬ﻭﺍﻟﻌﻨﺼﺭ ‪ OpenDialog‬ﻭﺃﻋﻁ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ﻟﻠﻌﻨﺎﺼﺭ‬
‫‪:‬‬
‫ﻋﻨﺼﺭ ﺍﻟﻨﻤﻭﺫﺝ ‪: Form1‬‬
‫ﺍﻟﻘﻴﻤﺔ‬ ‫ﺍﻟﺨﺎﺼﺔ‬
‫‪bdRightToLeft‬‬ ‫‪BiDiMode‬‬
‫ﺒﺭﻨﺎﻤﺞ ﺍﻟﻤﻔﻜﺭﺓ‬ ‫‪Caption‬‬
‫‪fsMDIForm‬‬ ‫‪FormStyle‬‬
‫‪MainForm‬‬ ‫‪Name‬‬
‫‪poDesktopCenter‬‬ ‫‪Position‬‬
‫ﻋﻨﺼﺭ ﺍﻟﻘﺎﺌﻤﺔ ‪ : MainMenu‬ﺃﻨﺸﺊ ﻓﻲ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﺍﻟﻘﺎﺌﻤﺔ ) ﻤﻠﻑ ( ﻭﺍﻟﻘﺎﺌﻤﺔ ) ﺇﻁﺎﺭ (‪:‬‬
‫ﺃﻋﻁ ﺍﻟﺯﺭ )ﻤﻠﻑ ( ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ Name‬ﺍﻟﻘﻴﻤﺔ ‪ FileMenu‬ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﺍﻷﻭﺍﻤﺭ ) ﺍﻷﺯﺭﺍﺭ ( ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﺔ ‪Shortcut‬‬ ‫ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﺔ ‪Name‬‬ ‫ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﺔ ‪Caption‬‬
‫‪New‬‬ ‫&ﺠﺩﻴﺩ‬
‫‪OpenFile‬‬ ‫&ﻓﺘﺢ‬
‫‪CloseApp‬‬ ‫&ﺨﺭﻭﺝ‬
‫ﺃﻋﻁ ﺍﻟﺯﺭ )ﺇﻁﺎﺭ( ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ Name‬ﺍﻟﻘﻴﻤﺔ ‪ Window1‬ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﺍﻷﻭﺍﻤﺭ ) ﺍﻷﺯﺭﺍﺭ ( ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﺔ ‪Shortcut‬‬ ‫ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﺔ ‪Name‬‬ ‫ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﺔ ‪Caption‬‬
‫ﺘﺭﺘﻴﺏ‬
‫ﺘﺘﺎﻟﻲ‬
‫‪-‬‬
‫ﺍﻟﻌﻨﺼﺭ ‪: OpenDialog1‬‬
‫‪.rtf‬‬ ‫‪DefaultExt‬‬
‫ﻀﻊ ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ Filter‬ﺍﻷﺴﻁﺭ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬ ‫‪Filter‬‬
‫‪Filter Name‬‬ ‫‪Filter‬‬
‫‪Rich Text‬‬ ‫‪*.rtf‬‬
‫‪Text File‬‬ ‫‪*.Txt‬‬
‫‪All File‬‬ ‫*‪*.‬‬
‫ﺍﺤﻔﻅ ﺍﻟﻭﺤﺩﺓ ﺒﺎﺴﻡ ‪ Main.pas‬ﻭﺍﻟﻤﺸﺭﻭﻉ ﺒﺎﺴﻡ ‪. MyTextEditor.Dpr‬‬

‫‪189‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺃﻀﻑ ﺇﻟﻰ ﺍﻟﻤﺸﺭﻭﻉ ﻨﻤﻭﺫﺠﹰﺎ ﺠﺩﻴﺩﹰﺍ ‪ FileÆ New Æ Form‬ﻭﺃﻀﻑ ﺃﻟﻴﻪ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﺘﺎﻟﻴﺔ ‪ :‬ﻋﻨﺼﺭ ‪MainMenu‬‬
‫ﻭ ﻋﻨﺼﺭ ‪ RichText‬ﻤﻥ ﺍﻟﺼﻔﺤﺔ ‪ Win32‬ﻭﻋﻨﺼﺭ ‪ SaveDialog‬ﻭ ‪ PrintDialog‬ﻭﻋﻨﺼﺭ ‪.FontDialog‬‬
‫ﺃﻋﻁ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺠﺩﻴﺩ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪bdRightToLeft‬‬ ‫‪BiDiMode‬‬
‫‪fsMDIChild‬‬ ‫‪FormStyle‬‬
‫‪EditForm‬‬ ‫‪Name‬‬
‫ﺃﻨﺸﺊ ﻓﻲ ﺍﻟﻌﻨﺼﺭ ‪ MainMenu1‬ﺜﻼﺙ ﻗﻭﺍﺌﻡ ﺒﺎﺴﻡ ) ﻤﻠﻑ ( ﻭ ) ﺘﺤﺭﻴﺭ ( ﻭ ) ﺘﻨﺴﻴﻕ ( ﻭﺃﻨﺸﺊ ﻓﻲ ﻜل ﻤﻨﻬﺎ ﺃﺯﺭﺍﺭ‬
‫ﺤﺴﺏ ﺍﻟﺠﺩﻭل ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫ﺃﻋﻁ ﺍﻟﺯﺭ )ﻤﻠﻑ ( ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ Name‬ﺍﻟﻘﻴﻤﺔ ‪ FileMenu‬ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﺍﻷﻭﺍﻤﺭ ) ﺍﻷﺯﺭﺍﺭ ( ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﺔ ‪Shortcut‬‬ ‫ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﺔ ‪Name‬‬ ‫ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﺔ ‪Caption‬‬
‫‪New‬‬ ‫&ﺠﺩﻴﺩ‬
‫‪OpenFile‬‬ ‫&ﻓﺘﺢ‬
‫‪Ctrl+S‬‬ ‫‪Save‬‬ ‫ﺤﻔﻅ‬
‫‪SaveAs‬‬ ‫ﺤﻔﻅ ﺒﺎﺴﻡ‬
‫‪PrintFile‬‬ ‫ﻁﺒﺎﻋﺔ‬
‫‪CloseFile‬‬ ‫ﺇﻏﻼﻕ‬
‫‪CloseAll‬‬ ‫&ﺨﺭﻭﺝ‬
‫ﺃﻋﻁ ﺍﻟﺯﺭ )ﺘﺤﺭﻴﺭ ( ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ Name‬ﺍﻟﻘﻴﻤﺔ ‪ EditMenu‬ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﺍﻷﻭﺍﻤﺭ ) ﺍﻷﺯﺭﺍﺭ ( ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﺔ ‪Shortcut‬‬ ‫ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﺔ ‪Name‬‬ ‫ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﺔ ‪Caption‬‬
‫‪Ctrl+C‬‬ ‫‪CopyText‬‬ ‫ﻨﺴﺦ‬
‫‪Ctrl+X‬‬ ‫‪Cuttext‬‬ ‫ﻗﺹ‬
‫‪Ctrl+V‬‬ ‫‪PasteText‬‬ ‫ﻟﺼﻕ‬
‫‪Ctrl+A‬‬ ‫‪SelectAll‬‬ ‫ﺘﺤﺩﻴﺩ ﺍﻟﻜل‬
‫ﺃﻋﻁ ﺍﻟﺯﺭ )ﺘﻨﺴﻴﻕ ( ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ Name‬ﺍﻟﻘﻴﻤﺔ ‪ EditMenu‬ﻭﺃﻀﻑ ﺇﻟﻴﻪ ﺍﻷﻭﺍﻤﺭ ) ﺍﻷﺯﺭﺍﺭ ( ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﺔ ‪Shortcut‬‬ ‫ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﺔ ‪Name‬‬ ‫ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﺔ ‪Caption‬‬
‫‪Left1‬‬ ‫ﻤﺤﺎﺫﺍﺓ ﺇﻟﻰ ﺍﻟﻴﺴﺎﺭ‬
‫‪Right1‬‬ ‫ﻤﺤﺎﺫﺍﺓ ﺇﻟﻰ ﺍﻟﻴﻤﻴﻥ‬
‫‪Center1‬‬ ‫ﻤﺤﺎﺫﺍﺓ ﺇﻟﻰ ﺍﻟﻭﺴﻁ‬
‫‪-‬‬
‫‪WordWrap1‬‬ ‫ﺍﻟﺘﻔﺎﻑ ﺘﻠﻘﺎﺌﻲ‬
‫‪Font1‬‬ ‫ﺨﻁ‬
‫ﺤﺩﺩ ﺍﻷﺯﺭﺍﺭ ﺍﻟﺜﻼﺜﺔ ﺍﻷﻭﻟﻰ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ﺘﻨﺴﻴﻕ ﻭﺃﻋﻁﻬﺎ ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ RadioItem‬ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻫﺫﺍ ﺴـﻴﺠﻌﻠﻬﺎ ﺘﺒـﺩﻭ‬
‫‪190‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻜﺄﺯﺭﺍﺭ ﺍﻟﺭﺍﺩﻴﻭ ﻭﻻ ﻴﻤﻜﻥ ﺍﺨﺘﻴﺎﺭ ﺇﻻ ﻭﺍﺤﺩ ﻤﻨﻬﺎ ﻓﻲ ﺫﺍﺕ ﺍﻟﻭﻗﺕ ‪.‬‬
‫ﺃﻋﻁ ﺍﻟﻌﻨﺼﺭ ‪ Richedit1‬ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪alClient‬‬ ‫‪Align‬‬
‫‪Editor‬‬ ‫‪Name‬‬
‫ﺃﻋﻁ ﺍﻟﻌﻨﺼﺭ ‪ Savedialog1‬ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪.rtf‬‬ ‫‪DefaultExt‬‬
‫ﻀﻊ ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ Filter‬ﺍﻷﺴﻁﺭ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬ ‫‪Filter‬‬
‫‪Filter Name‬‬ ‫‪Filter‬‬
‫‪Rich Text‬‬ ‫‪*.rtf‬‬
‫‪Text File‬‬ ‫‪*.Txt‬‬
‫_ ﺍﺤﻔﻅ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺴﻤﻲ ﺍﻟﻭﺤﺩﺓ ﺍﻟﺠﺩﻴﺩﺓ ﺒﺎﺴﻡ ‪EditText.pas‬‬
‫ـ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺠﺩﻴﺩ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﻤﻠﻑ ﻟﻠﻨﻤﻭﺫﺝ ‪: MainForm‬‬
‫;)‪TEditForm.Create(Self‬‬
‫ﺍﻟﻭﺴﻴﻁ ‪ Self‬ﻭﺴﻴﻁ ﻤﻌﺭﻑ ﻴﻌﻭﺩ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺫﻱ ﻴﻁﻠﺏ ﻓﻴﻪ ﻫﺫﺍ ﺍﻟﻭﺴﻴﻁ ‪.‬‬
‫‪ -‬ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺠﺩﻴﺩ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﻤﻠﻑ ﻟﻠﻨﻤﻭﺫﺝ ‪:EditForm‬‬
‫;)‪TEditForm.Create(Self‬‬

‫‪ -‬ﻓﻲ ﺍﻟﺤﺩﺙ ‪ OnClose‬ﻟﻠﻨﻤﻭﺫﺝ ‪ EditForm‬ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫; ‪Action := CaFree‬‬
‫ﺘﻤﻜﻨﻨﺎ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﻤﻥ ﺇﻏﻼﻕ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻻﺒﻥ ﻭﺘﻜﻭﻥ ﻗﻴﻤﺘﻬﺎ ﺍﻻﻓﺘﺭﺍﻀﻴﺔ ﻓﻲ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻻﺒﻥ ﻫﻲ ‪ CaMinimized‬ﺤﻴﺙ‬
‫ﻻ ﻤﻥ ﺇﻏﻼﻗﻪ ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺇﻏﻼﻕ ‪.‬‬
‫ﻴﺘﻡ ﺘﺼﻐﻴﺭ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻻﺒﻥ ﺒﺩ ﹰ‬
‫ـ ﻋﻨﺩﻤﺎ ﻴﻘﻭﻡ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺒﺎﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﻓﺘﺢ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ) ﺴﻭﺍﺀ ﻓﻲ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻷﺏ ﺃﻭ ﺍﻻﺒﻥ ( ﺴﻨﻘﻭﻡ ﺒﺈﻨﺸﺎﺀ ﻨﺎﻓـﺫﺓ‬
‫ﺍﺒﻥ ﺠﺩﻴﺩﺓ ﻭﺴﻨﻘﻭﻡ ﺘﺤﻤﻴل ﺍﻟﻤﻠﻑ ﺇﻟﻰ ﺍﻟﻌﻨﺼﺭ ‪ ، ( TrichEdit ) Editor‬ﻜﻤﺎ ﺴﻨﻐﻴﺭ ﻋﻨﻭﺍﻥ ﺍﻟﻨﺎﻓـﺫﺓ ﻟﻴﻜـﻭﻥ ﺒﺎﺴـﻡ‬
‫ﺍﻟﻤﻠﻑ ﺍﻟﺫﻱ ﻨﻔﺘﺤﻪ ‪.‬‬
‫ﻗﺒل ﺍﻟﺒﺩﺀ ﺒﻜﺘﺎﺒﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺨﺎﺼﺔ ﺒﻔﺘﺢ ﻤﻠﻑ ﺴﻨﻘﻭﻡ ﺒﺘﻌﺭﻴﻑ ﻤﺎ ﻴﻠﻲ ‪:‬‬
‫ـ ﻋﺭﻑ ﺍﻟﻤﺘﺤﻭل ‪ PathName‬ﻤﻥ ﺍﻟﻨﻭﻉ ‪ String‬ﻓﻲ ﺍﻟﻘﺴﻡ ‪ Private‬ﻟﻠﻭﺤﺩﺓ ‪. EditText‬‬
‫_ ﻋﺭﻑ ﺍﻟﺜﺎﺒﺕ ‪:‬‬
‫‪const‬‬
‫;'ﺒﺩﻭﻥ ﻋﻨﻭﺍﻥ' = ‪DefaultFileName‬‬
‫_ ﺃﻀﻑ ﺘﻌﺭﻴﻑ ﺍﻹﺠﺭﺍﺀ ﺍﻟﺘﺎﻟﻲ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ public‬ﻟﻠﻭﺤﺩﺓ ‪: EditText‬‬
‫;)‪Procedure Open(const AFileName: string‬‬

‫ـ ﻀﻊ ﻤﺅﺸﺭ ﻟﻭﺤﺔ ﺍﻟﻤﻔﺎﺘﻴﺢ ﻋﻨﺩ ﺍﻟﺴﻁﺭ ﺍﻟﺴﺎﺒﻕ ﻭﺍﻀﻐﻁ ﺍﻷﺯﺭﺍﺭ ‪ Ctrl+Alt+C‬ﺴﻴﺘﻡ ﻋﻨﺩﻫﺎ ﺇﻀﺎﻓﺔ ﺍﻟﺘﺎﺒﻊ ﺍﻟـﺴﺎﺒﻕ‬
‫ﺇﻟﻰ ﺍﻟﻘﺴﻡ ‪ ، Implementation‬ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺠﺴﻡ ﺍﻟﺘﺎﺒﻊ ‪:‬‬
‫;‪PathName := AFileName‬‬
‫‪191‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫;)‪Caption := ExtractFileName(AFileName‬‬
‫‪with Editor do‬‬
‫‪begin‬‬
‫;)‪Lines.LoadFromFile(PathName‬‬
‫;‪SelStart := 0‬‬
‫;‪Modified := False‬‬
‫;‪end‬‬
‫ﺍﻟﺘﺎﺒﻊ )‪ : ExtractFileName ( AFileName‬ﻴﻌﻴﺩ ﺍﺴﻡ ﺍﻟﻤﻠﻑ ﻤﻊ ﺍﻤﺘﺩﺍﺩﻩ ﻭﺒﺩﻭﻥ ﺫﻜﺭ ﺍﻟﻤﺴﺎﺭ ‪.‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻀﻤﻥ ﺍﻟﻜﺘﻠﺔ ;‪ With Editor Do begin …. End‬ﺘﻜﺎﻓﺊ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ‪:‬‬
‫;)‪Editor.Lines.LoadFromFile(PathName‬‬
‫;‪Editor.SelStart := 0‬‬
‫;‪Editor .Modified := False‬‬
‫ﺃﻱ ﺃﻨﻨﺎ ﻨﺴﺘﺨﺩﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ Width‬ﻟﻨﺘﺨﻠﺹ ﻤﻥ ﺫﻜﺭ ﺍﻟﻌﻨﺼﺭ ﻓﻲ ﻜل ﺴﻁﺭ ﻤﻥ ﺴﻁﻭﺭ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪.‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ Editor.selstart := 0‬ﻀﻊ ﻤﺅﺸﺭ ﺍﻟﺘﺤﺭﻴﺭ ﻟﻠﻌﻨﺼﺭ ‪ Editor‬ﻓﻲ ﺒﺩﺍﻴﺔ ﺍﻟﻤﻠﻑ ‪.‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ‪ Editorr.Modified‬ﺘﺄﺨﺫ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻓﻲ ﺤﺎل ﻋﺩل ﺍﻟﻤﺴﺘﺨﺩﻡ ﻓﻲ ﺃﻱ ﻨﻘﻁﺔ ﻤﻥ ﺍﻟﻤﻠﻑ ﺍﻟﻤﻔﺘﻭﺡ ‪.‬‬
‫ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﻓﺘﺢ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﻤﻠﻑ ﻟﻠﻨﻤﻭﺫﺝ ‪ MainForm‬ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪If OpenDialog1.Execute Then‬‬
‫; ) ‪TeditForm.Create(Self).Open(OpenDialog1.FileName‬‬
‫ﺘﻘﻭﻡ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﻌﺩ ‪ Then‬ﺒﺈﻨﺸﺎﺀ ﻨﺎﻓﺫﺓ ﺠﺩﻴﺩﺓ ﻭﻤﻥ ﺜﻡ ﻁﻠﺏ ﺘﻨﻔﻴﺫ ﺍﻹﺠﺭﺍﺀ ‪ Open‬ﺍﻟﺫﻱ ﻜﺘﺒﻨﺎﻩ ﺴﺎﺒﻘﹰﺎ ‪.‬‬
‫ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﻓﺘﺢ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﻤﻠﻑ ﻟﻠﻨﻤﻭﺫﺝ ‪ EditForm‬ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫; ‪MainForm.Openfile.Click‬‬
‫_ ﻋﻨﺩ ﺇﻨﺸﺎﺀ ﻤﻠﻑ ﺠﺩﻴﺩ ﺴﻨﻌﻁﻲ ﻋﻨﻭﺍﻥ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﻲ ﺘﻔﺘﺢ ﻫﺫﺍ ﺍﻟﻤﻠﻑ ﺍﺴﻡ ﺍﻓﺘﺭﺍﻀﻲ ﻟﺫﻟﻙ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓـﻲ‬
‫ﺍﻟﺤﺩﺙ ‪ OnCreate‬ﻟﻠﻨﻤﻭﺫﺝ ‪: EditForm‬‬
‫;‪PathName := DefaultFileName‬‬
‫ﺃﻱ ﺃﻥ ﺍﻟﻤﺘﺤﻭل ‪ PathName‬ﺴﻴﺩل ﻋﻠﻰ ﺍﻻﺴﻡ ﺍﻻﻓﺘﺭﺍﻀﻲ ﻟﻠﻤﻠﻑ ﺍﻟﺠﺩﻴﺩ ‪.‬‬
‫ﺤﻔﻅ ﺍﻟﻤﻠﻑ ‪:‬‬
‫ﺍﻟﻌﻨﺼﺭ ‪ Editor‬ﻭﻫﻭ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ TRichEdit‬ﻴﻘﻭﻡ ﺒﺤﻔﻅ ﺍﻟﻤﻠﻔﺎﺕ ﺒﺎﻤﺘﺩﺍﺩ ‪ rtf‬ﻓﻘﻁ ﻭﻋﻠﻰ ﺒﺭﻨﺎﻤﺠﻨـﺎ ﺤﻔـﻅ ﺍﻟﻤﻠـﻑ‬
‫ﺒﺎﻤﺘﺩﺍﺩ ‪ rtf‬ﺃﻭ ﺒﺎﻻﻤﺘﺩﺍﺩ ‪ Txt‬ﻟﺫﻟﻙ ﺴﻨﺴﺘﺨﺩﻡ ﻤﺘﺤﻭل ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Tstrings‬ﻟﻨﻘل ﺃﺴﻁﺭ ﺍﻟﻌﻨﺼﺭ ‪ Editor‬ﺇﻟﻴﻪ ﻭﻤﻥ ﺜﻡ‬
‫ﺤﻔﻅ ﺃﺴﻁﺭ ﻫﺫﺍ ﺍﻟﻤﺘﺤﻭل ﻋﻠﻰ ﻤﻠﻑ ÷ﺫﺍ ﻁﺒﻌﹰﺎ ﻋﻨﺩ ﺍﺨﺘﻴﺎﺭ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺤﻔﻅ ﺍﻟﻤﻠﻑ ﺒﺎﻻﻤﺘﺩﺍﺩ ‪. .Txt‬‬
‫ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺤﻔﻅ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﻤﻠﻑ ﻟﻠﻨﻤﻭﺫﺝ ‪ EditForm‬ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫;‪var S: Tstringlist‬‬
‫‪begin‬‬
‫‪if PathName = DefaultFileName then‬‬
‫)‪SaveAsClick(Sender‬‬
‫‪else‬‬
‫‪begin‬‬
‫‪if uppercase(rightstr(PathName,3)) = uppercase( 'rtf' ) then‬‬
‫‪Editor.Lines.SaveToFile(PathName) else‬‬
‫‪try‬‬
‫‪192‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫; ‪S:=Tstringlist.Create‬‬
‫) ‪s.AddStrings(Editor.Lines‬‬
‫‪finally‬‬
‫; )‪s.SaveToFile(PathName‬‬
‫;‪end‬‬
‫;‪Editor.Modified := False‬‬
‫;‪end‬‬
‫ﺘﻘﻭﻡ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺴﺎﺒﻘﺔ ﺒﻔﺤﺹ ﺍﻟﻤﺘﺤﻭل ‪ PathName‬ﻓﺈﺫﺍ ﻜﺎﻨﺕ ﻗﻴﻤﺘﻪ ﻫﻲ ﺍﻟﻘﻴﻤﺔ ﺍﻻﻓﺘﺭﺍﻀـﻴﺔ ﺃﻱ "ﺒـﺩﻭﻥ ﻋﻨـﻭﺍﻥ"‬
‫ﻴﻌﻨﻲ ﺃﻥ ﺍﻟﻤﻠﻑ ﺠﺩﻴﺩ ﻭﻟﻡ ﻴﺘﻡ ﺤﻔﻅﻪ ﺴﺎﺒﻘﹰﺎ ‪،‬ﻤﻤﺎ ﻴﺴﺘﺩﻋﻲ ﻁﻠﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﻲ ﺘﻨﻔﺫ ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺤﻔﻅ ﺒﺎﺴﻡ ﺃﻤﺎ ﺃﺫﺍ‬
‫ﻜﺎﻥ ‪ PathName‬ﻻ ﻴﺴﺎﻭﻱ ﺍﻟﻘﻴﻤﺔ ﺍﻻﻓﺘﺭﺍﻀﻴﺔ ﻤﻤﺎ ﻴﺩل ﺃﻥ ﻟﻠﻤﻠﻑ ﻤﺴﺎﺭ ﻭﺃﺴﻡ ﻤﺤﺩﺩﻴﻥ ﻭﺴﻨﺩﺭﺱ ﻫﻨﺎ ﺍﺤﺘﻤﺎﻟﻴﻥ ‪:‬‬
‫)‬ ‫‪ 1‬ـ ﺃﻥ ﻴﻜﻭﻥ ﺍﻤﺘﺩﺍﺩ ﺍﻟﻤﻠﻑ ﻫﻭ ‪ rtf‬ﻭﺒﺎﻟﺘـﺎﻟﻲ ﻨﻨﻔـﺫ ﺍﻟﺘﻌﻠﻴﻤـﺔ )‪Editor.Lines.SaveToFile(PathName‬‬
‫ﻭﺍﻀﺢ ﺃﻥ ﺍﻟﺸﺭﻁ ﺍﻟﺫﻱ ﻴﺴﺒﻕ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﻴﻘﺎﺭﻥ ﺍﻷﺤﺭﻑ ﺍﻟﺜﻼﺜﺔ ﺍﻷﺨﻴﺭﺓ ﻓﻲ ﺍﻟﻤﺘﺤﻭل ‪ PathName‬ﻤﻊ ﺍﻟﻘﻴﻤﺔ '‪'rtf‬‬
‫ﺒﻌﺩ ﺘﺤﻭﻴل ﺍﻟﻘﻴﻤﺘﻴﻥ ﻋﻠﻰ ﺃﺤﺭﻑ ﻜﺒﻴﺭﺓ ‪.‬‬
‫‪ 2‬ـ ﺃﻥ ﻴﻜﻭﻥ ﺍﻤﺘﺩﺍﺩ ﺍﻟﻤﻠﻑ ﻫﻭ ‪ Txt‬ﻭﺒﺎﻟﺘﺎﻟﻲ ﻨﻨﺸﺊ ﺍﻟﻤﺘﺤﻭل ‪ S‬ﻤﻥ ﺍﻟﻨﻭﻉ ‪ TStringList‬ﻭﻨﻨﻘل ﺃﺴـﻁﺭ ﺍﻟﻌﻨـﺼﺭ‬
‫‪ Editor‬ﺇﻟﻴﻪ ﻭﻤﻥ ﺜﻡ ﻨﺤﻔﻅﻪ ‪ ،‬ﺜﻡ ﻨﻌﻴﺩ ﺍﻟﻘﻴﻤﺔ ‪ False‬ﻟﻠﺨﺎﺼﺔ ‪ Editor.Modified‬ﺃﻱ ﺃﻥ ﺍﻟﻤﻠﻑ ﻟﻡ ﻴﺘﻡ ﺘﻌﺩﻴﻠﻪ ﺒﻌـﺩ‬
‫ﺍﻟﺤﻔﻅ ﺍﻷﺨﻴﺭ ‪.‬‬
‫ﺤﻔﻅ ﺍﻟﻤﻠﻑ ﺒﺎﺴﻡ ‪:‬‬
‫ـ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺤﻔﻅ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﻤﻠﻑ ﻟﻠﻨﻤﻭﺫﺝ ‪: EditForm‬‬
‫;‪SaveDialog1.FileName := PathName‬‬
‫‪if SaveDialog1.Execute then‬‬
‫‪begin‬‬
‫;‪PathName := SaveDialog1.FileName‬‬

‫;)‪Caption := ExtractFileName(PathName‬‬
‫;)‪SaveClick(Sender‬‬
‫;‪end‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻷﻭﻟﻰ ﺘﺠﻌل ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ﺤﻔﻅ ﺒﺎﺴﻡ ﺃﻥ ﻴﻅﻬﺭ ﺍﻻﺴﻡ ﺍﻟﺤﺎﻟﻲ ﻟﻠﻤﻠﻑ ﻜﺎﺴﻡ ﺍﻓﺘﺭﺍﻀﻲ ﻭﺍﻟﺘﻌﻠﻴﻤـﺎﺕ ﺍﻟﺘﺎﻟﻴـﺔ‬
‫ﺘﻘﻭﻡ ﺒﻭﻀﻊ ﺍﺴﻡ ﺍﻟﻤﻠﻑ ﺍﻟﺫﻱ ﺍﺨﺘﺎﺭﻩ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻓﻲ ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ﺤﻔﻅ ﺒﺎﺴﻡ ﻓـﻲ ﺍﻟﻤﺘﺤـﻭل ‪ PathName‬ﻭﺘﻐﻴـﺭ‬
‫ﻋﻨﻭﺍﻥ ﺍﻟﻨﺎﻓﺫﺓ ﻟﻴﺄﺨﺫ ﺍﺴﻡ ﺍﻟﻤﻠﻑ ﺍﻟﺠﺩﻴﺩ ‪.‬ﻭﻤﻥ ﺜﻡ ﺘﺴﺘﺩﻋﻲ ﺍﻹﺠﺭﺍﺀ ) ‪ SaveClick ( Sender‬ﻟﻴﺘﻡ ﺤﻔﻅ ﺍﻟﻤﻠﻑ ﻭﻓـﻕ‬
‫ﺍﻻﻤﺘﺩﺍﺩ ﺍﻟﺫﻱ ﺍﺨﺘﺎﺭﻩ ﺍﻟﻤﺴﺘﺨﺩﻡ ‪.‬‬
‫ﺇﻏﻼﻕ ﺍﻟﻤﻠﻑ ‪:‬‬
‫ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺇﻏﻼﻕ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﻤﻠﻑ ﻟﻠﻨﻤﻭﺫﺝ ‪: EditForm‬‬
‫;‪Close‬‬
‫ﺍﻟﺨﺭﻭﺝ ﻤﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪:‬‬
‫ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺨﺭﻭﺝ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﻤﻠﻑ ﻟﻠﻨﻤﻭﺫﺝ‪:MainForm‬‬
‫;‪Close‬‬

‫‪193‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺨﺭﻭﺝ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﻤﻠﻑ ﻟﻠﻨﻤﻭﺫﺝ ‪: EditForm‬‬
‫; ‪MainForm.CloseApp.Click‬‬
‫ﻴﺘﻡ ﺇﻏﻼﻕ ﺠﻤﻴﻊ ﺍﻟﻨﻭﺍﻓﺫ ﺍﻷﺒﻨﺎﺀ ﻋﻨﺩ ﺇﻏﻼﻕ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻷﺏ ‪.‬‬
‫ـ ﺃﻤﺎﻤﻨﺎ ﺍﻵﻥ ﻤﺸﻜﻠﺔ ﺠﺩﻴﺩﺓ ‪ ،‬ﺍﻓﺭﺽ ﺃﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻗﺩ ﻋﺩل ﺍﻟﻤﻠﻑ ﺜﻡ ﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺇﻏﻼﻕ ﺒﺩﻭﻥ ﺤﻔﻅ ﺍﻟﻤﻠـﻑ ‪،‬‬
‫ﺴﻴﻘﻭﻡ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ ﺒﺈﻏﻼﻕ ﺍﻟﻤﻠﻑ ﺩﻭﻥ ﺤﻔﻅ ﻭﻟﺫﻟﻙ ﻋﻠﻴﻨﺎ ﺇﻅﻬﺎﺭ ﺭﺴﺎﻟﺔ ﺤﻭﺍﺭ ﺘﺴﺄل ﺍﻟﻤـﺴﺘﺨﺩﻡ ﺇﺫﺍ ﻜـﺎﻥ‬
‫ﻴﺭﻴﺩ ﺃﻥ ﻴﺤﻔﻅ ﺍﻟﻤﻠﻑ ﺃﻡ ﻻ ‪.‬‬
‫ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺤﺩﺙ ‪ OnCloseQuery‬ﻟﻠﻨﻤﻭﺫﺝ ‪: EditForm‬‬
‫‪Const‬‬
‫;'ﻫل ﺘﺭﻴﺩ ﺤﻔﻅ ﺍﻟﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺩﺨﻠﺔ ﻋﻠﻰ ﺍﻟﻤﻠﻑ' = ‪SWarningText‬‬
‫‪begin‬‬
‫‪if Editor.Modified then‬‬
‫‪begin‬‬
‫‪case MessageDlg(Format(SWarningText + #13 + '%s', [PathName]), mtConfirmation,‬‬
‫‪[mbYes, mbNo, mbCancel], 0) of‬‬
‫;)‪mrYes: SaveClick(Self‬‬
‫;‪mrCancel: CanClose := False‬‬
‫;‪end‬‬
‫;‪end‬‬
‫;‪end‬‬
‫ﻴﺘﻡ ﺘﻨﻔﻴﺫ ﺍﻟﺤﺩﺙ ‪ OnCloseQuery‬ﻋﻨﺩﻤﺎ ﻴﻀﻐﻁ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻠﻰ ﺯﺭ ﺇﻏﻼﻕ ﻭﻗﺒل ﺃﻥ ﻴﺘﻡ ﺇﻏﻼﻕ ﺍﻟﻨﻤﻭﺫﺝ ﻭﻴﺠﻭﺩ ﻤﻊ‬
‫ﻫﺫﺍ ﺍﻟﺤﺩﺙ ﺍﻟﻭﺴﻴﻁ ‪ CanClose‬ﻭﺍﻟﺫﻱ ﻴﺄﺨﺫ ﻗﻴﻤﺔ ﺍﻓﺘﺭﺍﻀﻴﺔ ‪، True‬ﻭﻋﻨﺩ ﺇﻋﻁﺎﺀﻩ ﺍﻟﻘﻴﻤﺔ ‪ False‬ﻴﺭﻓﺽ ﺍﻟﺒﺭﻨـﺎﻤﺞ‬
‫ﺇﻏﻼﻕ ﺍﻟﻨﺎﻓﺫﺓ ‪.‬‬
‫ﻨﻔﺤﺹ ﻋﻨﺩﻫﺎ ﺍﻟﻤﺘﺤﻭل ‪) Editor.Modified‬ﺍﻟﺫﻱ ﻴﺄﺨﺫ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﺇﺫﺍ ﻗﺎﻡ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺒـﺈﺠﺭﺍﺀ ﺃﻱ ﺘﻌـﺩﻴل ﻋﻠـﻰ‬
‫ﺍﻟﻤﻠﻑ ( ‪ ،‬ﻭﻋﻨﺩﻫﺎ ﻨﻅﻬﺭ ﺼﻨﺩﻭﻕ ﺤﻭﺍﺭ ﻴﺴﺄل ﺍﻟﻤﺴﺘﺨﺩﻡ ﺇﺫﺍ ﻜﺎﻥ ﻴﺭﻴﺩ ﺤﻔﻅ ﺍﻟﻤﻠﻑ ﻭﻫﺫﺍ ﺍﻟﺼﻨﺩﻭﻕ ﺫﻭ ﺜﻼﺙ ﺃﺯﺭﺍﺭ ‪:‬‬
‫‪ : Yes‬ﺇﺫﺍ ﻀﻐﻁ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻠﻰ ﻫﺫﺍ ﺍﻟﺯﺭ ﻓﺈﻨﻪ ﻴﺭﻴﺩ ﺤﻔﻅ ﺍﻟﻤﻠﻑ ﻭﻨﺴﺘﺩﻋﻲ ﻋﻨﺩﻫﺎ ﺍﻟﺘﺎﺒﻊ ‪. SaveClick‬‬
‫‪ : No‬ﺇﺫﺍ ﻀﻐﻁ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻠﻰ ﻫﺫﺍ ﺍﻟﺯﺭ ﻓﺈﻨﻪ ﻻ ﻴﺭﻴﺩ ﺤﻔﻅ ﺍﻟﻤﻠﻑ ﻭﺴﻴﺘﻡ ﺇﻏﻼﻕ ﺍﻟﻨﺎﻓﺫﺓ ‪.‬‬
‫‪ : Cancel‬ﺇﺫﺍ ﻀﻐﻁ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻠﻰ ﻫﺫﺍ ﺍﻟﺯﺭ ﻓﺈﻨﻪ ﻻ ﻴﺭﻴﺩ ﺇﻏﻼﻕ ﺍﻟﻤﻠﻑ ﻭﺒﺎﻟﺘﺎﻟﻲ ﻨﻐﻴﺭ ﻗﻴﻤﺔ ﺍﻟﻭﺴـﻴﻁ ‪CanClose‬‬
‫ﺇﻟﻰ ‪ False‬ﻭﺒﺎﻟﺘﺎﻟﻲ ﻟﻥ ﻴﺴﺘﺠﻴﺏ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻟﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺇﻏﻼﻕ ‪.‬‬
‫ﺍﻟﺭﻤﺯ ‪ #13‬ﻓﻲ ﺍﻟﺘﺎﺒﻊ ‪ MessageDlg‬ﻴﺠﻌل ﺍﺴﻡ ﺍﻟﻤﻠﻑ ﻴﻅﻬﺭ ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺜﺎﻨﻲ ﻤﻥ ﺍﻟﺭﺴﺎﻟﺔ ‪ ،‬ﻫﺫﺍ ﻴﻜﺎﻓﺊ ﻜﺘﺎﺒﺔ ﻨﺹ‬
‫ﺍﻟﺭﺴﺎﻟﺔ ﻭﻤﻥ ﺜﻡ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ‪ Enter‬ﻭﻤﻥ ﺜﻡ ﻜﺘﺎﺒﺔ ﺍﺴﻡ ﺍﻟﻤﻠﻑ ‪.‬‬
‫ﺒﺭﻤﺠﺔ ﺍﻟﻘﺎﺌﻤﺔ ﺘﺤﺭﻴﺭ ‪:‬‬
‫ـ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﻨﺴﺦ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﺘﺤﺭﻴﺭ ‪:‬‬
‫;‪Editor.CopyToClipboard‬‬
‫ـ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﻗﺹ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﺘﺤﺭﻴﺭ ‪:‬‬
‫;‪Editor.CutToClipboard‬‬
‫ـ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﻟﺼﻕ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﺘﺤﺭﻴﺭ ‪:‬‬
‫‪194‬‬
http://www.alshater.net ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
Editor.PasteFromClipboard;
: ‫ـ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺘﺤﺩﻴﺩ ﺍﻟﻜل ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﺘﺤﺭﻴﺭ‬
Editor.SelectAll;
، Editor ‫ﻤﻥ ﺍﻟﻭﺍﻀﺢ ﺃﻥ ﺍﻟﺯﺭﻴﻥ ﻨﺴﺦ ﻭ ﻗﺹ ﻴﺠﺏ ﺃﻥ ﻴﻜﻭﻨﺎ ﻏﻴﺭ ﻓﻌﺎﻟﻴﻥ ﺇﺫﺍ ﻟﻡ ﻴﺤﺩﺩ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻨﺼﹰﺎ ﻤﺎ ﻓﻲ ﺍﻟﻌﻨﺼﺭ‬
، ( ‫ﻜﻤﺎ ﺃﻥ ﺍﻟﺯﺭ ﻟﺼﻕ ﻴﺠﺏ ﺃﻥ ﻴﻜﻭﻥ ﻏﻴﺭ ﻓﻌﺎل ﻓﻲ ﺤﺎل ﻜﺎﻨﺕ ﺍﻟﺤﺎﻓﻅﺔ ﻓﺎﺭﻏﺔ ) ﺃﻭ ﻓﻲ ﺤﺎل ﻜﺎﻨﺕ ﻓﻴﻬـﺎ ﺼـﻭﺭﺓ‬
: ‫ﻟﺘﺤﻘﻴﻕ ﺫﻟﻙ ﺃﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺘﺤﺭﻴﺭ‬
Copytext.Enabled := editor.SelLength > 0;
Cuttext.Enabled := editor.SelLength > 0;
Pastetext.Enabled := clipboard.HasFormat(CF_text);
. EditForm ‫ ﻓﻲ ﻟﻠﻭﺤﺩﺓ‬uses ‫ ﺇﻟﻰ ﺍﻟﻘﺴﻡ‬ClipBrd ‫ﻭﺃﻀﻑ ﺍﻟﻭﺤﺩﺓ‬
‫ ﻭﻫﻲ ﺘﺴﺎﻭﻱ ﺍﻟﺼﻔﺭ ﺇﺫﺍ ﻟﻡ ﻴﺤﺩﺩ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺃﻱ‬Editor ‫ ﻴﻌﻴﺩ ﻋﺩﺩ ﺍﻷﺤﺭﻑ ﺍﻟﻤﺤﺩﺩﺓ ﻓﻲ ﺍﻟﻌﻨﺼﺭ‬SelLength ‫ﺍﻟﻤﻨﻬﺞ‬
. ‫ﺤﺭﻑ‬
: ‫ﺒﺭﻤﺠﺔ ﺍﻟﻘﺎﺌﻤﺔ ﺘﻨﺴﻴﻕ‬
: ‫ﺍﻜﺘﺏ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﻤﺤﺎﺫﺍﺓ ﺇﻟﻰ ﺍﻟﻴﺴﺎﺭ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ‬
with Sender as TMenuItem do Checked := True;
with Editor.Paragraph do
if Left1.Checked then
Alignment := taLeftJustify
else if Right1.Checked then
Alignment := taRightJustify
else if Center1.Checked then
Alignment := taCenter;
‫ ﻓـﻲ‬OnClick ‫ﺜﻡ ﺤﺩﺩ ﺍﻟﺯﺭﻴﻥ ) ﻤﺤﺎﺫﺍﺓ ﺇﻟﻰ ﺍﻟﻴﻤﻴﻥ ( ﻭ)ﻤﺤﺎﺫﺍﺓ ﺇﻟﻰ ﺍﻟﻴﺴﺎﺭ ( ﺜﻡ ﺃﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺴﻬﻡ ﺍﻟﻤﺠﺎﻭﺭ ﻟﻠﺤﺩﺙ‬
. Left1Click ‫ ﻤﻥ ﻤﺤﺭﺭ ﺍﻟﺨﻭﺍﺹ ﻭﺍﺨﺘﺭ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ‬Event ‫ﺍﻟﺼﻔﺤﺔ‬

: ‫ـ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﺘﻔﺎﻑ ﺘﻠﻘﺎﺌﻲ‬

with Editor do
begin
WordWrap := not WordWrap; { toggle word wrapping }
if WordWrap then
ScrollBars := ssVertical
else
ScrollBars := ssBoth;
WordWrap1.Checked := WordWrap; { set menu item check }
end;
: ‫ـ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺨﻁ‬
FontDialog1.Font := Editor.Font;
if FontDialog1.Execute then
Editor.SelAttributes.Assign(FontDialog1.Font);

195
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﻴﺘﻤﻴﺯ ﺍﻟﻌﻨﺼﺭ ‪ RichEdit‬ﻋﻥ ﺍﻟﻌﻨﺼﺭ ‪ Memo‬ﺒﺈﻨﻪ ﻴﻤﻜﻥ ﺘﺤﺩﻴﺩ ﻨﻤﻁ ﺨﻁ ﻟﻜل ﺴﻁﺭ ﺃﻱ ﺃﻨﻪ ﻴﻤﻜﻥ ﺘﻨﺴﻴﻕ ﺍﻟـﻨﺹ‬
‫ﺍﻟﻤﻜﺘﻭﺏ ﺒﺩﺍﺨﻠﻪ ﻋﻠﻰ ﻋﻜﺱ ﺍﻟﻌﻨﺼﺭ ‪ Memo‬ﺍﻟﺫﻱ ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺨﻁ ﻭﺘﻨﺴﻴﻕ ﻭﺍﺤﺩ ﻟﻜل ﺍﻷﺴﻁﺭ ‪.‬‬
‫ﻭﺍﻟﻤﻨﻬﺞ ‪ SelAttributes‬ﻴﻌﻁﻴﻙ ﺃﻤﻜﺎﻨﻴﺔ ﺍﻟﺘﺤﻜﻡ ﺒﺘﻨﺴﻴﻕ ﺍﻟﺴﻁﺭ ﺍﻟﻤﺤﺩﺩ ﻓﻲ ﺍﻟﻌﻨﺼﺭ ‪.TRichEdit‬‬
‫ﺒﺭﻤﺠﺔ ﺍﻟﻘﺎﺌﻤﺔ ﺇﻁﺎﺭ ﻓﻲ ﺍﻟﻨﻤﻭﺫﺝ ‪: MainForm‬‬
‫ﻓﻲ ﺍﻟﺒﺩﺍﻴﺔ ﺘﻼﺤﻅ ﺃﻥ ﻫﺫﻩ ﺍﻟﻘﺎﺌﻤﺔ ﻟﻥ ﺘﻅﻬﺭ ﺃﺜﻨﺎﺀ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺇﺫﺍ ﻜﺎﻥ ﺃﺤﺩ ﺍﻷﺒﻨﺎﺀ ﻅﺎﻫﺭﹰﺍ ) ﺃﻏﻠﻕ ﺠﻤﻴﻊ ﺍﻟﻨﻭﺍﻓﺫ ﺍﻷﺒﻨﺎﺀ‬
‫ﺍﻟﻤﻔﺘﻭﺤﺔ ﻭﻻﺤﻅ ﻅﻬﻭﺭ ﺍﻟﻘﺎﺌﻤﺔ ﺇﻁﺎﺭ ﻤﻥ ﺠﺩﻴﺩ ( ﻫﺫﺍ ﻴﺤﺩﺙ ﻷﻥ ﻗﺎﺌﻤﺔ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻻﺒﻥ ﺘﺄﺨﺫ ﻤﻜﺎﻥ ﻗﺎﺌﻤﺔ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻷﺏ‬
‫ﻭﺇﺫﺍ ﺃﺭﺩﻨﺎ ﺇﻅﻬﺎﺭ ﻗﻭﺍﺌﻡ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻷﺏ ﺒﺠﻭﺍﺭ ﻗﻭﺍﺌﻡ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻻﺒﻥ ﻋﻠﻴﻨﺎ ﺍﺴﺘﺨﺩﺍﻡ ﻤﺎ ﻴﺩﻋﻰ ﺒﺩﻤﺞ ﺍﻟﻘﻭﺍﺌﻡ ﻭﻟﺘﺤﻘﻴﻕ ﺫﻟﻙ‬
‫‪:‬‬
‫ﺍﻓﺘﺢ ﻤﺤﺭﺭ ﺍﻟﻘﻭﺍﺌﻡ ﻓﻲ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻷﺏ ﻭﺤﺩﺩ ﺍﻟﺯﺭ ﺇﻁﺎﺭ ﺜﻡ ﺍﻜﺘﺏ ﺍﻟﻘﻴﻤﺔ ‪ 1‬ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪. GroupIndex‬‬
‫ﻻﺤﻅ ﺃﻥ ﺠﻤﻴﻊ ﻗﻭﺍﺌﻡ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻻﺒﻥ ﺘﺄﺨﺫ ﺍﻟﻘﻴﻤﺔ ﺍﻻﻓﺘﺭﺍﻀﻴﺔ ‪ 0‬ﻓﻲ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﻭﺇﺫﺍ ﺃﻋﻁﻴﺕ ﺍﻟﻘﻴﻤﺔ ‪ 1‬ﻷﺤﺩ ﻫﺫﻩ ﺍﻟﻘﻭﺍﺌﻡ‬
‫ﻓﺈﻨﻬﺎ ﺴﺘﺄﺨﺫ ﻤﻜﺎﻥ ﺍﻟﻘﺎﺌﻤﺔ ﺇﻁﺎﺭ ‪ ،‬ﺃﻤﺎ ﺇﺫﺍ ﺃﻋﻁﻴﺕ ﺃﺤﺩ ﻗﻭﺍﺌﻡ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻻﻴﻥ ﺍﻟﻘﻴﻤﺔ ‪ 2‬ﻓﻲ ﺍﻟﺨﺎﺼﺔ ‪ GroupIndex‬ﻓﺈﻨﻬـﺎ‬
‫ﺴﺘﻅﻬﺭ ﺒﻌﺩ ﺍﻟﻘﺎﺌﻤﺔ ﺇﻁﺎﺭ ‪.‬‬
‫ﺇﺫﹰﺍ ﺍﻟﺨﺎﺼﺔ ‪ GroupIndex‬ﺘﺴﺘﺨﺩﻡ ﻟﺩﻤﺞ ﻭﺘﺭﺘﻴﺏ ﺍﻟﻘﻭﺍﺌﻡ ﺒﻴﻥ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻷﺏ ﻭﺍﻟﻨﻤﺎﺫﺝ ﺍﻷﺒﻨﺎﺀ ‪.‬‬
‫ـ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺘﺭﺘﻴﺏ ﺍﻟﻜل ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﺇﻁﺎﺭ ‪:‬‬
‫‪MainForm.Tile‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺘﺭﺘﻴﺏ ﺍﻟﻨﻭﺍﻓﺫ ﺍﻷﺒﻨﺎﺀ ﺒﺸﻜل ﺃﻓﻘﻲ ) ﻋﻠﻴﻙ ﺃﻥ ﺘﻔﺘﺢ ﺃﻜﺜﺭ ﻤﻥ ﻨﺎﻓﺫﺓ ﺍﺒﻥ ﻟﺘﻼﺤﻅ ﺍﻟﻨﺘﺎﺌﺞ ‪.‬‬
‫ـ ﺍﻜﺘﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺤﺩﺙ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺘﺘﺎﻟﻲ ﺍﻟﻜل ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﺇﻁﺎﺭ‪:‬‬
‫;‪MainForm.Cascade‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺼﻑ ﺍﻟﻨﻭﺍﻓﺫ ﻓﻭﻕ ﺒﻌﻀﻬﺎ ﺍﻟﺒﻌﺽ ‪.‬‬
‫ﺇﻅﻬﺎﺭ ﺃﺴﻤﺎﺀ ﺍﻟﻨﻭﺍﻓﺫ ﺍﻷﺒﻨﺎﺀ ﻀﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ﺇﻁﺎﺭ ‪:‬‬
‫ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﻘﺎﺌﻤﺔ ﺇﻁﺎﺭ ﻓﻲ ﺒﺭﻨﺎﻤﺞ ﺍﻟﻭﻭﺭﺩ ﺘﻅﻬﺭ ﻓﻲ ﻨﻬﺎﻴﺔ ﺍﻟﻘﺎﺌﻤﺔ ﺃﺴﻤﺎﺀ ﺠﻤﻴﻊ ﻤﻠﻔﺎﺕ ﺍﻟﻨـﺼﻭﺹ ﺍﻟﻤﻔﺘﻭﺤـﺔ‬
‫ﻭﻟﺘﺤﻘﻴﻕ ﺫﻟﻙ ﻓﻲ ﺒﺭﻨﺎﻤﺠﻨﺎ ﺤﺩﺩ ﺍﻟﻨﻤﻭﺫﺝ ‪ MainForm‬ﺜﻡ ﺍﺫﻫﺏ ﺇﻟﻰ ﺍﻟﺨﺎﺼﺔ ‪ WindowsMenu‬ﻭﺃﻋﻁﺎﻫﺎ ﺍﻟﻘﻴﻤـﺔ‬
‫‪ ) Window1‬ﺍﺴﻡ ﺯﺭ ﺍﻟﻘﺎﺌﻤﺔ ﺇﻁﺎﺭ ( ‪ ،‬ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻵﻥ ﻭﺍﻓﺘﺢ ﺃﻜﺜﺭ ﻤﻥ ﻤﻠﻑ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﻘﺎﺌﻤﺔ ﺇﻁﺎﺭ ﺴﺘﻼﺤﻅ‬
‫ﻅﻬﻭﺭ ﺃﺴﻤﺎﺀ ﺠﻤﻴﻊ ﻫﺫﻩ ﺍﻟﻤﻠﻔﺎﺕ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻹﻁﺎﺭ ﻭﻴﻤﻜﻨﻙ ﺍﻟﺘﻨﻘل ﺒﻴﻥ ﻫﺫﻩ ﺍﻟﻤﻠﻔﺎﺕ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﻀﻐﻁ ﻋﻠـﻰ ﺍﺴـﻡ‬
‫ﺍﻟﻤﻠﻑ ﻓﻲ ﻫﺫﻩ ﺍﻟﻘﺎﺌﻤﺔ ‪.‬‬
‫ﺃﺤﻔﻅ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻵﻥ ﻭﺍﻨﺘﻘل ﺇﻟﻰ ﺍﻟﺨﻁﻭﺓ ﺍﻟﺘﺎﻟﻴﺔ ﻭﻫﻲ ﻋﻤل ﺒﺭﻨﺎﻤﺞ ﺘﻨﺼﻴﺏ ) ‪ ( Setup‬ﻟﺘﻭﺯﻴﻊ ﺒﺭﻨﺎﻤﺞ ﺍﻟﻤﻔﻜﺭﺓ ‪.‬‬

‫‪196‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﺒﺭﻨﺎﻤﺞ ‪: Install Shelled Express‬‬
‫ﺒﻌﺩ ﺃﻥ ﻴﺼﺒﺤﻙ ﺒﺭﻨﺎﻤﺠﻙ ﺠﺎﻫﺯﹰﺍ ﻭﺨﺎﻟﻴﹰﺎ ﻤﻥ ﺍﻷﺨﻁﺎﺀ ﻋﻠﻴﻙ ﺃﻥ ﺘﺤﻀﺭﻩ ﻟﻴﻌﻤل ﻋﻠﻰ ﺃﻱ ﺤﺎﺴـﺏ ﻭﺒﺄﺴـﻬل ﻁﺭﻴﻘـﺔ‬
‫ﻤﻤﻜﻨﺔ‪ ،‬ﻓﻠﻴﺱ ﻤﻥ ﺍﻟﻤﻌﻘﻭل ﺃﻥ ﻴﻜﻭﻥ ﺍﻟﻤﺒﺭﻤﺞ ﻤﻭﺠﻭﺩﹰﺍ ﻟﺘﻨﺼﻴﺏ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻋﻠﻰ ﻋﻨﺩ ﻜل ﻤﺴﺘﺨﺩﻡ ﻟﻠﺒﺭﻨﺎﻤﺞ ﻟﺫﻟﻙ ﺠـﺭﺕ‬
‫ﺍﻟﻌﺎﺩﺓ ﻋﻠﻰ ﺍﺴﺘﺨﺩﺍﻡ ﻤﻌﺎﻟﺠﺎﺕ ﺘﻨﺼﻴﺏ ﻭﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻥ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺼﻨﺎﺩﻴﻕ ﺍﻟﺤﻭﺍﺭ ﺘﺴﺄل ﺍﻟﻤـﺴﺘﺨﺩﻡ ﻋـﻥ ﻤـﺴﺎﺭ‬
‫ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﻟﻠﻐﺔ ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﻭﻤﻜﺎﻥ ﻭﻀﻊ ﺍﻻﺨﺘﺼﺎﺭﺍﺕ ‪.....‬‬
‫ﺘﺴﺘﻁﻴﻊ ﺃﻥ ﺘﻜﺘﺏ ﺒﺭﻨﺎﻤﺞ ﺍﻟﺘﻨﺼﻴﺏ ﺒﻨﻔﺴﻙ ﻓﻬﻭ ﻓﻲ ﺍﻟﻨﻬﺎﻴﺔ ﻋﺒﺎﺭﺓ ﻋﻥ ﻨﺴﺦ ﻤﻠﻔﺎﺕ ﻤﻥ ﻗﺭﺹ ﻤﺭﻥ ﺃﻭ ﻗﺭﺹ ﻟﻴـﺯﺭﻱ‬
‫ﺇﻟﻰ ﺍﻟﺤﺎﺴﺏ ﻭﻟﻜﻥ ﻫﻨﺎﻙ ﺒﺭﺍﻤﺞ ﻤﺨﺘﺼﺔ ﺒﻬﺫﻩ ﺍﻟﻌﻤﻠﻴﺔ ‪ ،‬ﻭﻴﺄﺘﻲ ﻤﻊ ﻗﺭﺹ ﺩﻟﻔﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪Install Shelled Express‬‬
‫ﻭﻫﻭ ﻨﺴﺨﺔ ﻤﺠﺎﻨﻴﺔ ﻤﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪ Install Shelled Professional‬ﻭﻟﻜﻨﻪ ﻴﻔﻲ ﺒﺎﻟﻐﺭﺽ ‪.‬‬
‫ﺴﻨﺸﺭﺡ ﺍﻵﻥ ﺒﺸﻜل ﺴﺭﻴﻊ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪Install Shelled Express‬‬
‫ﻋﻤل ﺒﺭﻨﺎﻤﺞ ﺘﻨﺼﻴﺏ ﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﻤﻔﻜﺭﺓ ‪:‬‬
‫ﻻ ﺘﻨﺼﻴﺏ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪ Install Shelled Express‬ﻤﻥ ﻗﺭﺹ ﺩﻟﻔﻲ ﻭﻤﻥ ﺘﺸﻐﻴﻠﻪ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪:‬‬ ‫ﻋﻠﻴﻙ ﺃﻭ ﹰ‬
‫‪Start Æ Program Æ IntallShelled Æ Express – Borland Limited Edition .‬‬
‫ﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﻨﺎﻓﺫﺓ ﺍﺨﺘﺭ ﻤﻨﻬﺎ ‪: Create new project‬‬
‫ﻓﻲ ﺍﻟﺼﻨﺩﻭﻕ ‪ Project name and location‬ﺃﻜﺘﺏ ‪ C:\My Documents\MySetups\MyNotpad.ism‬ﺜﻡ‬
‫ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ‪. Create‬‬
‫ﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﻨﺎﻓﺫﺓ ﺘﺘﺄﻟﻑ ﻤﻥ ﻨﺎﻓﺫﺓ ﺘﺤﻭﻱ ﺸﺠﺭﺓ ﻋﻠﻰ ﺍﻟﻴﺴﺎﺭ ﻭﺘﻅﻬﺭ ﻓﻲ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻴﻤﻨﻰ ﺨﺼﺎﺌﺹ ﺍﻟﻔﺭﻉ ﺍﻟﻤﺨﺘﺎﺭ ﻤـﻥ‬
‫ﻫﺫﻩ ﺍﻟﺸﺠﺭﺓ ‪.‬‬
‫ﺍﺨﺘﺭ ‪ General Information‬ﻤﻥ ﺍﻟﺸﺠﺭﺓ ﻓﺴﺘﻅﻬﺭ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻤﺠﺎﻭﺭﺓ ‪:‬‬
‫ﻫﻨﺎﻙ ﺒﻌﺽ ﺍﻟﺨﻭﺍﺹ ﺍﻟﻭﺍﻀﺤﺔ‬
‫ﻭﺍﻟﺘﻲ ﻟﻴﺴﺕ ﺒﺤﺎﺠﺔ ﺇﻟﻰ ﺸﺭﺡ‬
‫ﻟﺫﻟﻙ ﺴﺄﺸﺭﺡ ﺃﻜﺜﺭ ﺍﻟﺨﺼﺎﺌﺹ‬
‫ﺃﻫﻤﻴﺔ ‪:‬‬
‫‪ : INSTALLDIR‬ﺘﺤﺩﺩ ﻫﺫﻩ‬
‫ﺍﻟﺨﺎﺼﺔ ﺍﻟﻤﺠﻠـﺩ ﺍﻻﻓﺘﺭﺍﻀـﻲ‬
‫ـﺼﻴﺏ‬
‫ـﻪ ﺘﻨـ‬
‫ـﻴﺘﻡ ﻓﻴـ‬
‫ـﺫﻱ ﺴـ‬
‫ﺍﻟـ‬
‫ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒﺎﻟﻀﻐﻁ ﻋﻠـﻰ ﻫـﺫﻩ‬
‫ﺍﻟﺨﺎﺼﺔ ﺘﻅﻬﺭ ﺍﻟﻘﻴﻡ ﺍﻟﺘﻲ ﻴﻤﻜﻥ‬
‫ﺃﻥ ﺘﺄﺨﺫﻫﺎ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ‪ ،‬ﻜﻤـﺎ‬
‫ﻴﻤﻜﻨﻙ ﻜﺘﺎﺒﺔ ﺍﻟﻤﺠﻠﺩ ﺍﻟﺫﻱ ﺘﺭﻴﺩ‬
‫ﻟﺘﻨﺼﻴﺏ ﺒﺭﻨﺎﻤﺠﻙ ﺩﺍﺨﻠﻪ ‪.‬‬
‫‪ : Product Name‬ﺘﺤﺩﺩ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﺴﻡ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺴﻴﻅﻬﺭ ﺍﺴﻡ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻋﻨﺩ ﺒﺩﺍﻴﺔ ﺍﻟﺘﻨﺼﻴﺏ ‪.‬‬

‫‪197‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﺨﺘﺭ ‪ Setup Types‬ﻤﻥ ﺍﻟﺸﺠﺭ ﺓ ﺍﻟﻴﺴﺎﺭﻴﺔ ﻓﺘﻅﻬﺭ ﻨﺎﻓﺫ ﻋﻠﻰ ﺍﻟﻴﺴﺎﺭ ﺘﺴﺘﺨﺩﻡ ﻟﺘﺤﺩﻴﺩ ﻨﻭﻉ ﺍﻟﺘﻨﺼﻴﺏ ﻭﻫﻨـﺎﻙ ﺜـﻼﺙ‬
‫ﺃﻨﻭﺍﻉ ﻋﺎﺩﺓ ﻟﺘﻨﺼﻴﺏ ﺍﻟﻤﻠﻑ ﻭﻫﻲ ﺇﻤﺎ ﺘﻨﺼﻴﺏ ﻨﻤﻭﺫﺠﻲ ) ‪ ( Typical‬ﺃﻭ ﺘﻨﺼﻴﺏ ﺍﺼﻐﺭﻱ ) ‪ ( Minimal‬ﺃﻭ ﺘﻨﺼﻴﺏ‬
‫ﻤﺨﺼﺹ ) ‪ ( Custom‬ﺘﺘﺤﻜﻡ ﻁﺭﻕ ﺍﻟﺘﻨﺼﻴﺏ ﺒﺎﻟﻤﻠﻔﺎﺕ ﺍﻟﺘﻲ ﺴﻴﺘﻡ ﻨﺴﺨﻬﺎ ﺇﻟﻰ ﺍﻟﺤﺎﺴﺏ ﻭﺒﻤﺎ ﺃﻥ ﺒﺭﻨﺎﻤﺠﻨﺎ ﻤﺅﻟﻑ ﻤﻥ‬
‫ﻤﻠﻑ ﻭﺍﺤﺩ ﻓﻼ ﺤﺎﺠﻪ ﻷﻥ ﻴﻜﻭﻥ ﻫﻨﺎﻙ ﺜﻼﺙ ﺃﻨﻭﺍ ﻤﻥ ﺍﻟﺘﻨﺼﻴﺏ ﻟﺫﻟﻙ ﺍﺨﺘﺭ ﻓﻘﻁ ‪ Typical‬ﻤﻥ ﺍﻟﻨﺎﻓﺫﺓ ‪.‬‬

‫ﺍﺨﺘﺭ ‪ Files‬ﻤﻥ ﺍﻟﺸﺠﺭﺓ ﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺃﺭﺒﻊ ﻨﻭﺍﻓﺫ ﻤﺘﺠﺎﻭﺭ ﺇﻟﻰ ﻓﻲ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻴﺴﺭﻯ ‪ ،‬ﺴﻨﺤﺩﺩ ﻫﻨﺎ ﺍﻟﻤﻠﻔﺎﺕ ﺍﻟﺘـﻲ ﺴـﻴﺘﻡ‬
‫ﻨﺴﺨﻬﺎ ﺇﻟﻰ ﺍﻟﻘﺭﺹ ﺍﻟﺼﻠﺏ ﻭﻫﻲ ﻤﻠﻔﺎﺕ ﺍﻟﺘﻲ ﻴﺤﺘﺎﺠﻬﺎ ﺍﻟﺒﺭﻨﺎﻤﺞ ) ﻤﻌﻅﻡ ﺍﻟﺒﺭﺍﻤﺞ ﺍﻟﻤﻜﺘﻭﺒﺔ ﺒﺎﻟﻐﺔ ﺩﻟﻔﻲ ﻻ ﺘﺤﺘﺎﺝ ﺇﻻ ﺇﻟﻰ‬
‫ﺍﻟﻤﻠﻑ ﺫﻭ ﺍﻻﻤﺘﺩﺍﺩ ‪ .Exe‬ﺇﻻ ﺇﺫﺍ ﻜﺎﻥ ﺒﺭﻨﺎﻤﺠﻙ ﻴﺘﻌﺎﻤل ﻤﻊ ﻤﻠﻔﺎﺕ ﺨﺎﺭﺠﻴﺔ‪ ،‬ﻜﻤﻠﻔﺎﺕ ﺼﻭﺭ ﺃﻭ ﻨﺼﻭﺹ ﺃﻭ ﺼـﻭﺕ ﺃﻭ‬
‫ﻗﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ‪...‬‬
‫ﺍﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﻤﻴﻨﻲ ﻋﻠﻰ ‪ Destination Computer‬ﻓﻲ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻴﺴﺭﻯ ﻓﻲ ﺍﻷﺴﻔل ﺴﺘﻅﻬﺭ ﻟﻙ ﻗﺎﺌﻤﺔ ﺤـﺩﺩ‬
‫ﻤﻨﻬﺎ ‪ ، INSTALLDIR‬ﺤﺩﺩ ﺒﻌﺩﻫﺎ ﺍﻟﻔﻬﺭﺱ ﺍﻟﺫﻱ ﺤﻔﻅﺕ ﻓﻴﻪ ﺒﺭﻨﺎﻤﺞ ﺍﻟﻤﻔﻜﺭﺓ ﻓﻲ ﺍﻟﻨﺎﻓﺫﺓ ‪Source Computer's‬‬
‫‪. Folder‬‬
‫ﺜﻡ ﺃﻨﻘل ﺍﻟﻤﻠﻑ ﻤﻥ ‪ TextEditor.Exe‬ﻤﻥ ﺍﻟﻨﺎﻓـﺫﺓ ‪ Source Computer's Files‬ﺇﻟـﻰ ﺍﻟﻨﺎﻓـﺫﺓ ‪Destination‬‬
‫‪ Computer Files‬ﻋﻥ ﻁﺭﻴﻕ ﺴﺤﺏ ﺍﻟﻤﻠﻑ ﺇﻓﻼﺘﻪ ‪.‬‬
‫ﺍﺨﺘﺭ ‪ : Object/ Merge Modules‬ﻭﺤﺩﺩ ﻤﻥ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻤﺠﺎﻭﺭﺓ ﺍﻟﻤﻜﺘﺒﺎﺕ ﺍﻟﺘﻲ ﻴﺘﻌﺎﻤل ﻤﻌﻬﺎ ﺒﺭﻨﺎﻤﺞ ﻭﺃﻫﻤﻬﺎ ‪:‬‬
‫‪ : BDE_ent‬ﺤﺩﺩ ﻫﺫﺍ ﺍﻟﺨﻴﺎﺭ ﺇﺫﺍ ﻜﺎﻥ ﺒﺭﻨﺎﻤﺠﻙ ﻴﺴﺘﺨﺩﻡ ﺍﻟﻌﻨﺎﺼﺭ ﻓﻲ ﺍﻟﺼﻔﺤﺔ ‪ BDE‬ﻓﻲ ﺩﻟﻔﻲ ﻭﺒﻤﺠﺭﺩ ﺘﺤﺩﻴﺩ ﻫـﺫﺍ‬
‫ﺍﻟﺨﻴﺎﺭ ﻴﻅﻬﺭ ﻨﻤﻭﺫﺝ ﺤﻭﺍﺭ ﻟﺘﺤﺩﻴﺩ ﻨﻭﻉ ﻗﺎﻋﺩﺓ ﺍﻟﻤﻌﻁﻴﺎﺕ ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﻭﻹﻨﺸﺎﺀ ‪ Alias‬ﺇﺫﺍ ﻜﻨﺕ ﺒﺤﺎﺠﺔ ﻟﺫﻟﻙ ‪.‬‬
‫‪ : QuickReport‬ﺤﺩﺩ ﻫﺫﺍ ﺍﻟﺨﻴﺎﺭ ﺇﺫﺍ ﺍﺴﺘﺨﺩﻤﺕ ﻓﻲ ﺒﺭﻨﺎﻤﺠﻙ ﺍﻟﻌﻨﺎﺼﺭ ﻓﻲ ﺍﻟﺼﻔﺤﺔ ‪... . QuickRep‬‬
‫ﺍﺨﺘﺭ ﺒﻌﺩﻫﺎ ‪ : Shortcuts /folder's‬ﻓﺘﻅﻬﺭ ﻋﻨﺩﻫﺎ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫ﺍﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﻤﻨﻲ ﻋﻠﻰ ﺍﻟﻘﺎﺌﻤﺔ ‪ Program Menu‬ﻭﺍﺨﺘﺭ ‪ New Folder‬ﻭﺴﻡ ﺍﻟﻤﺠﻠﺩ ﺍﻟﺠﺩﻴﺩ ﺒﺎﺴﻡ ﺸﺭﻜﺘﻙ ﺜﻡ‬
‫ﺍﻀﻐﻁ ﻋﻠﻰ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻟﻴﻤﻴﻨﻲ ﻋﻠﻰ ﺍﻟﻤﺠﻠﺩ ﺍﻟﺠﺩﻴﺩ ﻭﺍﺨﺘﺭ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪ ، New Shortcut‬ﺃﻋﻁ ﻫﺫﺍ ﺍﻻﺨﺘﺼﺎﺭ ﺍﻻﺴﻡ‬
‫‪ Notepad‬ﺜﻡ ﺤﺩﺩ ﺍﻟﺨﺼﺎﺌﺹ ﻟﻬﺫﺍ ﺍﻻﺨﺘﺼﺎﺭ ﻜﻤﺎ ﻫﻭ ﻤﻭﻀﺢ ﻓﻲ ﺍﻷﻋﻠﻰ ﻭﻫﺫﺍ ﺸﺭﺡ ﻟﻬﺫﻩ ﺍﻟﺨﺼﺎﺌﺹ ‪.‬‬
‫‪ :Description‬ﺘﻅﻬﺭ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺘﻠﻤﻴﺢ ﻋﻨﺩﻤﺎ ﻴﻘﻑ ﻤﺅﺸﺭ ﻓﻭﻕ ﺃﻴﻘﻭﻨﺔ ﺍﻻﺨﺘﺼﺎﺭ ﻓﻲ ‪Win2000‬‬
‫‪ : Target‬ﺘﺤﺩﺩ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﻟﻤﻠﻑ ﺍﻟﺫﻱ ﺴﻴﺘﻡ ﺘﺸﻐﻴﻠﻪ ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻻﺨﺘﺼﺎﺭ ) ﻻ ﺤﻅ ﺃﻥ ﻫـﺫﺍ ﺍﻻﺨﺘـﺼﺎﺭ‬
‫ﻴﺠﺏ ﺃﻥ ﻴﺤﺩﺩ ﻋﻠﻰ ﺍﻟﻜﻤﺒﻴﻭﺘﺭ ﺍﻟﻬﺩﻑ ﻭﻟﻴﺱ ﻋﻠﻰ ﺤﺎﺴﺒﻙ ﻟﺫﻟﻙ ﻭﻀﻊ ﺩﺍﺨل ‪. INSTALLDIR\TextEditor.exe‬‬
‫‪ : IconFile‬ﻴﺘﻡ ﺘﺤﺩﻴﺩ ﻓﻲ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﻷﻴﻘﻭﻨﺔ ﺍﻟﺘﻲ ﺴﻴﺤﻤﻠﻬﺎ ﺍﻻﺨﺘﺼﺎﺭ ‪.‬‬

‫‪198‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫‪ : Working Directory‬ﺘﺤﺩﺩ ﻤﺠﻠﺩ ﻋﻤل ﺍﻟﺒﺭﻨﺎﻤﺞ ) ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﻀﺭﻭﺭﻴﺔ ﺠﺩﹰﺍ ﺇﺫﺍ ﻜﺎﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻴﺴﺘﺩﻋﻲ ﻤﻠﻔﺎﺕ‬
‫ﻤﻥ ﻤﺠﻠﺩ ﺍﻟﺒﺭﻨﺎﻤﺞ (‪.‬‬
‫ﻴﻤﻜﻨﻙ ﻋﻤل ﺃﻜﺜﺭ ﻤﻥ ﺍﺨﺘﺼﺎﺭ ﻟﻨﻔﺱ ﺍﻟﻤﻠﻑ ‪ ،‬ﻜﻤﺎ ﻴﻤﻜﻨﻙ ﺃﻥ ﺘﻅﻬﺭ ﺍﺨﺘﺼﺎﺭ ﻟﺒﺭﻨﺎﻤﺞ ﻋﻠﻰ ﺴﻁﺢ ﺍﻟﻤﻜﺘﺏ ﻭ ﺇﺫﺍ ﺃﺭﺩﺕ‬
‫ﻟﺒﺭﻨﺎﻤﺠﻙ ﺃﻥ ﻴﻌﻤل ﻓﻲ ﺒﺩﺍﻴﺔ ﺘﺸﻐﻴل ﻭﻴﻨﺩﻭﺯ ﻀﻊ ﺍﺨﺘﺼﺎﺭﹰﺍ ﻟﻪ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ‪. Startup‬‬
‫ﺍﺨﺘﺭ ‪ Registry‬ﻤﻥ ﺍﻟﺸﺠﺭﺓ ﺍﻟﻴﺴﺎﺭﻴﺔ ﺇﺫﺍ ﻜﺎﻥ ﺒﺭﻨﺎﻤﺠﻙ ﻴﺘﻌﺎﻤل ﻤﻊ ﻤﻠﻑ ﺘﺴﺠﻴل ﻭﻴﻨﺩﻭﺯ ) ﺇﺫﺍ ﻜﺎﻥ ﺒﺭﻨﺎﻤﺠﻙ ﻴﺤﺘـﺎﺝ‬
‫ﺇﻟﻰ ﺇﻀﺎﻓﺔ ﻗﻴﻡ ﺇﻟﻰ ﻤﺴﺠل ﺍﻟﻨﻅﺎﻡ ﻟﻴﻌﻤل ﺒﺸﻜل ﺠﻴﺩ ( ‪.‬‬
‫ﺍﺨﺘﺭ ‪ Dialog‬ﻤﻥ ﺍﻟﺸﺠﺭﺓ ﺍﻟﻴﺴﺎﺭﻴﺔ ﻟﺘﺤﺩﺩ ﺍﻟﻨﻭﺍﻓﺫ ﺍﻟﺘﻲ ﺴﺘﻅﻬﺭ ﺃﺜﻨﺎﺀ ﺘﺸﻐﻴل ﺒﺭﻨﺎﻤﺞ ﺍﻟﺘﻨﺼﻴﺏ ‪ ،‬ﺤﺩﺩ ﻤﻨﻬﺎ ﺍﻟﻨﻭﺍﻓﺫ ﺍﻟﺘﻲ‬
‫ﺘﺭﻴﺩ ﺃﻥ ﺘﻅﻬﺭ ﻭﻻﺘﻨﺱ ﺃﻥ ﺘﺘﺤﻜﻡ ﺒﺨﺼﺎﺌﺹ ﻫﺫﻩ ﺍﻟﻨﻭﺍﻓﺫ ) ﻻ ﺤﻅ ﺃﻥ ﻜﺜﺭﺓ ﺍﻟﻨﻭﺍﻓﺫ ﺴﺘﺅﺩﻱ ﺇﻟﻰ ﺯﻴﺎﺩﺓ ﺤﺠـﻡ ﻤﻠﻔـﺎﺕ‬
‫ﺒﺭﻨﺎﻤﺞ ﺍﻟﺘﻨﺼﻴﺏ ( ‪.‬‬
‫ﻼ ( ﺃﻭ‬
‫‪ Requirement‬ﺇﺫﺍ ﻜﺎﻥ ﺒﺭﻨﺎﻤﺠﻙ ﻤﺨﺼﺹ ﻟﻴﻌﻤل ﻋﻠﻰ ﻨﻅﺎﻡ ﺘﺸﻐﻴل ﻤﺤﺩﺩ ) ﻭﻴﻨﺩﻭﺯ ‪ 2000‬ﻓﻘﻁ ﻤﺜ ﹰ‬ ‫ﺍﺨﺘﺭ‬
‫ﺍﻨﻪ ﺒﺤﺎﺠﺔ ﺇﻟﻰ ﻤﻌﺎﻟﺞ ﻤﻥ ﻁﺭﺍﺯ ﻤﻌﻴﻥ ‪ ،‬ﺃﻭ ﺒﺤﺎﺠﺔ ﺇﻟﻰ ﺤﺩ ﻤﻌﻴﻥ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ ﻟﻴﻌﻤل ﻭ‪...‬‬
‫ﺍﺨﺘﺭ ‪ Build your release‬ﻭﺍﺨﺘﺭ ‪ Custom‬ﻤﻥ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻤﺠﺎﻭﺭﺓ ﻭﺤﺩﺩ ﺍﻟﺨﺼﺎﺌﺹ ﻤﻥ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﻤﺠﺎﻭﺭﺓ ﻭﻓﻴﻤـﺎ‬
‫ﻴﻠﻲ ﺸﺭﺡ ﻤﺨﺘﺼﺭ ﻟﻬﺫﻩ ﺍﻟﺨﻭﺍﺹ ‪:‬‬
‫‪ : Media Size‬ﺤﺩﺩ ﻫﻨﺎ ﺤﺠﻡ ﻭﺴﻴﻠﺔ ﺍﻟﺘﺨﺯﻴﻥ ﺍﻟﺘﻲ ﺘﺭﻴﺩ ﺃﻥ ﺘﺨﺯﻥ ﻋﻠﻴﻬﺎ ﺒﺭﻨﺎﻤﺞ ﺍﻟﺘﻨﺼﻴﺏ ) ﺇﺫﺍ ﻜﺎﻥ ﻗﺭﺹ ﻤـﺭﻥ‬
‫ﺃﻋﻁ ﺍﻟﻘﻴﻤﺔ ‪. ( 1.38‬‬
‫‪ : Media Size Unite‬ﻴﻤﻜﻨﻙ ﺃﻥ ﺘﺨﺘﺎﺭ ﺒﻴﻥ ‪ Mb‬ﺃﻭ ‪ Gb‬ﺃﻱ ﺃﻥ ﺍﻟﺤﺠﻡ ﺍﻟﺫ‪1‬ﻱ ﺤﺩﺩﺘﻪ ﻓﻲ ﺍﻟﺨﻴـﺎﺭ ﺍﻷﻭل ﺴـﻴﻘﺎﺱ‬
‫ﺒﺎﻟﻤﻴﻐﺎ ﺒﺎﻴﺕ ﺃﻭ ﻓﻲ ﺠﻴﻐﺎ ﺒﺎﻴﺕ ‪.‬‬
‫‪ : Cluster Size‬ﻴﻤﻜﻨﻙ ﺃﻥ ﺘﺨﺘﺎﺭ ‪ 512‬ﺃﻭ ‪ 1024‬ﺘﺒﻌﹰﺎ ﻟﻭﺴﻴﻁ ﺍﻟﺘﺨﺯﻴﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ‪.‬‬
‫‪ : Compress Media‬ﺃﻋﻁ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻟﻬﺫﻩ ﺍﻟﺨﺎﺼﺔ ﻟﻴﺘﻡ ﻀﻐﻁ ﻤﻠﻔﺎﺕ ﺒﺭﻨﺎﻤﺠﻙ ﻭ) ﻴﻔﻀل ﺃﻥ ﺘﻔﻌل ﺫﻟﻙ ﺇﺫﺍ ﻜﻨﺕ‬
‫ﺘﺭﻴﺩ ﺤﺠﻡ ﺍﻟﺘﺨﺯﻴﻥ ﺃﺼﻐﺭ ﻤﺎ ﻴﻤﻜﻥ ( ‪.‬‬
‫‪ : Setup.exe‬ﻓﻲ ﺒﺭﺍﻤﺞ ﺍﻟﺘﻨﺼﻴﺏ ﺍﻟﺤﺩﻴﺜﺔ ﻟﻡ ﻴﻌﺩ ﺍﻟﻤﻠﻑ ‪ Setup.exe‬ﻫﻭ ﺍﻟﻤﻠﻑ ﺍﻟﻤﺴﺅﻭل ﻋﻥ ﺘﻨـﺼﻴﺏ ﺍﻟﺒﺭﻨـﺎﻤﺞ‬
‫ﻭﻴﻘﻭﻡ ﺒﺘﻨﺼﻴﺏ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﻤﻠﻔﺎﺕ ﺫﺍﺕ ﺍﻻﻤﺘﺩﺍﺩ ‪ Msi‬ﻭﻤﻬﻤﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪ Setup.exe‬ﻫﻲ ﺘﺤﺩﻴﺩ ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ﻭﺘـﺴﻠﻴﻡ‬
‫ﺍﻟﻌﻤل ﺇﻟﻰ ﺒﺭﺍﻤﺞ ﺘﻨﺼﻴﺏ ﻤﻠﻔﺎﺕ ‪ Msi‬ﺍﻟﻤﻨﺎﺴﺒﺔ‪ ،‬ﻴﻔﻀل ﺃﻥ ﺘﻌﻁﻲ ﻫﺫﻩ ﺍﻟﺨﺎﺼﺔ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﻷﻥ ﺃﻏﻠﺏ ﺍﻟﻤﺴﺘﺨﺩﻤﻴﻥ‬
‫ﺘﻌﻭﺩ ﻋﻠﻰ ﺘﺸﻐﻴل ﻤﻠﻔﺎﺕ ‪. Setup.exe‬‬
‫‪ : Include Msi Win9x engine‬ﺴﻴﻀﻴﻑ ﻫﺫﺍ ﺍﻟﺨﻴﺎﺭ ﺍﻟﻤﻠﻑ ‪ instmsia.exe‬ﻭﻫﻭ ﻴﻘﻭﻡ ﺒﺘﻨﺼﻴﺏ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﺫﻱ‬
‫ﻴﺴﺘﻁﻴﻊ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻤﻠﻔﺎﺕ ‪ ) Msi‬ﺍﻟﻤﻠﻑ ﺫﻭ ﺍﻻﻤﺘﺩﺍﺩ ‪ Msi‬ﻟﻴﺱ ﻤﻠﻑ ﺘﻨﻔﻴﺫﻱ ﻭﻟﺫﻟﻙ ﻫﻭ ﺒﺤﺎﺠﺔ ﻟﺒﺭﻨﺎﻤﺞ ﺁﺨﺭ ﻟﺘﺸﻐﻴﻠﻪ‬
‫ﻓﺈﺫﺍ ﻗﻤﺕ ﺒﺘﻨﺼﻴﺏ ﺒﺭﻨﺎﻤﺠﻙ ﻋﻠﻰ ﺤﺎﺴﻭﺏ ﻻ ﻴﺤﻭﻱ ﺒﺭﻨﺎﻤﺞ ﺘﺸﻐﻴل ﻤﻠﻔﺎﺕ ‪ Msi‬ﻓﻠﻥ ﻴﺘﻡ ﺘﻨﺼﻴﺏ ﺍﻟﺒﺭﻨـﺎﻤﺞ‪ ،‬ﻟـﺫﻟﻙ‬
‫ﻋﻠﻴﻙ ﺃﻥ ﺘﻀﻴﻑ ﺍﻟﻤﻠﻑ ‪ instmsia.exe‬ﺍﻟﺫﻱ ﻴﺤﻭﻱ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﻤﺴﺅﻭل ﻋﻥ ﻓﺘﺢ ﺍﻟﻤﻠﻔﺎﺕ ﻤﻥ ﻨﻭﻉ ‪ ، ( Msi‬ﺇﺫﺍ ﻜﻨﺕ‬
‫ﺴﺘﺴﺘﺨﺩﻡ ﺍﻟﻘﺭﺹ ﺍﻟﻤﺭﻥ ﻜﻭﺴﻴﻠﺔ ﺘﺨﺯﻴﻥ ﻓﺄﻋﻁ ﻫﺫﺍ ﺍﻟﺨﻴﺎﺭ ﺍﻟﻘﻴﻤﺔ ‪. True‬‬
‫‪ : Include Msi Windows Nt engine‬ﺴﻴﻀﻴﻑ ﻫﺫﺍ ﺍﻟﺨﻴﺎﺭ ﺍﻟﻤﻠﻑ ‪ .... instmsiw.exe‬ﻨﻔﺱ ﺍﻟﺸﺭﺡ ﺍﻟﺴﺎﺒﻕ ‪.‬‬
‫‪ : Generate AutoRun.inf‬ﺃﻋﻁ ﻫﺫﺍ ﺍﻟﺨﻴﺎﺭ ﺍﻟﻘﻴﻤﺔ ‪ True‬ﺇﺫﺍ ﻜﻨﺕ ﺴﺘﻨﺴﺦ ﺒﺭﻨﺎﻤﺞ ﺇﻟﻰ ﻗﺭﺹ ﻟﻴﺯﺭﻱ ﺃﻭ ﻗـﺭﺹ‬
‫‪. DVD‬‬
‫‪199‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﺨﺘﺭ ﺍﻵﻥ ‪ Build Custom‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪ Build‬ﺴﻴﺘﻡ ﻋﻨﺩﻫﺎ ﺇﻨﺸﺎﺀ ﻤﻠﻔﺎﺕ ﺍﻟﺘﻨﺼﻴﺏ ﻭﻴﺠﺏ ﺃﻥ ﺘﻜﻭﻥ ﺍﻟﺭﺴﺎﻟﺔ ﺍﻷﺨﻴﺭﺓ‬
‫‪build completed with 0 errors, 0 warnings‬‬
‫ﻫﺫﺍ ﻴﻌﻨﻲ ﺃﻥ ﻟﻡ ﻴﺤﺩﺙ ﺃﻱ ﺃﺨﻁﺎﺀ ﺃﺜﻨﺎﺀ ﻋﻤﻠﻴﺔ ﺒﻨﺎﺀ ﻤﻠﻔﺎﺕ ﺍﻟﺘﻨﺼﻴﺏ ‪.‬‬
‫ﺍﺨﺘﺭ ﺒﻌﺩ ﺫﻟﻙ ‪ Test Your Release‬ﻤﻥ ﺍﻟﺸﺠﺭﺓ ﻭﺍﻀﻐﻁ ﻋﻠﻰ ‪ Custom‬ﻓﻲ ﺍﻟﻨﺎﻓﺫﺓ ﺍﻟﺠﺩﻴﺩﺓ ﻭﻤﻥ ﺜﻡ ‪Run Your‬‬
‫‪ ، Setup‬ﺴﻴﺘﻡ ﺍﻵﻥ ﺘﻨﺼﻴﺏ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒﺸﻜل ﻜﺎﻤل ﻻ ﺤﻅ ﺍﻟﺨﻁﻭﺍﺕ ﻭﺘﺄﻜﺩ ﻤﻥ ﺃﻨﻬﺎ ﺘﻌﻤل ﺒﺸﻜل ﺼﺤﻴﺢ ﻭﺇﺫﺍ ﺘﻡ ﺍﻟﻌﻤل‬
‫ﺒﺩﻭﻥ ﺭﺴﺎﺌل ﺃﺨﻁﺎﺀ ‪ ،‬ﺴﺘﺠﺩ ﺍﻻﺨﺘﺼﺎﺭﺍﺕ ﺍﻟﺘﻲ ﻭﻀﻌﺘﻬﺎ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﺃﺒﺩﺍ ‪ ،‬ﻜﻤﺎ ﻴﻤﻜﻨﻙ ﺇﺯﺍﻟﺔ ﺍﻟﺒﺭﻨـﺎﻤﺞ ﻤـﻥ ﺍﻟﻨﺎﻓـﺫﺓ‬
‫ﺇﻀﺎﻓﺔ ﺇﺯﺍﻟﺔ ﺍﻟﺒﺭﺍﻤﺞ ﻤﻥ ﻟﻭﺤﺔ ﺍﻟﺘﺤﻜﻡ ‪.‬‬
‫ﻓﻲ ﺤﺎل ﺤﺩﻭﺙ ﺃﺨﻁﺎﺀ ﻴﺠﺏ ﻋﻠﻴﻙ ﺍﻟﺘﺄﻜﺩ ﻤﻥ ﺍﻟﻘﻴﻡ ﺍﻟﺘﻲ ﺍﺨﺘﺭﺘﻬﺎ ﻓﻲ ﺍﻟﻨﻭﺍﻓﺫ ﺍﻟﺴﺎﺒﻘﺔ ﻭﺇﻋﺎﺩﺓ ﺒﻨﺎﺀ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻤﻥ ﺘﺠﺭﺒﺘﻪ‬
‫‪.‬‬
‫ﺒﻌﺩ ﺍﻻﻨﺘﻬﺎﺀ ﺴﺘﺠﺩ ﻨﺴﺨﺔ ﻤﻥ ﺒﺭﻨﺎﻤﺞ ﺍﻟﺘﻨﺼﻴﺏ ﻓﻲ ﺍﻟﻔﻬﺭﺱ ﺍﻟﺫﻱ ﺤﺩﺩﺘﻪ ﻟﺤﻔﻅ ﺒﺭﻨﺎﻤﺞ ﺍﻟﺘﻨﺼﻴﺏ ﻭﻫﻭ ﻏﺎﻟﻴﹰﺎ ﻤﻥ ﺍﻟﺸﻜل‬
‫‪:‬‬
‫‪C:\My Documents\MySetups\MyNotpad\Express\Custom\DiskImages\DISK1‬‬
‫ﺤﺩﺩ ﺍﻟﺨﻴﺎﺭ ‪ Distributed your release‬ﻭﺍﺨﺘﺭ ‪ Custom‬ﻤﻥ ﺍﻟﺸﺠﺭﺓ ﺍﻟﻤﺠﺎﻭﺭﺓ ﻭﻤﻥ ﺜﻡ ﺤﺩﺩ ﺍﻟﻤﻜﺎﻥ ﺍﻟﺫﻱ ﺘﺭﻴﺩ‬
‫ﺃﻥ ﺘﻀﻊ ﻓﻴﻪ ﺒﺭﻨﺎﻤﺞ ﺍﻟﺘﻨﺼﻴﺏ ‪،‬ﻟﻴﻜﻥ ﺍﻟﻘﺭﺹ \‪ A:‬ﻤﺜ ﹰ‬
‫ﻼ ‪...‬‬
‫ﻤﻼﺤﻅﺔ ‪:‬ﻫﺫﻩ ﺍﻟﻨﺴﺨﺔ ﻤﻥ ‪ Install Shelled‬ﻻ ﺘﺩﻋﻡ ﺍﻟﻠﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ ﻭﻓﻲ ﺤﺎل ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻠﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ ﻓـﻲ ﻋﻤﻠﻴـﺎﺕ‬
‫ﺇﻋﺩﺍﺩ ﺒﺭﻨﺎﻤﺞ ﺍﻟﺘﻨﺼﻴﺏ ﻤﻥ ﺍﻟﻤﺤﺘﻤل ﺃﻥ ﺘﺸﺎﻫﺩ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺭﺴﺎﺌل ﺍﻷﺨﻁﺎﺀ ‪.‬‬

‫ﻭﺁﺨﺭ ﺩﻋﻭﺍﻫﻡ ﺃﻥ ﺍﻟﺤﻤﺩ ﷲ ﺭﺏ ﺍﻟﻌﺎﻟﻤﻴﻥ‬

‫ﺍﻟﻠﻬﻡ ﻋﻠﻤﻨﺎ ﻤﺎ ﻴﻨﻔﻌﻨﺎ ﻭﺍﻨﻔﻌﻨﺎ ﺒﻤﺎ ﻋﻠﻤﺘﻨﺎ ﻭﺍﻨﻔﻊ ﺍﻟﻨﺎﺱ ﺒﻨﺎ ﻭﺍﻏﻔﺭ ﻟﻨﺎ ﻭﺍﺭﺤﻤﻨﺎ ﺇﻨﻙ ﺃﻨﺕ ﺍﻟﻐﻔﻭﺭ ﺍﻟﺭﺤﻴﻡ‬

‫ﻤﺤﻤﺩ ﺨﺎﻟﺩ ﻨﺎﺼﺭ ﺁﻏﺎ‬

‫‪200‬‬
‫‪http://www.alshater.net‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ دﻟﻔﻲ‬
‫ﺍﻟﻤﺭﺍﺠﻊ‬
‫ﺩﺍﺭ ﺸﻌﺎﻉ‬ ‫ﺍﻟﻤﻬﻨﺩﺱ ﻴﺎﺴﺭ ﻋﻘﺎﺩ‬ ‫ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ﺩﻟﻔﻲ‬
‫ﺃﺴﺎﻤﺔ ﻤﻌﺭﺍﻭﻱ‬ ‫ﻤﺠﻤﻭﻋﺔ ﻤﺤﺎﻀﺭﺍﺕ ﻓﻲ ﻜﻠﻴﺔ ﺍﻟﻬﻨﺩﺴﺔ ﺍﻟﻤﻌﻠﻭﻤﺎﺘﻴﺔ ﺠﺎﻤﻌﺔ‬
‫ﺤﻠﺏ‬
‫ﻤﺤﻤﺩ ﺤﻤﺩﻱ ﻏﺎﻨﻡ‬ ‫ﺍﺤﺘﺭﺍﻑ ‪Visual Basic .Net‬‬
‫ﻤﻭﺍﻗﻊ ﻋﻠﻰ ﺍﻻﻨﺘﺭﻨﺕ‬
‫ﻤﻥ ﺃﻭل ﻭﺃﻗﻭﻯ ﻤﻭﺍﻗﻊ ﺍﻟﺩﻟﻔﻲ ﻭﻟﻜﻨﻪ ﻟﻸﺴﻑ ﻻ ﻴﻌﻤل ﻓﻲ‬ ‫‪http://www.arabdevelopers.com‬‬
‫ﺍﻟﻭﻗﺕ ﺍﻟﺤﺎﻟﻲ‬
‫ﺍﻟﻔﺭﻴﻕ ﺍﻟﻌﺭﺒﻲ ﻟﻠﺒﺭﻤﺠﺔ‬ ‫‪http://www.arabteam2000.com‬‬

‫ﻤﻭﻗﻊ ﺇﻨﻜﻠﻴﺯﻱ ﻭﻟﻜﻨﻙ ﺒﺎﻟﺘﺄﻜﻴﺩ ﺴﺘﺤﺏ ﺍﻟﺩﻟﻔﻲ ﺇﺫﺍ ﻓﻬﻤﺕ‬ ‫‪http://www.delphiforfun.com‬‬

‫ﺒﺭﺍﻤﺞ ﻫﺫﺍ ﺍﻟﻤﻭﻗﻊ‬

‫‪201‬‬