نمایش نسخه قابل چاپ
با سلام
در این موضوع قصد داریم درباره لزوم کامپوننت نویسی ، باید ها و نباید ها و روند تکامل یک کامپوننت ساده بحث کنیم.
در ابتدا ممکن است چند سوال مطرح شود:
- کامپوننت چیست؟
- چرا باید از کامپوننت های استاندارد استفاده کنیم؟
- چه وقت باید سراغ کامپوننت های آماده در اینترنت رفت؟
- معایب و مزایای استفاده از کامپوننت های پولی (کرک شده) و یا رایگان چیست؟
- چه مجموعه کامپوننت هایی جزء بهترین ها هستند؟
- چگونه می توان یک کامپوننت برای نیاز خود بسازیم؟
پاسخ به سوال اول رو میزارم بر عهده ی خود مهندس ظریف عزیز و پس از ترجمه ی مقاله ای در این رابطه پاسخ کاملی رو به عرضتون خواهند رسوند.نقل قول:
نوشته اصلی توسط مجید [برای مشاهده لینک ها شما باید عضو سایت باشید برای عضویت در سایت بر روی اینجا کلیک بکنید]
استفاده از هر ابزار استانداردی باعث میشه تا با مجموعه ی کمتری از ایرادات مواجه بشیم.نقل قول:
- چرا باید از کامپوننت های استاندارد استفاده کنیم؟
در صورتی که دو تا از شرایط زیر رو داشته باشیم.نقل قول:
- چه وقت باید سراغ کامپوننت های آماده در اینترنت رفت؟
1. ارزش خرید کامپوننت رو نداشته باشد.
2. کامپوننت استانداردی در این زمینه وجود نداشته باشد.
منطقا این نوع از رفتار (کرک ) کار درستی نیست.نقل قول:
- معایب و مزایای استفاده از کامپوننت های پولی (کرک شده) و یا رایگان چیست؟
البته کامپوننت رایگان با کرک شده متفاوت است و استفاده از کامپوننت رایگان و استاندارد منعی ندارد.
برای هر زبانی و همچنین انجام هر عملیاتی، کامپوننت های متفاوتی در دسترس است، مثلا مجموعه کامپوننت های شرکت tms برای زبان دلفی گزینه ی خوبی هستند.نقل قول:
- چه مجموعه کامپوننت هایی جزء بهترین ها هستند؟
همچنین فایل پیوست رو مهندس سمیعی در پاسخ به سوال مهندس ظریف برام فرستادند که گوش دادن به اون خالی از لطف نخواهد بود.
با سلام مجدد وعرض پوزش بخاطر تاخیر بوجود آمده
متاسفانه این روزها خیلی سرم شلوغ هست و پیش بینی میکنم روند ارائه مطالب در ابتدای راه با کندی پیش بره . البته سعی خواهم کرد که در آینده هفته ای یک بار مطالب را بروز رسانی کنم . امیدوارم براتون مفید باشه.
مطالبی که از پست بعد توسط بنده درج خواهد شد بر اساس ترجمه یک فایل پی دی اف حاوی 163 صفحه خواهد بود . سعی میکنم هر جا که لازم بود از تصایر و سورس ها و مثال های جدید استفاده کنم. ضمنا فایل پی دی اف مذکور را هم در همین پست ضمیمه خواهم کرد تا هر کسی خواست سریعتر ادامه بده . و در همینجا هم اگه کسی هست که مایل باشه در این زمینه با بنده همکاری کنه (فی سبیل الله) خوشحال میشم اعلام آمادگی کنه.
- کامپوننت چیست؟
پاسخ این سوال در مقدمه فایل پی دی اف وجود داره که در پست بعدی ارائه خواهد شد.
- چرا باید از کامپوننت های استاندارد استفاده کنیم؟
منظوراز کامپوننت های استاندارد ، کامپوننت هایی هست که در کد نویسی آنها اصول و قواعد شیء گرایی رعایت شده ، همچنین نیاز کاربر در طراحی اولیه آن دیده شده باشد. کامپوننت های زیادی در این سالها برای اهداف متنوعی توسط برنامه نویسان سراسر دنیا ایجاد شده و همه ما کم و بیش از تعدادی از آنها در کار های خودمون استفاده کردیم . اگر چه نمیشه از روی ظاهر کامپوننت درباره استاندارد بودن یا نبودنشون قضاوت کرد ولی میشه از روی عملکرد بسیاری از کامپوننت ها به یک سری از ویژگی هاشون پی برد . مثلا بعضی از کامپوننت ها پس از قرار گرفتن روی فرم بخشی از کاری که قراره در RunTime اجرا کنند را در Design Time اجرا می کنند! و یا در بعضی موارد پس از استفاده در پروژه متوجه می شید که کامپوننت باگ داره و باعث مثلا کندی یا خطا هایی میشه که در زمان طراحی به اونها توجهی نشده . تشخیص استاندارد بودن یا نبودن یک کامپوننت کار ساده ای نیست چون اغلب کامپوننت ها با فایل dcu ارائه میشن و به همین دلیل شما نمی تونید کد های کامپوننت را از نظر اصول و قواعد بررسی کنید تا قضاوت درستی دربارشون بکنید. البته بعضی از کامپوننت ها هم با سورس ارائه میشن که میشه اونها رو بدقت تحلیل کرد. اما تجربه ثابت کرده معمولا کامپوننت هایی که توسط شرکت های معتبر و با سابقه تولید میشه و مدام در حال دیباگ هست تا نسخه های جدید و سازگار با ورژن های بالاتر دلفی را به بازار عرضه کنند ، کمترین ایرادات را دارند و با استفاده از روش های استاندارد و رعایت اصول و قواعد شیء گرایی تولید شدند.
- چه وقت باید سراغ کامپوننت های آماده در اینترنت رفت؟
اگه دانش این کارو ندارید و یا نمی تونید برای ساخت کامپوننت مورد نظر خودتون وقت بذارید و یا حدس میزنید ممکنه قبلا کسی کامپوننت مورد نظر شما رو ساخته ، بد نیست توی اینترنت یه جستجویی بکنید .
اما یادتون باشه هر چه بیشتر پروژه هاتونو با این روش پیش ببرید در آینده با مشکلات جدی تری روبرو می شید . کم نیستند دلفی کارانی که با همین طرز فکر پروژه هایی را با دلفی های 6 یا 7 انجام دادند و حالا برای مهاجرت به نسخه های بالاتر بدلیل عدم وجود نسخه های جدید کامپوننت های استفاده شده در پروژه ، امکان بروز رسانی نرم افزارشونو ندارند.
- معایب و مزایای استفاده از کامپوننت های پولی (کرک شده) و یا رایگان چیست؟
منظور از کامپوننت های رایگان ، عدم پرداخت پول توسط ما ایرانی ها بابت بدست آوردن کامپوننت های پولی (کرک شده) است. اصولا استفاده از هر نرم افزار کرک شده ای درست نیست . اما تعریف ما از درست و غلط در کشور عزیزمون با بقیه نقاط دنیا کمی فرق داره . ما مجبوریم بدلیل تحریم های بانکی ، تحریم هایی که بعضی تولید کنند گان نرم افزار برامون در نظر گرفتند، سیاست های دولتمردان خودمون ، در آمد ناکافی و (وضع نامناسب اقتصادی ) برای خرید نسخه های اصل و ... مجبور باشیم به نسخه های کرک شده رو بیاریم. شاید عدم پرداخت پول یکی از مهمترین مزایای استفاده از این کامپوننت ها باشه ولی مهمترین ایرادش اینه که شما نمی تونید بعنوان یک مشتری با شرکت تولید کننده در ارتباط باشید و انتظار دریافت آپدیت های رایگان داشته باشید . باید همیشه دنبال نسخه های جدید کرک شده بگردید . بماند که ممکنه اون محصول بدرستی کرک نشده باشه یا حتی نسخه های نصبی هم آلوده به بد افزار یا ویروس باشند.
- چه مجموعه کامپوننت هایی جزء بهترین ها هستند؟
بنده JEDI ، TMS و DevExpress را تجربه کردم
البته بین این سه تا هم از JEDI بیشتر خوشم اومد
باید دید بقیه کاربران چه نظری دارند
- چگونه می توان یک کامپوننت برای نیاز خود بسازیم؟
اگه عمری بود و خدا کمک کرد و خودم هم همت داشتم سعی میکنم این بحث را تا انتها ادامه بدم . امیدوارم در پایان ، پاسخ مناسبی به سوال بالا داده باشم.
ضمنا در همین ابتدا بابت ضعف های احتمالی در ترجمه از همه اساتید عذر خواهی میکنم . امیدوارم با راهنمایی هاشون به بنده و خوانندگان عزیز کمک کنند.
کامپوننت چیست ؟
کامپوننت ها بلوک های ساختمان برنامه های ایجاد شده با دلفی هستند. بسیاری از کامپوننت ها مسئولیت عناصر UI یا همان رابط کاربری را بر عهده دارند.به این دسته از کامپوننت ها visual گفته می شود. همچنین بعضی از آنها مانند Timer ها در نرم افزار ها استفاده میشوند که در زمان اجرا برای کاربر قابل مشاهده نیستند. به این گروه nonvisual می گویند.
از سه منظر می توان کامپوننت ها را بررسی کرد:
- فانکشنال
- تکنیکال
- کاربردی
1-تعریف فانکشنال از "کامپوننت"
از دید کاربران ، یک کامپوننت همان چیزیست که از Tool Palette انتخاب می کنند و در حالت طراحی فرم یا کد نویسی مورد استفاده قرار می دهند. زمانی که اقدام به نوشتن کامپوننت می کنید با یک سری محدودیت های واقعی مواجه خواهید شد. بد نیست به خاطر داشته باشید زمانیکه کاربر از کامپوننت های شما استفاده می کند ، چه انتظاری از آن دارد.
توصیه می کنیم قبل از اینکه سعی کنید کامپوننتی بنویسید ، کامپوننت های موجود دلفی را بدقت بررسی کنید ، شاید آنچه می خواهید بسازید در مجموعه کامپوننت های دلفی وجود داشته باشد.
2-تعریف تکنیکال از "کامپوننت"
در ساده ترین سطح ، یک کامپوننت از یک شیء TComponent بدست آمده است. TComponent اغلب رفتار های پایه ای مانند قابلیت نمایش در Component Palette و استفاده در Form Designer که تمام کامپوننت ها باید داشته باشند را تعریف می کند.
اما فراتر از این تعریف ساده مسائل مختلف بزرگتری نیز وجود دارند. به عنوان مثال ، اگر چه TComponent رفتار عمومی مورد نیاز برای IDE دلفی را تعریف می کند، اما نمی داند که چگونه ویژگی های خاصی را که به کامپوننت خودتان اضافه کرده اید ، مدیریت کند. شما باید خودتان آنها را مشخص کنید.
اگرچه ساخت کامپوننتی که درست رفتار کند خیلی سخت نیست ولی با اینحال بهتر است به استاندارد ها و اصول اینکار توجه کنید.
3-تعریف (کاربردی) کامپوننت نویسان از "کامپوننت"
در سطح کاربردی، یک کامپوننت به هر عنصری که بتواند در محیط توسعه دلفی (IDE) نصب شود ، اطلاق می گردد. آنها تقریبا می توانند هر گونه پیچیدگی را نشان دهند ، از یک افزونه ساده گرفته تا یکی از کامپوننت های استاندارد و همچنین یک رابط کاربر گسترده و پیچیده با یک سیستم نرم افزاری یا سخت افزاری دیگر.
بطور خلاصه ، تا زمانیکه یک کامپوننت را در قالب یک Framework قرار دهید ، می تواند هر آنچه را که شما با کد نویسی انجام میدهید ، اجرا کند.
تعریف محدودیت های یک کامپوننت شبیه تعریف محدودیت های برنامه نویسی است. ما نمیتوانیم به شما بگوییم هر نوع کامپوننتی که خواستید می توانید بسازید. شما تنها قادر خواهید بود آنچه زبان برنامه نویسی به شما امکان میدهد را در قالب کامپوننت ایجاد کنید. آنچه میتوان گفت این است که چگونه کدتان را بنویسید تا در محیط دلفی به خوبی کار کند.
تفاوت های مختلف کامپوننت نویسی با برنامه نویسی در چیست؟
مهمترین تفاوت های کامپوننت نویسی برای استفاده در دلفی و برنامه نویسی با کامپوننت ها به سه بخش تقسیم می شود:
کامپوننت نویسی یک فعالیت nonvisual (غیر بصری) است
کامپوننت نویسی نیازمند درک عمیقی از شیء گراییست
کامپوننت نویسی از قواعد بیشتری طبعیت می کند
کامپوننت نویسی یک فعالیت nonvisual (غیر بصری) است
واضح ترین تفاوت بین برنامه نویسی و کامپوننت نویسی این است که کامپوننت نویسی صرفا در سطح کد نویسی است. زیرا طراحی بصری برنامه های نوشته شده با دلفی نیازمند استفاده از کامپوننت های کامل شده است و ایجاد کامپوننت نیز نیاز مند کد نویسی به روش شیء گراییست.
با اینکه نمی توانید ابزار بصری را برای ایجاد کامپوننت ها بکار ببرید ، ولی می توانید از تمام امکانات برنامه نویسی در محیط دلفی ، شامل ویرایشگر کد (Code Editor) ، دیباگر یکپارچه (integrated debugger) و مرورگر شیء (Object Browser) استفاده کنید.
کامپوننت نویسی نیازمند درک عمیقی از شیء گراییست
غیر از برنامه نویسی غیر بصری (nonvisual) ، تفاوت عمده دیگری که بین برنامه نویسی با کامپوننت ها و کامپوننت نویسی وجود دارد این است که وقتی شما کامپوننت جدیدی ایجاد می کنید ، باید آن را از یکی از اشیاء موجود مشتق کنید و آنگاه خصوصیات و متد های مورد نظر خود را به آن اضافه کنید ولی استفاده کنندگان از کامپوننت ها ، رویداد ها (Events) ، رفتار و خصوصیات (Properties) کامپوننت های موجود را در زمان طراحی ، آنچنان که مورد نیاز خودشان است تغییر می دهند.
وقتی اشیاء جدید را مشتق می کنید، به قسمت هایی از اشیاء والد آنها که در دسترس کاربران نهایی (end users) نیست ، دسترسی پیدا می کنید. این قسمت ها تنها برای کامپوننت نویسان در نظر گرفته شده است که بطور کلی رابط محافظت شده (protected interface) اشیاء نامیده می شوند. برای اجرای بسیاری از اجزای اشیاء فرزند باید همان اجزاء از اشیاء والد فراخوانی شوند. بنابراین کامپوننت نویسان باید آشنا به برنامه نویسی شیء گرایی باشند.
کامپوننت نویسی از قواعد بیشتری طبعیت می کند
کامپوننت نویسی در مقایسه با ساخت برنامه های بصری از قدمت بیشتری برخوردار است . وقتیکه کامپوننت نویسی می کنید باید قواعد بیشتری را رعایت کنید تا زمانیکه از کامپوننت های موجود استفاده می کنید. احتمالا مهمترین چیزی که قبل از نوشتن کامپوننت ذهن شما را مشغول کرده است استفاده از کامپوننت هایی است که با دلفی ارائه شده است و نیز رعایت موارد واضحی مانند قواعد نامگذاری است. اما باید توجه داشته باشید که کاربران کامپوننت شما چه انتظاری از قابلیت های آن خواهند داشت.
مهمترین چیزی که کاربران از کامپوننتها انتظار دارند این است که کامپوننتها باید بتوانند تقریبا هر کاری را در هر زمانی انجام دهند .تحقق این انتظار در کامپوننت نویسی دشوار نیست ولی نیازمند برخی دور اندیشی ها و پایبندی به قواعد است.
و در نهایت ساخت یک کامپوننت
بطور خلاصه ، روند ساخت یک کامپوننت به شرح زیر است:
- ایجاد یک Unit برای کامپوننت جدید
- مشتق کردن یک نوع کامپوننت از یک نوع کامپوننت موجود
- افزودن خصوصیات (properties) ، رویداد ها (events) و متد (procedure / function) هایی که نیاز دارید
- رجیستر کردن کامپوننتتان با دلفی
- ایجاد یک فایل راهنما برای کامپوننتتان و خصوصیات ، رویداد ها و متد های آن
سعی خواهیم کرد تمام مراحل فوق را در این بحث دنبال کنیم. در انتها ، کامپوننت شما شامل 4 نوع فایل خواهد بود:
- یک یونیت کامپایل شده با پسوند DCU
- یک پالت Bitmap با پسوند DCR
- یک فایل راهنما با پسوند HLP
- یک فایل کلمات کلیدی برای راهنما با پسوند KWF
اگرچه فقط فایل اول مورد نیاز است ولی فایل های دیگر کامپوننت شما را مفید تر و کاربردی تر خواهند کرد.
با عرض سلام.
یک فایل pdf از مهندس مسعود دهقانیان ذخیره داشتم بهتر دونستم برای استفاده ی دوستان بزارمش.
موفق و موید باشید.
فصل اول
ساخت کامپوننت
یکی از ویژگی های کلیدی دلفی این است که می توانید کتابخانه کامپوننت های موجود درون دلفی را برای برنامه های کاربردی خود ، گسترش دهید . در این بخش تمام جنبه های ساخت کامپوننت تشریح خواهد شد.
برای اینکه استاد ساخت کامپوننت خودتان شوید به دانستن مطالب زیر نیاز دارید:
- بررسی اجمالی ساخت کامپوننت
- برنامه نویسی شیء گرایی (OOP) برای کامپوننت نویسان
- ایجاد خصوصیات (Properties)
- ایجاد رویداد ها (Events)
- ایجاد متد ها (methods)
- استفاده از گرافیک در کامپوننت ها
- مدیریت پیامها
- رجیستر (ثبت) کردن کامپوننت
بررسی اجمالی ساخت کامپوننت
در این فصل شاهد مرور گسترده ای بر معماری کامپوننت ، فلسفه ی طراحی کامپوننت و فرایند نوشتن کامپوننت ها برای برنامه های کاربردی دلفی خواهید بود.
موضوعات اصلی بحث :
- کتابخانه کامپوننت های بصری (Visual)
- کامپوننت ها و اشیاء
- چگونه کامپوننت می سازید؟
- کامپوننت چگونه کار میکند؟
- ساخت یک کامپوننت جدید
- تست کامپوننت حذف شده
برای تمام این موارد، شما باید با استفاده از دلفی و کامپوننت های استاندارد آن آشنایی داشته باشید.
کتابخانه کامپوننت های بصری (Visual)
کامپوننت های دلفی قسمت هایی از یک شیء وراثتی (سلسله مراتبی) هستند که کتابخانه کامپوننت های بصری (VCL) نامیده می شوند. تصویر 1.1 ارتباط بین اشیاء را بخوبی نمایش می دهد. در فصل دوم درباره روابط بین اشیاء و اشیاء وراثتی بحث خواهیم کرد.
توجه داشته باشید که TComponent جد مشترک بسیاری از کامپوننت های VCL است. TComponent حداقل خصوصیات و رویداد های مورد نیاز برای یک کامپوننت در محیط دلفی را فراهم می کند.
[برای مشاهده لینک ها شما باید عضو سایت باشید برای عضویت در سایت بر روی اینجا کلیک بکنید]
تصویر 1.1
وقتی شما یک کامپوننت می سازید ، با مشتق کردن یک شیء جدید از یکی از انواع اشیاء موجود در این سلسله مراتب ، به کتابخانه کامپوننت های بصری یکی اضافه می کنید.
کامپوننت ها و اشیاء
بدلیل اینکه کامپوننت ها ، در واقع اشیاء هستند ، کامپوننت نویسان در سطحی متفاوت از کاربران کامپوننت با اشیاء کار می کنند. ایجاد کامپوننت های جدید مستلزم مشتق کردن از انواع اشیاء دیگر است. فصل دوم توضیحات مفصلی درباره انواع وظایف شیء گرایی که کامپوننت نویسان باید انجام دهند، ارائه می دهد.
بطور خلاصه، دو تفاوت عمده بین ساخت کامپوننت و استفاده از کامپوننت وجود دارد . وقتی کامپوننت ها را می سازید:
- شما به قسمت هایی از اشیاء دسترسی پیدا می کنید که برای کاربران کامپوننت ها غیر قابل دسترسی است
- شما قسمت های جدیدی (مانند خصوصیات ) به کامپوننت ها ی خود می افزایید
بخاطر همین تفاوت ها ، باید به قواعد کار و شرایطی که کاربران کامپوننت های شما از آنها استفاده خواهند کرد ، آگاه باشید.
چگونه کامپوننت می سازید؟
رایج ترین روش های ساخت کامپوننت ها عبارتند از :
- تغییر کنترل های موجود
- ساخت کنترل های اصلی
- ساخت کنترل های گرافیکی
- انشعاب از کنترل های ویندوزی
- ساخت کامپوننت های غیر بصری (nonvisual)
جدول 1.1 تفاوت انواع کامپوننت ها و انواع اشیائی که برای شروع هر کدام استفاده می کنید نشان میدهد.
هدف
با این نوع شروع کنید تغییر یکی از کامپوننت های موجود هر کامپوننتی که وجود دارد، مانند TButton یا TListBox یا یک نوع کامپوننت انتزاعی مانند TCustomListBox ساخت یک کنترل اصلی TCustomControl ساخت یک کنترل گرافیکی TGraphicControl استفاده از یکی از کنترل های ویندوزی TWinControl ساخت کامپوننت غیر بصری (nonvisual) TComponent
همچنین شما می توانید اشیاء دیگری را که کامپوننت نیستند نیز مشتق کنید، در این صورت دیگر نمی توانید آنها را در فرم دستکاری کنید. دلفی شامل تعدادی از این نوع اشیاء است مانند TINIFile یا TFont .
تغییر کنترل های موجود
ساده ترین راه برای ساخت کامپوننت ، شروع با یکی از کامپوننت های موجود است. با آن کار کنید و آن را به دلخواه خود تغییر دهید.شما می توانید یک کامپوننت جدید را از یکی از کامپوننت های موجود که در دلفی ارائه شده است مشتق کنید. برای نمونه ممکن است بخواهید مقادیر پیش فرض خصوصیات یکی از کنترل های استاندارد را تغییر دهید.
بعضی از کنترل ها مانند ListBox ها و Grid ها ، در تم پایه ، حاوی تعدادی تغییر هستند. در این موارد ، وقتی که می خواهید نسخه دلخواه خود را مشتق کنید، دلفی یک نوع کنترل انتزاعی ارائه می کند (که در نام آن عبارت "Custom" وجود دارد ، مانند "TCustomGrid").
به عنوان مثال ، ممکن است بخواهید نوع خاصی از ListBox بسازید که بعضی از خصوصیات نوع TListBox استاندارد را نداشته باشد. شما می توانید یکی از خصوصیاتی که از نوع والد خود به ارث برده است را حذف کنید. بنابر این باید کامپوننت خود را از چیزی بالاتر از TListBox که در سلسله مراتب وجود دارد مشتق کنید.
بجای اینکه مجبور باشید تمام توابع یک ListBox را از یک نوع کنترل انتزاعی دوباره اختراع کنید، کتابخانه کامپوننت های بصری (VCL)، TCustomListBoxرا به شما ارائه می دهد که تمام خصوصیاتی که برای ListBox مورد نیاز است را داراست.اما تمام آنها را Publish نکرده است.
وقتی یک کامپوننت را از یک نوع انتزاعی مانند TCustomListBox مشتق می کنید ، آن خصوصیاتی را که مایلید در کامپوننتتان در دسترس باشد را Publish کرده و مابقی را به حالت Protected (محافظت شده) رها کنید. در فصل سوم چگونگی انتشار (Publishing) خصوصیات به ارث برده شده را توضیح می دهیم.
فصل 9 و 11 مثال هایی از تغییر کنترل های موجود را نشان می دهد.
ساخت کنترل های اصلی
یک کنترل استاندارد در زمان اجرا قابل مشاهده است و معمولا کاربر می تواند با آن تعامل داشته باشد. این کنترل های استاندارد از نوع شیء TWinControl پیاده سازی شده اند.زمانیکه می خواهید یک کنترل اصلی ایجاد کنید (یکی که با هیچیک از کنترل های موجود ارتباطی ندارد) ، برای شروع از TWinControl استفاده کنید.
جنبه کلیدی یک کنترل استاندارد ، هندل ویندوزی آن است که بصورت یک خصوصیت وجود دارد . این خصوصیت Handle نامیده می شود.هندل ویندوزی بدین معناست که ویندوز می تواند در میان سایر چیز های دیگر بوسیله این هندل ، کنترل را شناسایی کند و :
- کنترل می تواند فوکوس دریافت کند
- شما می توانید توابع API ویندوز را به آن پاس دهید (ویندوز برای شناسایی یک کنترل به هندل آن نیاز دارد)
اگر کنترل شما نیازی به دریافت فوکوس ندارد ، می توانید برای حفظ منابع سیستم آن را از نوع گرافیکی بسازید. بخش بعد درباره کنترل های گرافیکی توضیح می دهد.
تمام کامپوننت هایی (مثل Button ها، ListBox ها و EditBox ها غیر از TLabel که نیازی به دریافت فوکوس ندارد) که کنترل های استاندارد ویندوزی را نشان می دهند، از روی TWinControl پیاده سازی شده اند.
ساخت کنترل های گرافیکی
کنترل های گرافیکی بسیار شبیه به کنترل های Custom هستند.اما آنها در مقایسه با کنترل های ویندوزی سربار ایجاد نمی کنند. بخاطر آن است که ویندوز در مورد کنترل های گرافیکی چیزی نمیداند ! آنها هندل ویندوزی ندارند و از این رو منابع سیستم را مصرف نمی کنند. محدودیت اصلی کنترل های گرافیکی این است که نمی توانند فوکوس بگیرند.
دلفی ساخت کامپوننت های دلخواه از نوع TGraphicControl را بطور کامل پشتیبانی می کند. TGraphicControl یک نوع انتزاعی مشتق شده از TControl است. اگر چه شما می توانید کنترل ها را از TControl مشتق کنید، ولی بهتر است آنها را از TGraphicControl بگیرید. زیرا یک Canvas (کادر رسم) در اختیار شما می گذارد. همچنین میتوانید پیام های WM_PAINT را نیز مدیریت کنید. بنابر این شما باید متد Paint را نادیده بگیرید یا (override) کنید.
فصل 10 نمونه ای از ساخت یک کنترل گرافیکی را نشان می دهد.
انشعاب از کنترل های ویندوزی
سیستم عامل ویندوز مفهومی به نام window class دارد که تا حدی شبیه به مفهوم شیء یا کلاس در برنامه نویسی شیء گرا ست. یک window class مجموعه ای از اطلاعات مشترک شده بین نمونه های مختلف همان نوع پنجره یا کنترل در سیستم عامل ویندوز است.
وقتی شما یک نوع کنترل ایجاد می کنید (معمولا آن را Custom Control می نامند)، در برنامه نویسی مرسوم برای ویندوز ، یک window class جدید تعریف کرده و آنرا با ویندوز ثبت می کنید.
همچنین شما می توانید یک window class را به عنوان پایه برای یک کلاس موجود قرار دهید که آن را subclassing (انشعاب از کنترل های ویندوزی) می نامند.
در برنامه نویسی مرسوم برای ویندوز ، اگر شما بخواهید یک Custom Control بسازید، باید آن را مانند بسیاری از کنترل های ویندوز در یک فایل DLL بنویسید و یک interface برای آن ارائه کنید.
با استفاده از دلفی ، می توانید یک کامپوننت جدید "wrapper" (پوشه) پیرامون هر یک از کلاس های موجود در ویندوز بسازید. بنابراین اگر اکنون کتابخانه ای از Custom Control ها دارید که می خواهید آن را در برنامه های دلفی مورد استفاده قرار دهید ، همچون هر کامپوننت دیگری ، می توانید کامپوننت هایی با دلفی بسازید که اجازه استفاده از کنترل های موجود را به شما می دهند و کنترل های جدید را از آنها مشتق کنید.
اگر چه در این راهنما مثالی برای subclassing یک کنترل ویندوزی وجود ندارد ، می توانید تکنیک های استفاده شده در کامپوننت های یونیت StdCtls را ببینید که چگونه کنترل های استاندارد ویندوزی (مانند TButton) را نشان می دهند.
ساخت کامپوننت های غیر بصری (nonvisual)
نوع انتزاعی شیء TComponent نوع پایه برای تمام کامپوننت هاست. تنها کامپوننت هایی که از TComponent مشتق می کنید ، کامپوننت های غیر بصری (nonvisual) هستند.بیشتر کامپوننت هایی که شما می نویسید ، احتمالا انواع مختلفی از کنترل های بصری (visual) هستند.
TComponent تمام خصوصیات و متد های ضروری یک کامپوننت را برای استفاده در محیط طراح فرم تعریف می کند. بدین ترتیب هر کامپوننتی که از TComponent مشتق می کنید سازگار با محیط طراحی فرم دلفی است.
کامپوننت های غیر بصری نسبتا کمیاب هستند. شما بیشتر آنها را در برنامه های غیر بصری (دلفی اغلب برای عناصر پایگاه داده و نیز محلی برای نگهداری Dialog Box ها مانند File Dialog Box استفاده می کند) بکار خواهید برد.
فصل 13 نمونه ای از ساخت یک کامپوننت غیر بصری (nonvisual) را نشان می دهد.
کامپوننت چگونه کار می کند؟
وقتی کامپوننت نویسی می کنید، با محدودیت های کمی روبرو خواهید شد. در صورتیکه بخواهید کامپوننتتان را ساده و قابل اعتماد بسازید ، باید از قواعد مسلمی تبعیت کنید تا مردم از آن استفاده کنند.
این بخش در مورد فلسفه اساسی طراحی کامپوننت ها بحث می کند که شامل موارد زیر است:
- از بین بردن وابستگی ها
- خصوصیات ، رویداد ها و متد ها
- کپسوله سازی گرافیک ها
- ثبت
از بین بردن وابستگی ها
شاید مهمترین فلسفه ایجاد کامپوننت های دلفی ، ضرورت از بین بردن وابستگی ها باشد. یکی از چیز هایی که باعث می شود کاربران کامپوننت ها ، بسادگی آنها را با برنامه های خود ترکیب کنند ، این واقعیت است که مایلند به طور کلی هیچ محدودیتی در آنچه انجام می دهند در هیچ جای کد آنها وجود نداشته باشد.
ماهیت بسیاری از کامپوننت ها نشان می دهد که کاربران مختلف مایلند آنها را با برنامه خود در محیط ها ، ترتیب ها و ترکیب های گوناگون استفاده کنند . شما باید کامپوننت های خود را طوری طراحی کنید که بدون هیچ پیش شرطی و در هر زمینه ای عملکرد مناسبی داشته باشند.
یک نمونه از حذف وابستگی ها
یک نمونه عالی برای از بین بردن وابستگی ها در کامپوننت ها ، خصوصیت Handle از کنترل های پنجره ای است. اگر قبل از این برنامه های ویندوزی می نوشتید ، می دانستید که یکی از مشکل ترین و مستعد ترین جنبه های بروز خطا این بود که باید مطمئن می شدید که پنجره یا کنترل برنامه در حال اجرا تا قبل از اینکه آن را با تابع CreateWindow ایجاد کنید ، به آن دسترسی ندارد. فراخوانی توابع با Handle های نادرست سبب بروز چندین خطا می شد.
کامپوننت های دلفی ، این نگرانی کاربران را که آیا همیشه Handle های معتبر را گرفته اند یا خیر ، برطرف کرده است. برای این منظور با استفاده از یک خصوصیت برای Handle یک پنجره، کامپوننت می تواند بررسی کند که آیا پنجره ایجاد شده است یا خیرو در نتیجه آیا پنجره دارای یک Handle معتبر است یا خیر؟ اگر Handle معتبرنباشد ، خصوصیت مورد نظر ، پنجره را ایجاد کرده و Handle آن را باز می گرداند. بدین ترتیب هر وقت کد کاربر به خصوصیتHandle دسترسی یابد ، مطمئن است که Handle معتبر را گرفته است.
با حذف وظایف پشت صحنه مانند ایجاد پنجره ، کامپوننت ها به توسعه دهندگان اجازه می دهند که روی آنچه دقیقا می خواهند فوکوس کنند. اگر یک توسعه دهنده بخواهد Handle یک پنجره را به یک تابع API پاس دهد، دیگر نیازی به بررسی وجود Handle معتبر ندارد یا اینکه لازم نیست آن را برای پنجره ایجاد کند. با روش برنامه نویسی مبتنی بر کامپوننت ،بجای اینکه برنامه نویس مدام نگران بررسی اشتباه های ممکن باشد ، با این فرض که همه چیز درست کار خواهد کرد می تواند کد نویسی کند.
هر چند بطور کلی ممکن است ساخت کامپوننت هایی که وابستگی نداشته باشند کمی بیشتر طول بکشد ، اما صرف این زمان نتیجه بهتری خواهد داشت. این موضوع ، از آنجاییکه لازم نیست توضیحات و هشدار های متعدد و یا راه حل های مشکلات احتمالی کاربران را ارائه دهید ، نه تنها کاربران کامپوننت شما را از اجرای چندین باره همان وظایف محافظت می کند ، بلکه بار پشتیبانی و تهیه مستندات آن را نیز کاهش می دهد.
خصوصیات ، رویداد ها و متد ها
بارز ترین ویژگی های یک کامپوننت که کاربر در زمان طراحی آن ها را دستکاری می کند ، خصوصیات ، رویداد ها و متد های آن است. هر کدام از اینها آنقدر مهم هستند که یک فصل از کتاب را به آن اختصاص دهیم ، اما این بخش توضیح مختصری از فلسفه ی اجرای آنها خواهد داد.
خصوصیات
چند مزیت استفاده از خصوصیات برای کامپوننت نویس به شرح زیر است :
- خصوصیات در زمان طراحی در دسترس است
این امکان به کاربران کامپوننت اجازه می دهد که مقادیر اولیه خصوصیات را بدون کد نویسی تنظیم کرده یا تغییر دهند.
- خصوصیات می توانند مقادیر یا فرمتهای آنچه که کاربر به آنها اختصاص داده است را بررسی کنند.
اعتبار سنجی مقادیر ورودی کاربرمانع از بروز خطاهای ناشی از مقادیر نامعتبر خواهد شد.
- کامپوننت می تواند همیشه مقادیر مناسب را بسازد.
شاید رایج ترین نوع خطای برنامه نویسان این است که به متغییری مراجعه می کنند که مقدار اولیه به آن اختصاص داده نشده است. با مقدار دهی اولیه به یک خصوصیت ، می توانید مطمئن باشید که همیشه خصوصیت مورد نظر مقدار معتبری دارد.
فصل 3 توضیح می دهد که چگونه خصوصیات را به کامپوننت خود اضافه کنید.
رویداد ها
رویداد ها ارتباط بین رویداد تعیین شده توسط کامپوننت نویس (مانند فعالیت های ماوس و کیبرد) و کد نوشته شد توسط کاربران کامپوننت ("handlers event") را برقرار می کنند. در اصل یک رویداد ، روش کامپوننت نویسان از ارائه یک قلاب (hooks) برای کاربران کامپوننت است تا مشخص کنند زمانیکه یه اتفاق خاص رخ می دهد ، چه کدی اجرا شود. رایج ترین دلیل برای subclassing در برنامه های ویندوزی این است که به عنوان مثال کاربران می خواهند یک پاسخ متفاوت برای یک پیام ویندوزی تعیین کنند . اما در دلفی ، کاربران کامپوننت می توانند handler های از پیش تعریف شده ای را بدون subclassing تعیین کنند ، بنابراین آنها نیازی به مشتق کردن کامپوننت خود ندارند.
فصل 4 توضیح می دهد که چگونه رویداد ها را برای اتفاقات استاندارد ویندوز یا رویداد های تعریف شده خودتان اضافه کنید .
متد ها
متد ها procedure ها یا functionهای ساخته شده در یک کامپوننت هستند. کاربران کامپوننت ، متد ها را برای اجرای یک فعالیت خاص یا باز گرداندن یک مقدار مشخص که با یک خصوصیت پوشش داده نشده است بکار می برند. همچنین یکی دیگر از فایده های متد ها این است که با یک بار فرا خوانی ، می توان چند خصوصیت مرتبط به هم را بروز رسانی کرد.
متد ها به دلیل نیاز به اجرای کد ، فقط در زمان اجرا (Run Time) در دسترس هستند.
فصل 5 توضیح می دهد که چگونه متد ها را به کامپوننت خود اضافه کنید.
کپسوله سازی گرافیک ها
دلفی بوسیله ابزار های گرافیکی موجود دربوم یا Canvas ، بسیاری از اضافه کاری های گرافیکی ویندوز را کپسوله سازی می کند. بوم (Canvas) برای ترسیم ظاهر یک پنجره یا کنترل است که اشیاء دیگری در آن مانند یک قلم (Pen) ، یک قلم مو (Brush) و یک فونت وجود دارند. بوم (Canvas) بیشتر شبیه یک device context ویندوزی است با این تفاوت که با دقت بیشتری در اختیار شماست.
اگر شما تا کنون یک نرم افزار گرافیکی ویندوزی نوشته باشید، با انواع الزاماتی که دستگاه رابط گرافیکی ویندوز (GDI) به شما تحمیل می کند (مانند تعداد device context های در دسترس ، و باز گرداندن وضعیت اشیاء گرافیکی به حالت اولیه شان پیش از آنکه آن ها را destroy کنید) آشنا هستید.
وقتی با گرافیک ها در دلفی کار می کنید ، نیازی نیست نگران هیچ کدام از این ها باشید. برای رسم روی یک فرم یا کامپوننت ،خصوصیت Canvas در دسترس شماست. اگر مایل باشید قلم (Pen) یا قلم مو (Brush) را به دلخواه خود تنظیم کنید ، می توانید مقادیر رنگ (Color) یا سبک (Style) را برای هر کدام تنظیم نمایید. وقتی کارتان تمام شد ، از این به بعد دلفی مراقب هدر رفتن منابع شماست. در واقع ، منابع را برای شما cash می کند ، بنابراین اگر برنامه شما بارها از همان منابع استفاده کند ، احتمالاً از ایجاد و باز آفرینی بسیاری از عناصر نجات خواهید یافت.
البته شما هنوز هم به GDI ویندوز بطور کامل دسترسی دارید. اما اگر از کامپوننت های بوم آماده داخلی دلفی استفاده کنید در بیشتر موارد کد شما ساده تر و سریع تر اجرا خواهد شد. ویژگی های گرافیکی دلفی در فصل 6 توضیح داده خواهد شد.
ثبت
قبل از اینکه کامپوننت شما بتواند در محیط طراحی دلفی عملیاتی شود باید آن را توسط دلفی ثبت کنید. عملیات ثبت به دلفی می گوید که شما مایلید کامپوننتتان را در کدام پالت کامپوننت نمایش دهید همچنین برخی روش ها وجود دارد که شما بوسیله آنها می توانید به دلفی بگویید کامپوننتتان را در فایل فرم قرار دهد. عملیات ثبت در فصل 8 توضیح داده خواهد شد.
ایجاد یک کامپوننت جدید
برای ایجاد یک کامپوننت چند روش وجود دارد. تمام مثال ها با این فرض که شما با این روش ها آشنا هستید ارائه شده اند.
- شما به دو روش می توانید کامپوننت بسازید:
- ساخت کامپوننت به روش دستی
- ساخت کامپوننت با استفاده ازمنوی Component
با استفاده از هر کدام از این روشها باید بتوانید کامپوننتی با حداقل کارایی ، برای نصب در پالت کامپوننت ها آماده کنید. پس از نصب ، می توانید کامپوننت خود را به یک فرم اضافه کرده و هم در زمان طراحی و هم در زمان اجرا آن را تست کنید. پس از آن می توانید ویژگی های بیشتری را به آن افزوده وآن را در پالت کامپوننت ها بروز رسانی کرده و به تست آن ادامه دهید.
ساخت کامپوننت به روش دستی
ساده ترین روش برای ساخت کامپوننت استفاده ازمنوی Component است. اگر چه شما می توانید تمام این مراحل را بصورت دستی نیز انجام دهید.
- ساخت کامپوننت به روش دستی نیازمند مراحل زیر است :
- ایجاد یک یونیت جدید
- مشتق کردن یک شیء کامپوننت جدید
- ثبت کامپوننت
ایجاد یک یونیت جدید
یک یونیت ، یک ماژول جداگانه از کد پاسکال شیء است. دلفی به چند منظور از یونیت ها استفاده می کند. هر فرم یونیت خود را دارد، وهمچنین بیشتر کامپوننت ها (یا گروهی از کامپوننت ها که منطق مشابهی دارند) نیز یونیت خود را دارند.
وقتی یک کامپوننت جدید می سازید ، یک یونیت جدید برای آن ایجاد کنید یا آن را به یک یونیت موجود اضافه کنید.
- جهت ایجاد یک یونیت برای کامپوننت از منوی File گزینه New Unit را انتخاب کنید.
دلفی یک فایل جدید می سازد و آن را در محیط ویراستار کد باز می کند.- برای افزودن کامپوننت به یک یونیت موجود ، از منوی File گزینه Open را انتخاب کنید تا بتوانید سورس کد یونیت موجود را ببینید.
نکته : وقتی یک کامپوننت را به یک یونیت موجود اضافه می کنید، مطمئن شوید که یونیت فقط حاوی کد کامپوننت است. به عنوان مثال ، افزودن یک کامپوننت به یونیت یک فرم باعث ایجاد خطا در پالت کامپوننت ها خواهد شد.
در هر دو صورت ، با هر بار ایجاد کامپوننت ، شما می توانید شیء کامپوننت را مشتق کنید.
مشتق کردن شیء کامپوننت
هر کامپوننت یک شیء مشتق شده از نوع TComponent ، یا از مشتقات تخصصی تر آن مانند TControl یا TGraphicControl ، و یا یکی ازانواع کامپوننت های موجود است. برای مشتق کردن یک شیء کامپوننت ، تعریف نوع شیء را به قسمت interface از همان یونیتی که حاوی کامپوننت خواهد بود ، اضافه کنید. مثلاً برای ایجاد یک نوع کامپوننت ساده ، یک کامپوننت غیر بصری (non-visual) که مستقیماً از TComponent مشتق شده است ، تعریف نوع زیر را به قسمت interface یونیت کامپوننت اضافه کنید:
حالا می توانید TNewComponent را ثبت کنید . توجه داشته باشید که کامپوننت جدید هنوز هیچ فرقی با TComponent ندارد.کد:
type
TNewComponent = class(TComponent)
end;
ثبت کامپوننت
ثبت یک کامپوننت یک فرایند ساده است که به دلفی می گوید چه کامپوننت هایی باید به کتابخانه کامپوننت ها اضافه شوند و کامپوننت ها در چه صفحاتی از پالت کامپوننت ها نمایش داده شوند. فصل 8 روند ثبت کامپوننت ها و تفاوت های ظریف آن ها را با جزئیات بیشتر توصیف می کند.
- برای ثبت یک کامپوننت :
- یک Procedure با نام Register به قسمت interface یونیت کامپوننت اضافه کنید.
Register هیچ پارامتری دریافت نمی کند. بنابراین تعریف آن به سادگی زیر است:
کد:procedure Register;
اگر کامپوننت را به یونیتی که شامل کامپوننت های دیگر است اضافه کرده اید ، این یونیت الان باید دارای یک اعلان procedure Register باشد. بنابراین نیازی به تغییر آن اعلان نیست.RegisterComponents یک procedure است که دو پارامتر ورودی دریافت می کند :
2. Procedure Register را در قسمت implementation یونیت اضافه کرده ودستور RegisterComponents را برای هر کامپوننتی که می خواهید ثبت شود، فراخوانی کنید.
1- نام پالت کامپوننت2- و گروهی از انواع کامپوننت که به صورت Set تعریف می شوند
اگر می خواهید کامپوننت خود را به پروسیجر ثبت کامپوننتی که از قبل وجود دارد اضافه کنید ، می توانید آن را به گروه موجود اضافه کرده و یا برای آن یک دستور RegisterComponents جدید فراخوانی کنید.برای ثبت یک کامپوننت با نام TNewComponent و قرار دادن آن در صفحه Samples در پالت کامپوننت ها ، دستور procedure Register زیر را به یونیتی که حاوی اعلان TNewComponent است ، اضافه کنید.
کد:procedure Register;
begin
RegisterComponents('Samples',[TNewComponent]);
end;
فقط با یک بار ثبت کامپوننت ، می توانید آن را در پالت کامپوننت نصب کنید.
ساخت کامپوننت با استفاده از منوی Componentبرای ساخت کامپوننت به صورت ویزاردی مراحل زیر را دنبال کنید:
[برای مشاهده لینک ها شما باید عضو سایت باشید برای عضویت در سایت بر روی اینجا کلیک بکنید]
دلفی را اجرا کرده و از منوی Component گزینه New Component را انتخاب کنید
[برای مشاهده لینک ها شما باید عضو سایت باشید برای عضویت در سایت بر روی اینجا کلیک بکنید]
مراحل را مانند تصاویر دنبال کنید
[برای مشاهده لینک ها شما باید عضو سایت باشید برای عضویت در سایت بر روی اینجا کلیک بکنید]
پس از جستجوی عبارت TComponent گزینه TComponent را از لیست زیر انتخاب کرده و روی Next کلیک کنید.
[برای مشاهده لینک ها شما باید عضو سایت باشید برای عضویت در سایت بر روی اینجا کلیک بکنید]
مسیر دلخواه را انتخاب کرده و نام یونیت را MyComponent قرار داده و در انتها روی Save کلیلک کنید.
[برای مشاهده لینک ها شما باید عضو سایت باشید برای عضویت در سایت بر روی اینجا کلیک بکنید]
در قسمت Class Name عبارت TNewComponent را وارد کرده و عبارت دلخواه خود را در قسمت Palette Page درج کنید . در این مثال ما از عبارت "ایران دلفی" برای نام پالت استفاده کردیم. در قسمت Unit Name نام فایل و مسیر دلخواه را وارد کنید . و در انتها روی Next کلیک کنید.
[برای مشاهده لینک ها شما باید عضو سایت باشید برای عضویت در سایت بر روی اینجا کلیک بکنید]
و در پایان مشخص کنید که می خواهید کامپوننت در یک یونیت جدید ایجاد شود و یا در یک Package موجود یا Package جدید نصب شود.
[برای مشاهده لینک ها شما باید عضو سایت باشید برای عضویت در سایت بر روی اینجا کلیک بکنید]
پس از اتمام مراحل فوق دلفی نتیجه را مانند تصویر بالا نشان خواهد داد . در این مرحله روی دکمه Save All کلیلک کنید.
[برای مشاهده لینک ها شما باید عضو سایت باشید برای عضویت در سایت بر روی اینجا کلیک بکنید]
یکبار دیگر پنجره ذخیره نام فایل و مسیر را از شما می پرسد .
[برای مشاهده لینک ها شما باید عضو سایت باشید برای عضویت در سایت بر روی اینجا کلیک بکنید]
بدلیل استفاده از کاراکتر های فارسی ("ایران دلفی") در یونیت دلفی برای ذخیره سازی فرمت UTF8 از شما تأیید می گیرد.
تست کامپوننت نصب نشده
شما می توانید رفتار یک کامپوننت را قبل از نصب در پالت کامپوننت ها در زمان اجرا تست کنید. این امر به ویژه برای اشکال زدایی (دیباگ کردن) کامپوننت تازه ایجاد شده ، مفید است. اما شما می توانید بدون در نظر گرفتن اینکه کامپوننت در پالت کامپوننت ها ظاهر شده است یا نه ، از این تکنیک برای تست هر کامپوننتی استفاده کنید.
در واقع ، درست مانند زمانی که یک کاربر ، کامپوننت را از پالت کامپوننت ها روی فرم قرار می دهد ، شما نیز می توانید یک کامپوننت نصب نشده را با تقلید از فعالیت های انجام شده تست کنید. برای اینکار مراحل زیر را دنبال کنید :
این یکی از اصلی ترین تفاوت های بین روش اجرایی شما و دلفی است. شما فیلد شیء را به قسمت public در انتهای اعلان type فرم اضافه می کنید. دلفی برای مدیریت آن ، فیلد شیء را بالای قسمت اعلان type فرم اضافه می کند.شما نباید هیچ وقت فیلد ها را در قسمت مدیریت شده دلفی واقع در بالای اعلان type فرم اضافه کنید. آیتم هایی که در آن قسمت اعلان می شوند مطابق با آیتم های موجود در فایل فرم (فایل های DFM) هستند.افزودن نام کامپوننت هایی که در فرم وجود ندارند به آن قسمت ، باعث نا معتبر شدن فایل فرم (DFM) خواهد شد.
فرض کنید شما می خواهید یک کامپوننت جدید از نوع TNewComponent را در یک یونیت به نام NewTest تست کنید. یک پروژه جدید ایجاد کرده و مراحل گفته شده را تا آخر دنبال کنید تا نتیجه به شکل زیر شود:
پایان فصل اولکد:
unit MyComponent;
interface
uses
System.SysUtils, System.Classes;
type
TNewComponent = class(TComponent)
private
{ Private declarations }
FParent: TComponent;
FLeft : Integer;
procedure SetLeft(val:Integer);
protected
{ Protected declarations }
public
{ Public declarations }
constructor Create(Owner:TComponent); override;
destructor Destroy; override;
property Parent: TComponent read FParent write FParent;
property Left: Integer read FLeft write SetLeft;
published
{ Published declarations }
end;
procedure Register;
implementation
procedure Register;
begin
RegisterComponents('ایران دلفی', [TNewComponent]);
end;
constructor TNewComponent.Create(Owner:TComponent);
begin
inherited;
end;
destructor TNewComponent.Destroy;
begin
inherited;
end;
procedure TNewComponent.SetLeft(val: Integer);
begin
FLeft := val;
end;
end.
کد:
unit Unit1;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils,
System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, MyComponent;
type
TForm1 = class(TForm)
procedure FormCreate(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
NewComponent1: TNewComponent;
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
procedure TForm1.FormCreate(Sender: TObject);
begin
NewComponent1 := TNewComponent.Create(Self); { 4. Construct the component }
NewComponent1.Parent := Self; { 5. Set Parent property }
NewComponent1.Left := 12; {6. Set other properties...}
{ ...continue as needed }
end;
end.
فصل دوم
برنامه نویسی شیء گرا برای کامپوننت نویسان
کار با دلفی، شما را با این ایده مواجه می کند که یک شیء شامل کد و داده است و شما می توانید شیء را هم در زمان طراحی و هم در زمان اجرا دستکاری کنید. در این حالت تبدیل به یک کاربر کامپوننت شده اید.
وقتی که type های جدید کامپوننت ها را ایجاد می کنید، با مواردی در اشیاء سر و کار پیدا می کنید که کاربر نهایی نیازی به آن ها ندارد.
به طور کلی ، قبل از اینکه شروع به ساخت کامپوننت ها کنید ، نیازمند آشنایی با موضوعات مرتبط با برنامه نویسی شیء گرایی ، که در این فصل ارائه شده است خواهید بود.
- ایجاد اشیاء جدید
- اجداد و فرزندان
- کنترل دسترسی
- توزیع امکانات method ها
- اشیاء و اشاره گر ها
ایجاد اشیاء جدید
تفاوت اصلی بین کاربران کامپوننت و کامپوننت نویسان در این است که ، کاربران instance هایی از اشیاء را دستکاری می کنند ولی کامپوننت نویسان type های جدیدی از اشیاء را ایجاد می کنند. اگر برای ایجاد کامپوننت های خود برنامه ریزی می کنید ، این مفهوم اساسی برنامه نویسی شیء گرا است و داشتن درک درستی از این تفاوت بسیار مهم است.
مفهوم type ها و instance ها منحصر به اشیاء نیست. برنامه نویسان بطور مستمر با type ها و instance ها کار می کنند ، اما بصورت کلی از این واژگان استفاده نمی کنند. type یک ایده بسیار عمومی در برنامه های Object Pascal است و شما بعنوان یک برنامه نویس معمولاً متغیرها را از یک type ایجاد می کنید. این متغییر ها instance هایی از type ها هستند.
اشیاء معمولاً پیچیده تر از انواع ساده ای همچون Integer هستند، اما یک کاربر با اختصاص مقادیر مختلف به instance هایی از همان نوع ، می تواند وظایف کاملاً متفاوتی را انجام دهد.
بعنوان مثال ، کاربر روی یک فرم دو دکمه با عناوین OK و Cancel قرار می دهد . هر دو ، instance هایی از نوع TButton هستند، اما با اختصاص مقادیر مختلف در خصوصیت Caption هر کدام، تعیین خصوصیت Default و Cancel ، و رویداد OnClick متفاوت برای هر کدام ، دو عملکرد متفاوت از این دو instance یکسان بوجود می آورد.
مشتق کردن type های جدید
هدف از تعریف type های شیء ، ارائه مبنایی مفید برای instance هاست. به این معنا که ، هدف از ایجاد یک شیء این است که شما یا کاربران دیگر بتوانید در برنامه های مختلف ، و یا بخش های مختلفی از یک برنامه ، از آن استفاده کنید.
دو دلیل برای مشتق کرن type جدید وجود دارد:
- تغییر پیشفرض های type برای جلوگیری از تکرار کد نویسی
- افزودن قابلیت های جدید به یک type
در هر صورت ، هدف ایجاد شیئی است که Reusable (قابل استفاده مجدد) باشد.اگر قصد دارید اشیائی را طراحی کنید ، می توانید خود را از تکرار مقدار زیادی از کار هایی را که قرار است بعداً انجام دهید نجات دهید ، تا در آینده نیز از آنها استفاده کنید. به type های اشیائ خود مقادیر پیشفرض قابل استفاده بدهید، اما آن ها را Customizable (قابل تنظیم) کنید.
بخش های زیر نگاه دقیق تری به دو دلیل بالا ارائه می کند.
تغییر پیشفرض های type برای جلوگیری از تکرار کد نویسی
وظیفه تمام برنامه ها ، جلوگیری از تکرار کار هاست. اگر کد ها را بیش از یک بار بازنویسی می کنید ،باید آن ها را در subroutine یا تابع یا DLL قرار داده تا بتوانید در برنامه های بیشتری از آن ها استفاده کنید. همین استدلال برای کامپوننت نویسی کافیست. اگر اغلب در حال تغییر یک سری خصوصیات و فرا خوانی یک سری method ها هستید ، احتمالاً باید یک نوع کامپوننت جدید ایجاد کرده تا همه این ها را بصورت پیش فرض انجام دهد. بطور مثال ، هر بار که یک برنامه جدید می سازید، یک کادر محاوره ای برای انجام یک تابع خاص نیز اضافه می کنید.اگرچه ساخت مجدد کادر محاوره ای خیلی سخت نیست ، ولی نیازی به این کار هم نیست. می توانید کادر محاوره ای را یک بار طراحی کرده و خصوصیات آن را تنظیم کرده و نتیجه آن را در پالت کامپوننت ها نصب کنید تا برای دفعات بعدی نیز قابل استفاده باشد. با این روش نه تنها جلو دوباره کاری را گرفته اید بلکه با استاندارد سازی احتمال بروز خطا را در ساخت مجدد کادر محاوره ای ، کاهش داده اید.
فصل 9 نمونه ای از تغییر خصوصیات پیش فرض یک کامپوننت را نشان می دهد.
افزودن قابلیت های جدید به یک type
دلیل دیگر برای ایجاد یک نوع جدید از کامپوننت این است که قصد دارید قابلیت های جدیدی را به کامپوننت موجود اضافه کنید. برای انجام این کار می توانید کامپوننت جدید را از یک نوع از کامپوننت های موجود (مثلاً ، ایجاد یک نوع تخصصی از ListBox) یا از یک نوع پایه انتزاعی مثل TComponent یا TControl مشتق کنید.
به عنوان یک قاعده کلی ، کامپوننت جدیدتان را از نوعی مشتق کنید که حاوی نزدیک ترین زیر مجموعه از ویژگی هایی باشد که بدنبال آن هستید. شما می توانید قابلیت هایی را به یک شیء اضافه کنید ، اما نمی توانید قابلیت هایی را از آن جذف کنید. بنابراین ، اگر کامپوننتی که مد نظر شماست خصوصیاتی دارد که شما مایل نیستید در کامپوننت شما وجود داشته باشد ، باید کامپوننتان را از جد یا والد آن کامپوننت مشتق کنید.
بطور مثال ، اگر می خواهید قابلیت هایی را به یک ListBox اضافه کنید ، باید کامپوننت خود را از TListBox مشتق کنید . اما اگر می خواهید قابلیت هایی را به ListBox استاندارد اضافه و قابلیت هایی را از آن حذف کنید ، باید کامپوننت خود را از TCustomListBox مشتق کنید که خود والد TListBox است. سپس قابلیت هایی که می خواهید دیده شود را ایجاد کنید. و در نهایت ویژگی های مد نظر خود را به آن بیافزایید.
فصل 11 مثالی از یک نوع کامپوننت سفارشی که از یک نوع انتزاعی مشتق شده است را نشان می دهد.
اعلان یک نوع کامپوننت جدید
وقتی تصمیم می گیرید یک نوع جدید کامپوننت را ایجاد کنید، باید بدانید که می خواهید آن را از چه نوعی مشتق کنید. همانطور که قابلیت های جدید را به نوعی از کامپوننت موجود اضافه می کنید، ضروریست که از قاعده زیر نیز پیروی کنید :
کامپوننت خود را از نوعی مشتق کنید که شامل بیشترین قابلیت های مد نظر شما باشد و هیچ کدام از قابلیت هایی که مایل نیستید را نیز نداشته باشد.
دلفی تعدادی از انواع کامپوننت های انتزاعی را به منظور طراحی ، برای کامپوننت نویسان ارائه کرده است تا بعنوان کامپوننت پایه از آن ها استفاده کنند. جدول 1.1 که قبلاً مشاهده کردید انواع مختلفی را که می توان با آن ها کامپوننت نویسی را شروع کرد نشان می دهد.
برای اعلان یک نوع کامپوننت جدید ، اعلان type آن را به یونیت کامپوننت ها اضافه کنید . در اینجا نمونه ای از یک اعلان ساده یک کامپوننت گرافیکی را می بینید :
یک اعلان کامپوننت نهایی شده قبل از end ، شامل Property، Field و method خواهد بود. اما بدون این ها نیز یک اعلان معتبر است و می تواند نقطه شروعی برای افزودن ویژگی های کامپوننت باشد. فصل 10 مثالی از ایجاد یک کنترل گرافیکی کامل را نشان می دهد.
کد:type
TSampleShape = class(TGraphicControl)
end;