קטגוריה: Lazarus

לזרוס, חדשות תקופתיות

הרבה זמן שלא היה לי זמן לכתוב את הפינה שלי של חדשות לזרוס, ובנתיים עברו להן מספר גרסאות חדשות (מאז גרסה 1.0).

הנה חלק קטן מהדברים אשר הוכרזו בשלושה חודשים האחרונים בנושא:

ביום שני האחרון (4/02/2013) שוחררה גרסה 1.0.6 של לזרוס אשר מכילה תיקוני באגים בלבד.

בינואר שוחרר הסבר כיצד ניתן לפתח עבור Raspberry Pi באמצעות לזרוס.

שוחררו רכיבים עבור לזרוס לפיתוח טוב ואיכותי יותר עבור iOS. זה כולל הרבה סרטוני ווידאו המסייעים להדריך כיצד לעשות זאת.

מנוע המשחק Castle שיחרר גרסה 4 שלו. המנוע מאפשר לספק API גבוהה לפיתוח משחקים, התחברות למודלים (כדוגמת אלו הנבנים עם blender), ועוד.

אנשים בקהילת הלזרוס של סין (תתפלאו אבל יש כזו קהילה), שיחררו את pascal4android בסוף שנה שעברה.

מערכת בשם Formbox שהיא חצי קוד סגור המספקת מערכות לניהול ווירטואליזציה על בסיס SmartOS השתמשה ב FPC לפתח את כל תשתית הניהול שלה בצד השרת. יש להם רצון לפתוח את המוצר גם כקוד פתוח בנוסף, והם מחפשים לגייס כסף בנושא להמשיך בפיתוח.

אחרון חביב לפוסט זה, הוא Community של FPC/Lazarus ב Google+‎ שאתם מוזמנים גם להצטרף לשם כמובן.

My First Lazarus plugins – split lazarus

I have released today v0.0.1 b2 of my first ever Lazarus plugins – Split Lazarus.
This plugins allow users to split view source code using the Lazarus IDE.

split_lazarus_v001 b2

The following release is just to provide a look and feel, and request for help with testers etc… and by no mean should be used otherwise.
I must say that it was not so simple to arrive to this version due to few factors:

  • First time of writing such thing
  • For debugging my own code, I need to debug the IDE, because I'm executed from within
  • Found a bug with FPC class
  • There are things that I thought that works in one way, but actually in much different way
  • So I needed to rewrite code in that level as well …
The following release contains only few features, such as syntax color, and fonts that are copied from the original editor.
It also provide a splitter between the original editor and the new one, and should not support anything else. So if you find that it does something else, it was by mistake 🙂

The plugins install itself into the Editor tab menu, and also allow you to register a shortcut for it's actions that by default are empty.

Installation:

  • Open the package menu
  • Choose the option of open package file (.lpk)
  • Open the file under the package directory named lazsplitview.lpk
  • At the new opened window, press on compile to make sure that the source can be build. Then choose "Install".
  • You'll be prompt for a question if you wish to build it now, answer "yes"
  • Lazarus will be booted up and enjoy 🙂

Split Lazarus v0.0.1 build 2

לפני חודש בערך, הזכרתי כי אני כותב תוסף ללזרוס.

split_lazarus_v001  b2

התוסף מאפשר לעשות split view עבור העורך של לזרוס, ובכך לאפשר לבצע עריכה ו/או צפיה בקוד תחת 2 view ports על אותו טאב בעצם.

להגיע לנקודה הזו היה מאוד לא פשוט בגלל מספר סיבות:

  • פעם ראשונה שאני עושה דבר כזה
  • לדבג קוד למערכת הזו אינו פשוט – צריך לדבג את ה IDE בעצם מתוך ה IDE‏
  • מצאתי באג בספריות של FPC אשר דורש התייחסות
  • יש המון דברים שחשבתי עליהם בגישה איקס ומסתבר שהם ממומשים אחרת בפועל
  • מה שאומר ששכתבתי קוד יותר מפעם או פעמים להגיע לגישה הנכונה

הגרסה הנוכחית יודעת רק להעתיק את צביעת הטקסט, תכונות הגופן ולהציג עצמה כמובן על המסך.
היא לא אמורה לעשות שום דבר מעבר לכך, ואם היא עושה, אז לא במכוון 🙂
התוסף מתקין עצמו בתפריט הימני של הלשוניות אשר מחזיקות בעורכי הטקסט, וגם מאפשרת לרשום עבור הפעולות קיצורי מקשים, אך בברירת המחדל, אינה מקצה כאלו.

גרסה זו נועדה יותר לבדיקות וחוו"ד מאשר שימוש אמיתי בה, ואשמח לשמוע ממכם בנושא

הוראות התקנה

פתחו בלזרוס את התפריט package ושם בחרו באפשרות open package file (.lpk)‎.
בספריית התוסף, בחרו את תת הספרייה בשם package ושם את הקובץ lazsplitview.lpk .
לאחר שנפתח לכם חלון של החבילה, לחצו קודם על כפתור compile לבדוק כי אין בעיות בבניית התוסף, וכשזה מסתיים, בחרו ב install.
לאחר אתחול מחדש של לזרוס, התוסף כבר מותקן אצלכם.

התוסף הראשון שלי חלק ראשון

שנה חדשה, התחלות חדשות, כדוגמת פרסום ה gem שדיברתי עליו, וגם החלטתי לעשות משהו שכבר מספר שנים אני חושב עליו: לכתוב תוסף ללזרוס שיאפשר לעשות split view על עורך טקסט.split_view

כאשר שאלתי אם תהיה התעניינות בנושא, הרבה אנשים בגוגל+ וגם ברשימת הדיוור מאוד אהבו את הרעיון, וגם הם, כמוני לא מבינים מדוע זה לא קיים כבר כחלק מהסביבה, אבל תוסף זה גם טוב 🙂

זו פעם ראשונה שאני כותב תוסף לאיזושהי תוכנה קיימת. עד היום הדבר הכי קרוב לזה היה רק ליצור רכיבים עבור דלפי ולזרוס, אבל כאן אני נוגע בIDE עצמו, ומשנה או מוסיף לו דברים.

אז נכון לשלב הזה, אני עדיין מבצע הרבה ניסויים שונים.
הניסוי הראשון שיצרתי הוא בעצם לראות איך יוצרים את האפקט של split. הניסוי צריך לקחת בחשבון הרבה דברים, למשל להקפיד כי לא יהיה מיקום זהה של הסמנים, עדכון הבאפרים באותו פרק הזמן, וגם להעתיק תכונות של העורך טקסט, למשל צביעה, bookmarks והגדרות שונות.

ואז מסתבר כי לפחות החלק של הבאפר, זה הדבר הקל ביותר בסיפור, ולקח לי כחצי שעmy first pluginsה כולל מחקר (שלקח את רוב הזמן) ליצור כמו שצריך את הבדיקה, ואז לשפצר אותה להיות נכונה תכנותית (למשל DRY).

הניסוי השני, היה לקבל מידע של הIDE, למשל מה העורך הנוכחי המאופשר, ולמצוא איזה תפריט אני צריך לערוך.
בניסוי הזה בעצם יצרתי את התוסף הראשון שלי, כי בשביל לקבל את המידע מהIDE, אני חייב להיות תוסף שלו.
אחרי מחקר, וקריאה של הוויקי, וכן התייעצות קלה, זה נראה קל מידי, וגם הקוד פשוט מידי.

השלב הבא בניסוי יהיה לרשום גם קיצור מקשים למקלדת על אותו תוסף.

Brook Framework

Brook Framework הוא שם לא הכי ברור עבור framework לפיתוח אתרי ווב דינאמיים באמצעות פסקל מונחת עצמים, המשוחררת תחת LGPL 2.brook-framework_hello-world

הסביבה מזכירה מאוד את הרעיון של framework כדוגמת dancer של פרל, וPadrino ברובי.

ההצהרה הרשמית של הפרוייקט היא בתמיכה קלה ב:

  • נהול ניתובים – כל הפעולות מתבצעות לפי ניתובים
  • יכולת עבודה עם פריימוורקים נוספים, המספקים תוספות לעבודה עם ווב
  • תמיכה מובנת בJSON ופעולות שונות עליו
  • תמיכה בפעולות REST והפרדת העבודה לפי סוג הבקשה
  • אינטגרציה עבור Lazarus
  • תמיכה בכתיבת תוספים עבור הframework

ממעט משחק עם הסביבה, לדעתי ניתן גם להגיד כי השימוש במסדי נתונים די קל ופשוט יחסית להרבה frameworks אחרים. אולי בזכות DataSet.

לקח למפתח למעלה משנה ליצור את הגרסה הראשונה לשחרור, ולמעלה מ15,000 שורות קוד שכתב לשם כך.

יחסית קל ופשוט מאוד ליצור ניתובים דינאמיים, וסביבת CGI טבעית לשרתי ווב כדוגמת אפצ'י, אך לא רק.
במידה ומשתמשים בלזרוס, אז בחירה ב Simple CGI application, זה כל מה שנדרש עבור Hello World, אך במידה ולא, יש צורך ליצור שלושה קבצים.
קובץ אחד הוא בעצם ה"תוכנה" שלנו, שהיא הcgi. קובץ נוסף הוא ברוקר שלנו שיודע לדבר עם שרת HTTP, והקובץ השלישי זו בעצם התוכנית שלנו. כמובן שניתן להוסיף עוד קבצים/מחלקות לפי הצורך.

אפשר להשוות זאת למשל לסינטרה, בה קובץ הראשון הוא כדוגמת config.ru, הקובץ השני הוא Rack והשלישי זה המודול של סינטרה.

הרעיון הוא שכל מחלקה אחראית על נתיב מסויים (path info), ממש כמו ב Rails למשל, ואנו רושמים את הנתיב בחלק הinitialization של היחידה:

...
initialization
  TMyClassHandler.register('/info/:user');
end.

המחלקה בעצם רשמה את עצמה לנתיב של info – כלומר http://example.com/info/ik

הפרוייקט עצמו מורכב מעוד מספר תתי פרוייקטים אשר מספקים את היכולות השונות, ולי לקח קצת זמן להבין זאת, בשביל להבין מדוע אינני מצליח להבין איפה התלויות להתקנה עבור לזרוס.

אתם מוזמנים לבדוק ואף לתרום חזרה לפרוייקט.

מלח הארץ

לאחרונה אני מוצא צורך לממש דברים בעצמי במקומות שהייתי מצפה שיהיה מימוש קיים לדברים שאני צריך. אז לפני שאני כותב משהו, אני מעדיף לחקור דברים לעומק, ולהבין כיצד הם בעצם עובדים.
למשל אני זקוק למערכת ניהול משתמשים וסיסמאות, וכל מה שמצאתי עבור מה שאני עובד בו, כתוב בצורה שלדעתי לפחות, לא מספיק מאובטחת, אז החלטתי לכתוב אחד בעצמי. זה לא כזה מסובך, או הרבה עבודה (מסתבר).

כאשר שומרים פרטים של משתמש וסיסמה, חשוב לא לשמור את הסיסמה עצמה, אלא חתימה חד חד ערכית שלה.
הסיבה לכך מאוד פשוטה: אם בטעות מישהו מצליח לגשת למסד הנתונים, הוא לא ידע מה הסיסמה של המשתמשים שלך, ובכך לפחות עמודת הסיסמאות אינה שימושית בצורה ה"רגילה" שלה.
בשביל שהיא כן תהיה שימושית, צריך בעצם ליצור סוג של מילון שמתרגם hash למה שהרכיב אותו.

בשביל להפריע לתרגום של ה hash שהוא חייב להיות ייחודי לאוסף הבתים של הסיסמה, המציאו דרך של תוספת. התוספת הזו נקראת Salt. היא בעצם "ממליחה" את חתימת הסיסמה עם עוד תוספת שייחודית פר יצירת סיסמה (ואסור לה לחזור שוב פעם במסד הנתונים בשביל שתהיה מספיק בטוחה). הסיבה היא, שבמידה ויש יותר ממשתמש אחד עם אותה הסיסמה, עדיין החתימה תהיה ייחודית, ובכך גם אם "גיליתי" את הסיסמה של משתמש אחד באמצעות "תקיפה" של hash, עדיין זה לא יהיה רלוונטי לשאר הסיסמאות שחוזרות על עצמן.

השימוש בSalt אומר כי החתימה היא בעצם הSalt פלוס הסיסמה (או הסיסמה פלוס ה Salt). יש עוד הרבה דרכים לעשות את זה, כדוגמת הוספת ביטים/בתים לסוג הhash וכו' כאשר משתמשים בSalt, אבל העיקרון בסופו של דבר אומר, כי החתימה של הסיסמה זה Salt וסיסמה בייחד, ולא רק הסיסמה לבד.

כאשר "חותמים", כיום מומלץ בחום לא לעבוד יותר עם md5, היות ויש לו התנגשויות. כלומר ישנה יותר מסדרת בתים אחת שיכולה להיות עם אותה חתימה. אז אני משתמש ב sha256 במקום. הנה קוד רובי המדגים כיצד יש לבצע זאת: להמשיך לקרוא

יחידות בדיקה עם fpcUnit

הקדמה

ישנם מספר ספריות לבדיקה עבור שפת פסקל. הספרייה הכי וותיקה שאני מכיר נקראת DUnit, והיא שוחררה לראשונה ב1999, כמימוש jUnit עבור דלפי. ד"א jUnit למיטב ידיעתי היא מימוש ג'אווה של SUnit עבור שפת Smalltalk.
fpcUnit הוא סוג של מימוש מחודש עבור FPC ולזרוס. fpcUnit מגיע בשני טעמים:

  1. הצגה גרפית של בדיקות
  2. הצגה טקסטואלית (כולל ייצוא למספר פורמטרים) של בדיקות

הוא תומך במרבית התחביר של דלפי, אבל מציג גם תחביר חדש לגמרי. לפרוייקט עצמו יש פורק שמוסיף לו עוד תכונות, כדוגמת יכולת לאתחל מידע בהתחלת ריצת המערכת, ושחרור בסיומה לפני היציאה. כך למשל במסדי נתונים, ופעולות מאוד יקרות, ניתן ליעל את זמן הריצה והתגובתיות.

צורת עבודה

הרעיון:

הרעיון הכללי הוא ליצור "תוכנה" אחת שמריצה הרבה unit tests, שבפסקל, זה באמת יחידות :). היחידות נרשמות בחלק ה initialization של היחידה, באמצעות RegisterTest. אשר לוקח את המחלקה של הבדיקות ורץ על הפרוצדורות השונות לבדיקה.
המחלקה יורשת מ TTestCase, וכל פרוצדורות הבדיקה (הרי אנחנו רוצים לפרק את הבדיקות לחלקים הגיוניים), חייבת להיות בחלק ה published, בשביל שתוכל לרוץ.
ישנה מתודה אחת שבמידה וצריך לאתחל מידע, צריך להגדיר אותה (בחלק ה protected) בשם SetUp. במידה והגדרנו את SetUp מומלץ גם להגדיר מתודה בשם TearDown שעושה בדיוק הפוך.

אני ממליץ לבקש מלזרוס ליצור לנו את השלד עבור הבדיקות, אך לא חייבים אותו לשם כך, אבל מכאן והלאה, אני מניח שעשיתם זאת.
להמשיך לקרוא

יצירת מסד נתונים בזמן ריצה

אחת הפעולות המעצבנות ביותר שאני מגלה בהתקנות בלינוקס, היא שאין יצירה של מסדי נתונים בקוד, אלא דורשים ממני ליצור בעצמי את מסד הנתונים בשביל להתחיל לעבוד עם התוכנה.

אז החלטתי להציג כמה קל ופשוט כאשר עובדים בכלים הנכונים ליצור מסדי נתונים בקוד עצמו. החלטתי להשתמש ב Firebird SQL, סתם כי אני יכול 🙂

createdb

אם אתם עוקבים אחרי הבלוג שלי, אתם יודעים כבר כי המסך הזה נוצר באמצעות לזרוס, ומדובר בסה"כ בLabel ו Edit , עם קינוח של Button.
בנוסף זרקתי רכיב לא וויזואלי של TIBConnection, שמטפל לנו בחיבור למסד נתונים מבוסס Firebird.

אשאיר לכם להשקיע 2 דקות מזמנכם לטפל במראה המתאים לכם.

לאחר מכן, באירוע של הכפתור, אצור את הקוד הבא:

procedure TfrmDBCreate.btnCreateClick(Sender: TObject);
var Transaction : TSQLTransaction;
begin
  FBConnection.DatabaseName := edtDatabaseName.Text;
  FBConnection.CharSet      := 'UTF8';
  FBConnection.HostName     := edtHost.Text;
  FBConnection.UserName     := edtUserName.Text;
  FBConnection.Password     := edtPassword.Text;
  Transaction               := TSQLTransaction.Create(nil);
  FBConnection.Transaction  := Transaction;
  try
   FBConnection.CreateDB;
   FBConnection.ExecuteDirect('CREATE table test1 (name varchar(24) not null)');
   Transaction.Commit;
   MessageDlg('Info', 'The database was created.', mtInformation,
             [mbClose], -1);
  except
    on e : EIBDatabaseError do
     begin
       MessageDlg('Error', 'Could not create database : ' + LineEnding +
                  e.Message, mtError, [mbClose], -1);
     end;

     on e : Exception do
       begin
        MessageDlg('Error', 'Unknown error : ' + LineEnding + e.Message,
                 mtError, [mbClose], -1);
       end;
  end;
  Transaction.Free;
end;

קודם כל אנחנו מזינים לTIBConnection את הפרמטרים שהוזנו, כדוגמת קובץ מסד הנתונים, הכתובת של השרת, בנוסף החלטתי להשתמש ב UTF8 כקידוד למחרוזות.
בנוסף יצרתי רכיב עבור טרנזאקציות, הוא צריך להיות בשימוש לשאילתא שאריץ לאחר יצירת מסד הנתונים (כל השימוש בו).
בתוך try אני אומר למנהל החיבור למסד נתונים ליצור את מסד הנתונים. חשוב לדעת כי זה קיים בכל החיבורים שלנו למסדי נתונים המבוססים DataSet, ולא ייחודי ל Firebird.
לאחר מכן, החלטתי גם להציג כיצד ניתן ליצור בתוך אותו קוד טבלה, אז יצרתי טבלה בשם test1 עם שדה בשם name שהוא מסוג varchar ומסוגל לקבל עד 24 תווים.
נעשה על השאילת commit, ואנחנו מוכנים !

במידה ויש חריגה בעת הריצה, אז אם מדובר בחריגה של מסדי הנתונים, נציג על כך הודעה מיוחדת, אחרת, נציג הודעה כללית על השגיאה שהתקבלה.
בסוף אני משחרר את הטרנזאקציה, וזהו, זה כל הקוד שצריך.

מי אמר שעבודה עם מסדי נתונים צריכה להיות כואבת ?

את קוד המקור תוכלו למצוא כאן
 

צפייה בעץ חלק שני

עבר הרבה זמן מאז שיצרתי את החלק הראשון, והגיע הזמן להשלים חוסרים.

Program using VirtualTreeView

תוכנה בשם precisionhelper המשתמשת ברכיב

יש רכיב צד שלישי הנקרא VirtualTreeView אשר נכתב במקור לדלפי ומגיע כקוד פתוח (LGPL).
הרכיב לא ניתן לעבודה בברירת מחדל עם לזרוס), והוא עובר מספר שינויים על מנת לקבל תמיכה בלזרוס, כאשר השינויים נמצאים ב Lazarus-CCR.

הרכיב מאפשר ליצור שליטה מלאה בעבודה אשר בברירת מחדל זהה לרכיב העץ (עליו דיברתי בחלק הקודם), אבל מספקת המון יכולות ותכונות אשר לא קיימות ברכיב המקורי, כדוגמת היכולת לייצג מידע אמיתי בצורה של עץ, שינוי תפיסה וויזואלית של הדברים, עבודה בסגנון Grid, אנימציה בתצוגת המידע, כולל תמיכה בהאצת חומרה, ציור של מידע בצורה מותאמת אישית, תוכנן במקור לתמוך בדו כיווניות (עברית וערבית) וזה אפילו לא מכסה את פסגת קצה הקרחון. להמשיך לקרוא

*LazPackager

lazDebian

LazPackager היא חבילה עבור לזרוס המאפשרת ליצור חבילות deb (עבור דביאן, אובונטו, מינט וכו') הישר מתוך לזרוס, ומנסה להקל מאוד על התהליך.

החבילה מאפשרת גם לחתום את החבילה ולהעלות אותן אל מאגר ה PPA של אובונטו.

בנוסף, היא מאפשרת ליצור קובץ tar המקורי שדרכו ניתן ליצור את החבילות, ובכך לספק חבילת "קוד מקור", אשר יכולה להעלות בצורה נכונה אל חווות ליצירת חבילות בצורה תקינה.

לא ניסיתי את החבילה בעצמי, וגם אין לי הפצה מבוססת deb לנסות' כך שאינני יכול להוסיף יותר מניסיון אישי.

קוד המקור של החבילה.

* החבילה שונתה בשמה מ LazDebian לLazPackager

TAChart – חלק רביעי

בחלק הקודם התעסקתי רק על הפיכת הטבלה לדבר לפעולה התשרת את הוספת הערכים לעוגה. הגיע הזמן אבל ליצור עוגה, כי אם מקודם הייתי קצת רעב, תארו לכם מה קורה אחרי ארבעה ימים…

יצירת הגרף

את פעולת היצירה חילקתי לשני חלקים:

  1. אתחול המידע
  2. הזנת הנתונים לעוגה

TAGraph עובד עם "סדרות". הסדרות הללו הן למעשה סוגי הגרפים עבור TAGraph. אתם בטח מבינים כי מן הסתם, סדרה בשם TPieSeries מדברת על גרף מסוג Pie.
התחלתי קודם בחלק האתחול. היות והוא צריך לרוץ רק פעם אחת, אבל הכנסתי אותו למתודה משל עצמו וקראתי לה בשם initpie. יצרתי גם שדה בשם pie מסוג TPieSeries שהוא גלובלי במחלקה של החלון.

בראש ובראשונה אני רוצה לאתחל את pie, אח"כ לספק לו כותרת. במידה ואתם רוצים (אני לא אוהב את זה במיוחד), ניתן גם להגיד לו לפצל כל פלח בעוגה.
לאחר מכן, אני החלטתי לטפל קצת באיך המקרא יראה, כולל איזה טקסט יוצג שם (עבודה עם חוקי format string של פסקל). גם החלטתי כי הקבוצה שאליה הגרף שייך היא קבוצה מספר 0.

לאחר המקרא, החלטתי להתחיל לטפל באיך כל נתון יקבל ייחס. החלטתי לתת צבע צהוב בהיר לרקע התווית, ושהעט המציירת אותה תהיה ברוחב 2 פקסלים.
התווית עצמה תציג גם את השם וגם את הערך של כל איבר בגרף.

לאחר מכן, החלתי לטפל קצת במקרא של Chart עצמו. והוספתי קבוצה מספר 0, בשם Pie. לאחר מכן, הוספתי את הסדרה שיצרתי:

procedure TForm1.initpie;
begin
  Chart.ClearSeries;
  pie          := TPieSeries.Create(Chart1);
  pie.Title    := 'Pie Chart';
  pie.Exploded := False;
  with pie.Legend do
   begin
     Multiplicity := lmPoint;
     Format       := '%2:s (%1:.2f%%)';
     GroupIndex   := 0;
   end;

  with Pie.Marks do
   begin
     LabelBrush.Color  := $80FFFF;
     LinkPen.Width     := 2;
     Style             := smsLabelPercent;
     OverlapPolicy     := opHideNeighbour;
     Visible           := true;
   end;

  with Chart.Legend do
   begin
     GroupTitles.Clear;
     GroupTitles.Add('Pie');
     Chart.AddSeries(pie);
   end;
end;

חשוב לזכור כי את כל הדברים האלו ניתן גם לבצע בצורה גרפית לחלוטין, אבל רציתי קצת להראות איך הקוד נראה, במידה ואנחנו בוחרים לעשות את זה בקוד.
היות ואנחנו יוצרים את pie, צריך גם לשחרר אותה. אז הלכתי לאירוע של החלון הנקרא OnDestroy והוספתי שם את הקוד הבא:

procedure TForm1.FormDestroy(Sender: TObject);
begin
  if Assigned(pie) then
    FreeAndNil(pie);
end;

וכך אני מונע דליפת זיכרון בקוד שלי, בעת סגירת החלון.

השלב הבא שלי, היה בעצם לספק את הנתונים עבור הגרף. וברגע שאני מסיים לספק אותם, הם מוצגים על המסך.
לשם כך הלכתי לאירוע של btnApply והוספתי שם את הקוד הבא:

procedure TForm1.btnApplyClick(Sender: TObject);
var i    : integer;
    acol : TColor;
begin
  if not Assigned(pie) then initpie; // first time applying ... it can have memory leak if we apply it every time
  pie.Clear;
  for i := 1 to sgGraphDetails.RowCount -1 do
   begin
     with sgGraphDetails do
      begin
        if Cells[2, i] = '' then continue; // empty content
        acol := clTAColor; // set color automatic
        if Cells[3, i] <> '' then // unless we choose one ...
          acol := StringToColor(Cells[3, i]);

        // Add the values
        pie.Add(StrToFloat(Cells[2, i]), Cells[1, i], acol);
      end;
   end;
end;

ועכשיו אנחנו גם מציגים את העוגה. הבעיה היא שאני עדיין לא יכול לאכול אותה, כי היא נמצאת רק בחלון 😦
הבטן מציקה לי מאוד, ואני חייב כבר לאכול את העוגה.

אז הגיע הזמן לייצא את התוצר החוצה.
למרות שיש הרבה מאוד סוגי תמונות אליהם ניתן לייצא, החלטתי לתמוך בהדגמה שלי רק ב6 סוגים נפוצים:

  1. Windows Bitmap (bmp)‎
  2. Jpeg (jpg)‎
  3. Portable Network Graphics (png)‎
  4. Portable Map Graphics (ppm)‎
  5. X Pixmap (xpm)‎
  6. SVG

לשם כך הגדרתי קצת את הפילטר של SaveDialog. אתן לכם לשחק איתו קצת, היות והוא מאוד פשוט להגדרה בצורה גרפית.
הקוד שכתבתי, עובד לפי הסדר שרשמתי כאן ובנוי לפיו.

למעט SVG, לייצא לפורמט מפת סיביות כלשהי, זה יחסית מאוד פשוט. הקוד האמיתי הוא עבור ה SVG.

procedure TForm1.btnExportClick(Sender: TObject);
var fs : TFileStream;
    id : IChartDrawer;
begin
  if not SaveDialog.Execute then exit;

  case SaveDialog.FilterIndex of // lets see what type of image they want
    1 : Chart.SaveToBitmapFile(SaveDialog.FileName);                          // bitmap
    2 : Chart.SaveToFile(TJPEGImage, SaveDialog.FileName);                    // JPeg
    3 : Chart.SaveToFile(TPortableNetworkGraphic, SaveDialog.FileName);       // PNG - our default
    4 : Chart.SaveToFile(TPortableAnyMapGraphic, SaveDialog.FileName);        // PPM
    5 : Chart.SaveToFile(TPixmap, SaveDialog.FileName);                       // XPM
    6 : begin                                                                   // SVG
          fs := TFileStream.Create(SaveDialog.FileName, fmCreate);
          try
            id                       := TSVGDrawer.Create(fs,true);
            id.DoChartColorToFPColor := @ChartColorSysToFPColor;
            Chart.Draw(id, Rect(0,0, Chart.Width, Chart.Height));
          finally
            fs.Free;
          end;
        end;
  end;
end;

החלטתי להשתמש בסטטיסטיקה של w3school על דפדפנים, והשתמשתי בנתונים שלהם לחודש אוגוסט 2012.
זהו, עכשיו אפשר לקחת את התוצר ולאכול. בתאבון 🙂
tachart browser statistics

את קוד המקור, ניתן להורד מgithub.

TAChart – חלק שלישי

בחלק הקודם, יצרתי את הסביבה הגרפית ליצירת הגרף, בחלק הזה אתמקד בכל מה שקשור להכנה ליצירת הגרף עצמו, ובחלק הבא (שהוא האחרון), אתמקד בגרף עצמו וביצוא שלו לתמונה.

כתיבת קוד

החלטתי קודם להתעסק קצת ב"קוסמטיקה" שהיא קצת חשובה. הקוסמטיקה היא הוספה והסרה של שורות, וכן התגובתיות של הרכיבים. אבל הם חשובים מאוד כי רק באמצעותם ניתן בעצם ליצר את הגרף עצמו, וכן לאפשר או לא לאפשר פעולות למשתמש.

הלכתי קודם לכפתור הנקרא btnAddItem , לחצתי עליו פעמים, והוא פתח בעורך הטקסט מתודת Callback בשם btnAddItemClick. ניתן לראות אותה גם בObject Inspector במידה ונלך לטאב הנקרא Events. זהו אירוע ברירת המחדל של כפתור, ולכן הוא זה שבעצם הוגדר.

הקוד עבור הcallback מאוד פשוט. אנחנו הולכים להוסיף לו 2 שורות. הראשונה אומרת להוסיף עוד שורה, השניה הולכת לשים מספור מתאים לתא, ובכך נקבל מספורים כדוגמת "1, 2, 3" וכו' … פר שורה:

procedure TForm1.btnAddItemClick(Sender: TObject);
begin
  sgGraphDetails.RowCount := sgGraphDetails.RowCount + 1;
  sgGraphDetails.Cells[0,sgGraphDetails.RowCount -1] := IntToStr(sgGraphDetails.RowCount -1);
end;

השלב הבא יהיה להסיר שורה על ידי הוספת Callback עבור btnRemoveLastItem:

procedure TForm1.btnRemoveLastItemClick(Sender: TObject);
begin
  if sgGraphDetails.RowCount > 1 then
    sgGraphDetails.RowCount := sgGraphDetails.RowCount - 1;
end;

אנחנו גם בודקים, אם אנחנו לא חורגים מהגבולות שלנו, כאשר כאן מדובר בשאלה האם יש לנו יותר משורה בודדה, ורק אם כן, נבטל שורה אחת.

עכשיו נלך לעשות "טריק" פשוט. הפעלת וביטול פעולות של מחיקה ורינדור. אם אין מידע, או שורות, אני לא רוצה לעשות סתם פעולות, אשר לפחות ברינדור, הן לוקחות כוח מיחשוב שיכול להיות גדול, ובהסרת שורות, במידה ואין אפשרות, סתם תהיה "פרצה הקוראת לגנב".
לשם כך, הלכתי לטאב הEvents בחרתי ברכיב של sgGraphDetails, ובאירוע OnColRowDeleted. לחצתי עליו פעמיים, וכתבתי את הקוד הבא:

procedure TForm1.sgGraphDetailsColRowDeleted(Sender: TObject; IsColumn: Boolean;
  sIndex, tIndex: Integer);
begin
  btnRemoveLastItem.Enabled := sgGraphDetails.RowCount > 1;
  btnApply.Enabled          := sgGraphDetails.RowCount > 1;
end;

אני מבצע בדיקה לוגית (במקום שאלת if), האם יש יותר משורה אחת בודדה, ואם כן, רק אז לאפשר את הכפתורים.
אבל זה לא מספיק ! הרי מה קורה כאשר אני מוסיף שורה ?
אז חזרתי לטאב הEvents של sgGraphDetails, ובאירוע OnColRowInserted בחרתי מהרשימה את sgGraphDetailsColRowDeleted, ולמעשה יש לי שני Callbacks אשר מצביעים על אותו הקוד, רק מתרחשים בזמנים שונים.

השלב הבא הוא לחשוב מה קורה כאשר אנחנו בעצם רק יוצרים את החלון. הרי הכפתורים בברירת המחדל מאופשרים, אבל לא באמת ניתן למחוק או לרנדר משהו.
אז הלכתי לאירוע של הטופס עצמו, ויצרתי את הקוד הבא, ועל הדרך גם הוספתי עוד כותרת אחת רק בקוד:

procedure TForm1.FormCreate(Sender: TObject);
begin
  sgGraphDetails.Cells[0,0] := '#';
  btnRemoveLastItem.Enabled := sgGraphDetails.RowCount > 1;
  btnApply.Enabled          := sgGraphDetails.RowCount > 1;
end;

עד כאן הקוד מאוד פשוט נכון ?
זוכרים שזרקתי על החלון, רכיב דיאלוג של צבעים ?
הגיע הזמן להשתמש בו, ולקשר אותו בעצם לטבלה ששמתי.
אז הלכתי לאירוע של OnButtonClick ברכיב sgGraphDetails ולחצתי עליו פעמיים.
שם בעצם אני בודק קודם כל מה העמודה שלחצו בה, ורק אם זו העמודה הנכונה, אני מציג את הדיאלוג.
לאחר הצגת הדיאלוג, במידה והמשתמש מאפשר לי (כלומר לא לחץ על cancel), אני מוסיף את הצבע הנבחר.
התאוריה נחמדה, והיא נראת ככה בצורה מעשית:

procedure TForm1.sgGraphDetailsButtonClick(Sender: TObject; aCol, aRow: Integer);
begin
  if (aRow >= 1) and (aCol = 3) then
    begin
      if ColorDialog.Execute then
        begin
          sgGraphDetails.Cells[aCol, aRow] := ColorToString(ColorDialog.Color);
        end;
    end;
end;

אם חושבים על זה לעומק, הבעיה החמורה ביותר שיש היא האפשרות שהאחוזים לא יהיו מספר עשרוני.
אש צריך להגיד בקוד שבמידה ומזינים ערך לא חוקי, פשוט לא לקבל את זה בעת ההזנה (ולא אחרי).
לשם כך החלטתי לממש את זה דווקא באירוע בשם OnSetEditText. הסיבה לכך פשוטה. אני רוצה שבזמן הקביעה מה הוא העריכה, אני אחליט אם זה תקין או לא:

procedure TForm1.sgGraphDetailsSetEditText(Sender: TObject; ACol, ARow: Integer;
  const Value: string);
var num : double;
begin
  if (ACol = 2) and (Value  '') then
    begin
      if not TryStrToFloat(Value, num) then // do we have a real floating point number ?
        begin
          sgGraphDetails.Cells[ACol, ARow] := '';
        end;
    end;
end;

כאן אני מנסה להמיר בזמן העריכה את הערך שהתקבל. במידה והוא מתאים למספר עשרוני, אני לא נוגע בתוכן, אבל במידה והוא לא, אז אני הופך את התא לריק.
אם נרצה ליצור תוכנה מלאה, ולא רק הדגמה, אבדוק כאן כי העמודה של הצבעים גם מכילה טקסט תקין עבור צבע. אך במקרה הזה, החלטתי שלא להוסיף לכך קוד.

בחלק הבא (כאמור), אציג כיצד להגיע תאכלס ליצירת הגרף.

TAChart – חלק שני

בחלק הקודם, דיברתי על קצה המזלג אודות TAChart. בשל אורך הפוסט, הוא חולק למספר חלקים, וסה"כ יהיו 4 חלקים לכל הנושא (כולל הפוסט הקודם), בשביל להקל על הקריאה.

tachart_example

חשבתי להתחיל לפשט דברים, אז בחרתי להציג גרף מסוג פאי (גם הייתי קצת רעב, אני חייב להודות).

במקום ללמד אתכם לתכנת רק וויזואלית (הכוח של לזרוס), החלטתי לשלב בין השניים. הגדרות מאוד בסיסיות מוגדרות בצורה גרפית, כל השאר בקוד. בחלק הזה, אתמקד בחלק הוויזואלי בתכנות. החלקים הבאים יתמקדו בקוד עצמו.

חשוב להדגיש כי כל מה שיצרתי בצורה וויזואלית, ניתן לבצע דרך קוד, ומרבית הדברים שכתבתי בקוד (אך לא כולם), יכולים להתבצע גם בצורה וויזואלית.

עיצוב וויזואלי

דבר ראשון, ניצור לנו אפליקציה חדשה עם לזרוס. נלך לטאב של Standard אשר סבור להניח כי כבר מצביע לכם על דברים, נזרוק על הטופס TPanel, ונגיד לו כי Align הוא Bottom. זה אומר לרכיב שתמיד ידאג להצמיד את עצמו לתחתית הcontiner שלו, במקרה הזה כמובן, זה החלון שלנו.

הרכיב קיבל את השם Panel1. אני שיניתי לו את השם ל pnlBottom, בשביל לתאר את התפקיד שלו. עבורי לפחות זה אומר שהוא מכסה את האיזור התחתון רק כ container.  סוג של דרך שמות שהרגלתי את עצמי לתת לתפקיד שכזה.

לאחר מכן, נלך לטאב של Additional ונזרוק לנו על ה pnlBottom את הרכיב TStringGrid. זה בעצם הרכיב שאיתו נבצע את העריכות שלנו.

גם לרכיב זה, שיניתי את השם, וגרמתי לו להיות sgGraphDetails. המקדם מסביר כי זה StringGrid, בעוד שהשם מסביר לי מה הוא עושה.

נזרוק 4 כפתורים (תבחרו את הסוג שלדעתכם מתאים) אל pnlBottom , ונתחיל לשחק עם העיצוב שנרצה לקבל.

אני למשל בחרתי כי הכפתורים יהיו בצד ימים, ומסודרים לפי סוגי פעולות. כאשר ה2 העליונים תמיד דבוקים כלפי מעלה, והשניים התחתונים כלפי מטה, והם גם תמיד דבוקים לצד ימין (כל הארבעה). מבצעים זאת על ידי שימוש בתכונה Anchors (ראו את התמונה למעלה).

  • הכפתור הראשון קיבל כותרת של Add Item. והוא קיבל את השם btnAddItem.
  • הכפתור השני קיבל את השם Remove Last Item .השם אותו קיבל הוא btnRemoveLastItem.
  • הכפתור השלישי קיבל כותרת של Apply. והשם שלו הוא btnApply.
  • הכפתור הרביעי קיבל כותרת של Export. וכמובן שהשם שלו כמו שאתם כבר מזמן, מבינים הוא btnExport.

לאחר מכן, היה קל יותר למקם את sgGraphDetails. אותו מיקמתי להיות צמוד גם לימין, גם לשמאל, גם למעלה וגם למטה, וברוחב שתמיד לא יתנגש עם הכפתורים. עושים זאת קודם כל על ידי שינוי הגדלים בצורה חופשית, ואז משתמשים שוב בAnchors על מנת להשיג זאת.

אמרתי לsgGraphDetails, שיש לו רק שורה אחת כרגע  על ידי שינוי התכונה RowCount.
לאחר מכן בתכונה Options, הודעתי כי האפשרות לעריכה מאופשרת.
עם ה StringGrid, הלכתי להגדיר את תכונת ה Columns בצורה וויזואלית.

  • העמודה הראשונה שהגדרתי קיבלה כותרת בשם Name. וזהו השינוי היחיד שהיא קיבלה.
  • העמודה השניה שהגדרתי קיבלה כותרת בשם Percentage וגם כאן זה השינוי היחיד.
  • העמודה השלישית, קיבלה את הכותרת Color, אבל קיבלה עוד שינוי: ButtonStyle מצביע על כפתור בעל שלוש נקודות (Ellipsis), היות ואנחנו נאפשר למשתמש לבחור בצורה וויזואלית איזה צבע הוא מעוניין להשתמש עבור כל עמודה לגרף.

לאחר מכן, זרקתי על הטופס, רכיב בשם TSplitter. כיוונתי אותו באמצעות align להיות צמוד לBottom. הוא יאפשר לנו לשנות את גודל הTPanel וכן של הגרף בצורה דינאמית. הרכיב צריך להיות מעל pnlBottom.
הSplitter קיבל את השם spltBottom.

עכשיו הלכתי לטאב הנקרא Chart וזרקתי על החלון רכיב בשם TAChart, והגדרתי אותו עם Align להיות על הclient, דבר שאומר כי הוא תופס את כל הגודל הפנוי האפשרי.

שיחקתי עם הגדרות ה Legend של Chart (הייתי מאוד מקורי בשם שלו, תודו) שיתאימו לצורך ולמראה שאני רוצה, וכן שיניתי את הוויזואליות של הצירים, וצבע הרקעים השונים, וזה כל השינויים שעשיתי וויזואלית.

זרקתי גם מטאב Dialogs שני רכיבים. זרקתי את TColorDialog לבחירת צבע, וכן SaveDialog, לייצא יותר מאוחר את הגרף.

tachart_designtime

TAChart – חלק ראשון

להכיר על TAChart על קצה המזלג

TAChart הוא למעשה סדרה של רכיבים עם המון כוח ועצמה בלזרוס. הסדרה של הרכיבים מאפשרת לנו ליצור גרפים ממספר מקורות שאנחנו בוחרים כגון הזנה עצמית, מידע "hard coded", הזנה ממסד נתונים וכו' …

tachart browser statistics

אבל זה אפילו לא מתחיל לתאר את הרכיבים. הרעיון של הרכיבים הוא לאפשר גמישות ליצור איזה סוג גרף העולה כצורך על המתכנת. הוא מבצע את זה על ידי הפרדה בין הצגת הגרף לבין מערכת חישוב הגרפים עצמה. ואם זה לא מספיק, הוא מאפשר ליצור עוד סוגי גרפים כרכיבים או תוספות משל עצמנו, כולל אפשרות של "ציור עצמי".
ניתן גם להוסיף מספר גרפים למערכת הציור בו זמנית, ולא להסתפק רק בגרף בודד בכל פעם.

על זה, אנחנו מוסיפים את היכולות המדהימות שלו לעבוד גם בצורה לא גרפית, כלומר אני יכול ליצור מערכת גרפים שלמה באתר לדוגמה, ולשמור כתמונה. אני יכול לעצב כל אלמנט במערכת הזו, ואפילו ליצור תמונה של "זום" רק על נקודות מדוייקות שאני רוצה להציג, במקום את כל הגרף.

הרכיבים יודעים גם להיכנס למערכות של דו"חות כדוגמת LazReport ובכך גם להתאים את עצמה לדו"ח מודפס, PDF וכו'. למעשה את הרכיבים לא מעניין סוג "בד הציור" עליהם הם נמצאים, כך שאפשר למשל לעבוד איתם באמצעות OpenGL, מערכת BGRA או אפילו מערכת Agg. זו הסיבה שאפשר כאמור ליצור מהם SVG בנוסף לתמונות Bitmap,  PDF וכו' ….
אבל זה לא הכל. ניתן גם להציג את הגרפים כיום בצורת אנימציה ובכך גם להמחיז את השינויים השונים, ולא לקבל אותם רק בצורה "יבשה".

הרכיבים ממשיכים להיות בפיתוח מתמיד כבר מספר שנים, ומאוד מומלץ לקחת אותם לסיבוב. מבטיח כי לא תתאכזבו מהתוצאות.

בחלק הבא, אציג כיצד יצרתי את התמונה למעלה, ואיך ליצור קוד אשר יבצע אותה בפועל.

Display Quote ההמשך

עברו כבר 10 חודשים מאז שהפסקתי לעבוד על Display Quotes, אבל לאחרונה בגלל מספר סיבות, חזרתי לפרוייקט כסוג של מנוחה ורגיעה מסויימת.

הדבר הראשון שעשיתי, היה להוסיף רישיון לפרוייקט בצורה רשמית. הוא כרגע משוחרר ברישיון MIT. מבחינתי תעשו מה שאתם רוצים עם מה שיצרתי. אם זה לימוד, שימוש כתוכנה, או כל דבר אחר העולה על רוחכם. אני עושה את זה כתחביב נטו.

display_quote_navigation_mode

החלטתי עכשיו לשים לעצמי 2 מטרות לגרסה שאני יוצר:

  1. ליצור תמיכה בהוספה, עריכה, מחיקה ושמירה של ציטוטים באמצעות הממשק
  2. אפשרות לפרסם לפייסבוק את הציטוט שעומד מולכם.

הבעיה עם פייסבוק, היא שאסור לי לפרסם את הסיסמה שהפרוייקט קיבל, ובנוסף אני צריך ליצור או להתחבר למימוש של OAuth2, אשר שונה מ OAuth1 למשל …

הבעיה עם פייסבוק קצת מונעת מתוכנת קוד פתוח לפתוח את הקוד עד הסוף. אני פשוט יצרתי 2 קבצים. קובץ אחד שמכיל את ההגדרות האמיתיות, והוא לא נמצא ב git. הוא מכיל רק את מזהה התוכנה והסיסמה שלה, ככה שלעקוב אחרי זה עם git לא נותן הרבה.

קובץ שני, הוא אותו קובץ, רק בלי המידע, ואתם תוכלו להשתמש בו במידה ותרצו לקחת את התוכנה ולגרום לה לעבוד עם פייסבוק. רק תהיו צריכים לרשום אותה בעצמכם קודם …

ההתחלה שלי היא קודם על העריכה,  היות ואני חושב שזה החלק הפשוט יותר, ומכניס אותי חזרה לקוד שלא נגעתי בו הרבה זמן.

אבל אז מאיר ציין משהו חשוב: הממשק יהיה עמוס אם אוסיף עוד רכיבים אליו. אז חשבתי על פתרון שבו המיקום של פקדי הניווט משתנה לפקדי העריכה. היות ואין היגיון גם לניווט להיות פעיל בזמן עריכה, אני גם עושה לפעולות האלו disable.

display_quote_edit_mode

עכשיו כאשר אני חושב על זה, אני לא יודע כל כך איפה להכניס למשל את הפקד של פייסבוק (בעתיד ארצה גם לפרסם אולי לעוד רשתות חברתיות, כמו Google+‎ למשל), אבל הרעיון להחליף את הפקדים, למעשה עוזר כאן, אז במקום ליצור משהו בינארי (מאחורי הקלעים), אני בעצם שומר "מצבים" של התצוגה. כרגע היות ויש שניים, זה מוצג וויזואלית כפעולה בינארית, אבל אין זה המצב בצורה שאני מתנהג בפועל.

לאחר שאסיים את 2 השלבים האלו, כנראה שהשלבים הבאים יהיו:

  • ניסיון לאתר כפילויות – מימוש אלגוריתמים שונים לזיהוי טקסט במבנה דומה אבל לא זהה (התחלה של מנוע חיפוש ?)
  • מימוש לתמיכה של שורת פקודה. כלומר להפריד לוגיקה בין GUI לבין הצורך האמיתי, ולאפשר להציג את הציטוטים גם באמצעות שורת פקודה, שליחה לפייסבוק, ואולי גם כ pipe לתוכנות אחרות.

עוד רעיונות ממכם יתקבלו בברכה.

הקוד עצמו, ד"א כרגיל נמצא ב github.

Gtk3, GObject Introspection ו Free Pascal

קראתי פוסט מעניין על מצב ה binding של GTK3 בעולם הפסקל, וגיליתי משהו מאוד מעניין: הוא נעשה לגמרי ללא התערבות מתכנתים. זהו סוג של תרגום לפוסט.

ביצוע הBinding משתמש למעשה בפרויקט שקהילת GTK יצרה בשם GObject Introspection.
אם להסביר על רגל אחת את מהות הפרוייקט, אז הוא לוקח את ה API של פרוייקט GTK וממיר את המידע לקבצי XML אותם ניתן לקרוא בכל שפת תכנות.

אז מה שעשו אנשים בעולם הפסקל הוא ליצור מערכת שיודעת לתרגם את אותו קובץ XML אשר קיבל את הסיומת gir, וממירים אותו לקוד פסקל. הפרוייקט אשר ממיר לפסקל נקרא gir2pascal.

קובץ כזה יראה כך: להמשיך לקרוא

לזרוס 1.0

כמעט כמתיחה של אחד באפריל, נוצר לו ענף 1.0 עבור לזרוס בתחילת אותו יום. וזוהי נקודה מאוד חשובה בהיסטוריה של הפרוייקט. אך זו לא היתה מתיחה, ואתמול בלילה לזרוס 1.0 שוחררה לאוויר העולם.

אודות לזרוס

לזרוס 0.9.29 המשתמש ב Qt תחת לינוקס

לזרוס היא סביבת עבודה משולבת (IDE) אשר משוחררת כקוד פתוח ומאפשרת פיתוח מואץ למערכות גרפיות, וכן לכתיבת קוד מקור גם ללא צורך בתכנות גרפי. היא מתמקדת בפסקל מונחה עצמים (ואף כתובה בשפה), אך מאפשרת גם להוסיף תמיכה לשפות נוספות. המערכת בנויה בצורה של חבילות התקנה (מנהל חבילות מאוד דומה לרעיונות הקיימים בלינוקס) המאפיינות את התוכנות שלה, התמיכות שלה בדברים וכיוב'… השימוש בחבילות מאפשרת להוסיף, ואף לשנות את היעוד שלה.

המערכת מאפשרת לפתח יישומים למגוון רחב של פלטפורמות, וסביבות גרפיות, לרוב ללא שינוי הקוד. היא עושה זאת על ידי שימוש בספריות פיתוח אשר מספקות כלים גבוהים יותר במקום להתמודד עם סביבה מסויימת. זו הסיבה שסיסמת הפרוייקט היא write once compile everywhere.

סביבות העבודה אשר כיום לזרוס יודעת לאפשר עבודה מולם הם: MS Windows, Linux, FreeBSD, Solaris, Mac OS X, WinCE, Android, JVM, iOS ועוד מספר מערכות אחרות, בהתאם לתמיכת המהדר.
בנוסף, ישנה תמיכה בסביבות גרפיות כדוגמת Windows GDI, X11, GTK, Qt, Cocoa, Carbon ו fpGUI.

התמיכה הזו מגיעה באמצעות ספריית רכיבים בשם LCL‎ ‏(Lazarus Component Library) אשר תפקידה הוא אספקת כלים להתמודדת עם כתיבת התוכנות הגרפיות (אך לא רק) ללא צורך בלימוד של סביבה מסויימת כדוגמת Windows GDI או Qt.

בנוסף, המערכת מגיעה עם תמיכה מובנת למספר מסדי נתונים בניהם ODBC, SQLite, Firebird SQL, MS SQL, Oracle, MySQL, PostgreSQL, Sybase ואפילו Paradox במידה והותקנו הספריות המתאימות במערכת. בנוסף גם יש תמיכה ל dBase בצורה טבעית.

ישנם תוספות רבות ללזרוס המספקות תמיכה ביותר מסדי נתונים, ואף במימוש שונה לאותם מסדי נתונים, אך הקוד שלך לא ישתנה בגלל שהחלפת מסד נתונים, או מנוע שכזה.

לזרוס אף מגיעה עם תמיכה ברירת מחדל לפיתוח מערכות CGI ברמה נמוכה מאוד בשם fpWeb ועוד מספר כלים אחרים כדוגמת ExtPascal המאפשר לכתוב תוכנת web וויזואלית שמומרת ל ExtJS.

כל זה הוא רק הקדמה בנושא, ויש עוד המון דברים שמקבלים עם סביבת הפיתוח עצמה. להמשיך לקרוא

שינוי תצורת ממשק ה IDE

גרסה 1.0 של לזרוס שהוכרזה בראשון לאפריל, לאט לאט מתקרבת לה, אבל תמיד עולה השאלה לגבי הממשק של לזרוס.עורך טקסט

ללזרוס יש יכולת לקבל "חבילות" (packages) אשר חלקן הן עבור תכנות בזמן ריצה, חלקן לזמן תכנון. אבל זה לא הכל. אפשר גם ליצור חבילה אשר משפיעה על הסביבה עצמה, ואפילו לשנות אותה.

באמצעות חבילה כזו, אפשר ליצור מצב של Dock לסביבת העבודה, אבל לאחרונה גיליתי עוד דרך מדהימה (לדעתי) שמשנה את סביבת העבודה בצורה הזו: KZDesktop.

תכנות גרפיהגישה של KZDesktop היא להשתמש ב Tabbed Based User Interface ולא בDock UI, SDI או MDI.

הרעיון הוא שכל הסביבה תהיה כאילו היא חלון אחד, רק היא משתנה בין הצרכים וה"חלונות" הפתוחים אצלה.

לצערי, העבודה הזו, לא תיכנס ללזרוס 1.0, אשר ממש מעבר לפינה. אולי הפיתוח יכנס לגרסה 1.2, או רק ישפיע על הפיתוח של לזרוס לכיוון בסגנון הזה, ימים אבל יגידו.

נכון לכתיבת פוסט זה, עדיין לא ניסיתי בעצמי את התוסף, אבל אנסה אותו בסופ"ש הזה וכנראה אדווח 🙂

התמונה הבאה, מציגה איך מתקינים חבילות בלזרוס, תכנות נעים 🙂

התקנת חבילות

פסקל ברברס

התארחתי בפודקאסט "רברס עם פלטפורמה", ודיברתי מעט על שפת פסקל מונחת עצמים, ובעיקר על FPC.

תודה לאורי ורן על האירוח.

אתם מוזמנים להקשיב , ובעיקר להעריך את העובדה שאני יותר כותב ופחות מדבר 🙂

כתיבת ממשקי משתמש בסיסיים ללא שימוש ב C או Glade

שלומי ישראלי הציג אתמול פוסט כיצד ניתן בקוד פתוח ליצור ממשקי משתמש בסיסיים באמצעות C ו Glade.

לדעתי האישית הצגות כאלו, רק מוכיחות לאנשים המתנגחים בקוד הפתוח כל מה שרע בקוד הפתוח, אז החלטתי להציג דרך בקוד פתוח נוחה, מהירה ונקיה יותר, ללא קשר אם ה toolkit שלנו הוא GTK, Qt, אנדרואיד או IOS. הכל אצלנו נשאר אותו הדבר. מה שמשתנה זו הצורה שאנחנו מהדרים את הקוד.

כל מה שאני מציג כאן בגישה גרפית, ניתן גם לעשות בקוד מקור, כולל טעינת המסכים שלנו מקובץ בזמן ריצה. רק אין באמת צורך בכך במרבית המקרים.

עבור תוכנה גרפית, נתחיל בכך שנעבוד עם Lazarus. ונתחיל שם פרוייקט חדש:

הממשק בנוי ממספר חלונות, אשר את חלקם אתם רואים בתמונה. והוא נועד לסייע לנו לכתוב תוכנות בצורה כמה שיותר פשוטה, נוחה וכמה שפחות מאמץ, וכמה שפחות חזרה על קוד. בנוסף, הוא בנוי להיות חוצה פלטפורמות או סביבות גרפיות, ובכך מציג לנו API אחיד עבור כל סוג ממשק, ולמעשה לא אכפת לנו אם אנחנו עובדים ב GTK או Qt. זה לא חשוב לנו. להמשיך לקרוא

ממשק גרפי לציטוטים חלק רביעי

quotes_windowבין מספר פרוייקטים, בעיות רשת, ועוד מספר דברים, החלטתי בסופ"ש האחרון לחזור ולהמשיך עם פיתוח הממשק לציטוטים (זה כמובן תחביב שלי, ונכתב בראש ובראשונה עבורי, אבל אתם גם יכולים להנות מזה).

הגעתי למספר תובנות, בהם הממשק הגרפי עוד צריך להשתנות קצת, והעברתי את הUI של חלון החיפוש להיות דומה יותר למה שמוזילה הציגו לנו ב Firefox, ועכשיו כולנו מעתיקים את הרעיון 🙂

אבל לפני כן, עוד עשיתי ניסויים שונים עם יכולות החיפוש, והחלטתי בהתחלה להשתמש בספריית Regex כלשהי לבצע את החיפוש. לשם כך, הייתי צריך לבחור בין 2 ספריות המגיעות בברירת מחדל עם FPC, אחת ישנה, שגם אני בין הכותבים המקוריים שלה (גרמתי לה לתמוך בתחביר POSIX ב2005), או בספרייה חדשה יותר ומומלצת יותר לשימוש. בחרתי בסוף בחדשה יותר.

עכשיו במקום למחוק את החלון של החיפוש, הפכתי אותו לחלון מסוג TFrame. חלון זה, הוא חלון אשר אינו עומד בזכות עצמו, אלא צריך "מסגרת" כלשהי להיות בה. במקרה הזה, החלון הראשי.

אז למה בעצם יצרתי frame ? ובכן, אני מנסה להפריד רשויות, לוגיקה וכו'. אני עושה את זה במגוון דרכים, אבל גם עושה את זה בגישת DRY. כלומר נגיד ומחר ארצה בעוד דרך להשתמש באותו חלון באפליקציה, ובכן באמצעות ה frame זה אפשרי בלי לשכתב קוד.

הframe עדיין לא עד הסוף כמו שאני רוצה. אני חושב לשנות אותו במעט, שיהיה קרוב יותר למוזילה. למשל להשתמש בצבעים במידה וטקסט קיים או לא קיים. כרגע אני משתמש ב label אשר יגיד רק כאשר טקסט לא קיים, בעוד שבמידה והוא קיים אני משמיע לכם bell של המערכת על מנת שתדעו שקרה משהו, ותבינו כי הטקסט נמצא. לא הכי טוב, אני יודע. זו הסיבה שאני רוצה לשנות.

עוד דבר שנוסף (אשר למראית עין הוא מאחורי הקלעים), הוא שקובץ ההגדרות עכשיו שומר את מיקום קובץ הציטוטים. מה שאומר שבמידה והוא לא נמצא/קיים, אני מאפשר לחפש אותו ולפתוח אותו. כלומר הסרתי את התמיכה בקובץ ציטוטים במיקום שהוא hard-coded. יש גם מספר בדיקות שהוספתי שיוודאו שאם המידע לא נטען, אז התוכנה לא תמשיך לרוץ, אבל תדווח על כך למשתמש לפני.

עוד מספר פיטצ'רים שחשבתי להוסיף:

  •  לשלוח ציטוטים לרשת חברתית (או יותר נכון מספר רשתות חברתיות).
  • להוסיף צלמית ל system tray, וגם לשלוט משם.

נראה עוד בפרק הבא מה יהיה, בנתיים אתם כמובן מוזמנים לקבל את הציטוטים וקוד המקור של הפרוייקט מ github.

nvidia widgets

NvWidget_MacOS_386nvidia שחררה לפני מספר שנים sdk להשתמש בAPI שהיא משחררת עבור שימוש ב OpenGL. בעקבות ה sdk, קם פרוייקט אשר יצר רכיבים גרפיים המשתמש ב API של nvidia.

אנשים בלזרוס החליטו לתרגם את קבוצת הרכיבים לגישה טבעית בלזרוס ויש גם ללזרוס תמיכה כיום ברכיבים גרפיים מבוססי OpenGL עבור כרטיסים גרפיים של nvidia.

ממשק גרפי לציטוטים חלק שלישי

Quote Window

בחלק הקודם מאוד התלהבתי מהקלות של הפיתוח, אחרי שכבר מזמן לא יצא לי לתכנת בגישה הזו.

אז התחלתי ליצור גם חלון גרפי לחיפוש (החלון לא מכיל את הלוגיקה, רק את המראה הגרפי. מה שנקרא MVC 🙂 ), והוא למעשה חלון דו-שיח המאפשר לי להגדיר מה לחפש ואיך, ומימוש החיפוש נמצא בקובץ אחר. בפועל לא יצרתי עוד את האלגוריתמי חיפוש עצמם.

עוד דבר שרציתי וניסיתי, וניסתי וניסתי וניסיתי ונכשלתי כל הזמן, זה להבין את d-bus ואיך אני שולח הודעה אליו. אז בסוף החלטתי ללכת על משהו טוב אחר, וזה מימוש של libnotify. הבעיה היא שזה דורש תמיכה של GTK, כי הוא נבנה עבור גנום במקור, אם כי לא דורש את גנום עצמו. כך שאם מישהו מכיר מימוש גם עבור Qt ושאר הדרכים, אשמח לדעת עליהם. עכשיו הוא מעצבן מספיק כאשר הוא שולח הרבה ציטוטים לNotify. אז החלטתי שצריך אפשרות להגדיר האם לשלוח או לא כאשר אפילו אותי זה התחיל לעצבן לגמרי.

עכשיו התחילה בעיה חדשה. הממשק הגרפי לא מספיק טוב ! הוא נהיה עמוס מידי, ואם זה לא מספיק חמור, אז הComboBox פשוט לא מתאים לכמות כזו של ציטוטים. אז התחלתי לשחק עם העיצוב הגרפי, תוך כדי הטרדה של מספר אנשים, כדוגמת בוריס, אורי ומאיר. אשר היו בעיקר מנומסים מספיק ולהתעלם 🙂 למעט בוריס ז"א שנתן את דעתו מספר פעמים. תודה בוריס !

הנה מספר קטן של ניסויים שעשיתי בממשק: להמשיך לקרוא

Abbrevia

Abbrevia הוא סוג של toolkit עבור C++ Builder, Delphi, Kylix ו FPC/Lazarus אשר מספק רכיבים וספריות רבות לטיפול בפורמטי קיבוץ שונים כדוגמת ZIP, CAB, LZMA ואחרים.

הtoolkit הוא בעצם סדרת רכיבים בקוד פתוח, אשר חזרה להיות מפותחת אחרי קרוב לעשור, בה היא סתם שכבה בSourceForge. כמו כן, היא כיום עובדת במספר מערכות הפעלה כדוגמת Windows, Linux ו Mac OS-X.

הסיפור של ה toolkit הוא סיפור מאוד מעניין, היות והוא פותח במקור על ידי חברה בשם TurboPower. שם שאומר לחלק המון ולמרבית קוראי הבלוג מעט מאוד אם בכלל (וחבל שכך).

בתעשייה, למעט בעולם הקוד הפתוח, ישנם חברות שלמות אשר ההתמחות שלהן הוא לספק רכיבים, ספריות וכו' אשר מסייעות לחברות אחרות לפתח מוצרים שונים. החברות מוכרות את הספריות שלהם לכל דורש בהתאם לכל מיני סוגי רישוי ובכך במקום שכל חברה תפתח את אותם הדברים in-house, יש תעשייה שלמה של ספריות תכנות.

חברת TurboPower היתה חברה כזו. החברה היתה מאוד מוכרת בעולם בשנות ה80 וה90 בעיקר. היא היתה חברה מאוד קטנה, אבל עם המון פיתוחים אשר שינו את עולם התכנות המקצועי לכל אלו אשר בחרו בדלפי או C++ Builder של בורלנד, ולפני כן גם ב Turbo Pascal ו Turbo C, וכן Borland Pascal ו Borland C.

בתחילת שנות ה2000, משהו כמו 2002, הודיעה החברה כי היא הולכת להסגר (השותפים בחברה החליטו לצאת לפנסייה עד כמה שאני זוכר) והם החליטו לשחרר כקוד פתוח את הספריות הכי נפוצות שלהם, וAbbrevia היתה אחת מהן. היו עוד מספר ספריות, כולל מסד נתונים בשם FlashFiler שהם פיתחו בעצמם.

לאחרונה חברה מסויימת לקחה על עצמה את המשך הפיתוח של Abbrevia כאשר היא משאירה את הפיתוח כקוד פתוח, ובSourceForge, והיא גורמת לספרייה לעבוד כאמור במגוון פלטפורמות ומהדרים.

החברה שיחררה את גרסה 5.0 עבור הספרייה והחלטתי לפרסם על זה כאן. תכנות מהנה.

הקשיים ביצירת תכנות טבעיות לאנדוראיד

"The greatest challenge to any thinker is stating the problem in a way that will allow a solution" — Bertrand Russell

פליפה פרסם פוסט המסביר את הבעיות הרבות שהוא נתקל בהם בעת ניסיון ליצור תמיכה טבעית לאנדרואיד עבור לזרוס. לזרוס היה הראשון להציע פיתוח טבעי עבור אנדרואיד (אשר עדיין לא נתמך במלוא יכולותיו), ולמעשה היה זה פליפה אשר פתח את הרעיון הזה גם למימושים במהדרים וכלים נוספים. וכרגיל מערכות מבוססות פסקל הן חוד החנית בחידושים עבור כלי פיתוח ב30 שנה האחרונות.

פליפה מציין כי עבור הפיתוח הוא היה צריך לעבור הרבה מאוד דברים, כולל לימוד ממש רציני של ndk ובעצם איך המערכות עובדות. בהתחלה הוא יציר סוג של pipe בין משהו הכתוב בג'אווה למשהו טבעי, אבל כיום זה לאט לאט עובר להיות משהו טבעי יותר.

אחד הדברים שנוצרו בעיקר בזכות המימוש הזה הוא כתיבת סדרת רכיבים אשר יודעים לקבל עיצובים שונים, אבל מה שמויחד בהם, הוא שהם מצויירים על בד ציור אחד אשר יודע להיות מוצג על בד ציור טבעי, ובכך אפשר לקבל מראה זהה ואחיד בכל מערכת הפעלה או סביבה גרפית. אבל יותר מכך, זה פותח פתח להרבה סגנונות פיתוח חדשים בעולם ה UI של תוכנות גרפיות (להבדיל מפיתוח ui של web).

ממשק גרפי לציטוטים חלק 2

display quotes

עוד לא הספקתי לשחרר את האב-טיפוס הראשון וכבר עשיתי הרבה שינויים במערכת.

השינויים המורגשים הם כמובן בסביבה הגרפית: דבר ראשון התיבה המשולבת, לא מאפשרת לכם לחפש יותר ציטוט (הגרסה הבאה תכיל חיפוש מיוחד). עוד הוספתי מידע על כמה ציטוטים נטענו סה"כ, וציטוט מספר כלשהו שמוצג.

עוד שינויים גרפיים משמעותיים:הוספתי יכולת להעתיק את הציטוט ישירות ללוח הגזירים (Clipboard).  כמו כן, החלפתי את פקדי הכפתורים לBitBtn ומציג עכשיו איקונים (רק אם הסביבה מאפשרת להציג. כלומר אם בחרתם שלא יוצגו תמונות של כפתורים בסביבה הגרפית – KDE, Gnome וכו', אז הם לא יוצגו). האיקונים נלקחו באכזריות מאוסף Oxygen.

השינויים מאחורי הקלעים הם שעכשיו אינני מסתמך יותר על התיבה המשולבת, אלא משתמש ב StringList בשביל הכל. זה אומר שאם אחליט מחר להפסיק להשתמש בתיבה המשולבת, לא אהיה צריך לשכתב הכל מחדש יותר.

תכנונים לגרסה הבאה:

  • תיבת חיפוש ציטוטים
  • מציאת צטוטים כפולים (רק אם הם זהים לגמרי)
  • אפשרות להציג את הציטוט כהודעת מערכת בdbus.

עוד רעיונות יתקבלו בברכה

ממשק גרפי לציטוטים

display quotesכמו שכתבתי בעבר, יש לי חיבה מאוד מוזרה לציטוטים, אז החלטתי לנסות את מזלי ולראות כמה מסובך יהיה ליצור ממשק גרפי אשר יציג את האוסף שלי לעולם.

לקח לי בערך 10 דקות מהרגע שפתחתי את לזרוס, עד לנקודה שראיתי שהכל מתפקד כמו שרציתי (אחרי זה עוד עשיתי עוד כל מיני שניויים עיצוביים), והנה הקוד..

הצגת QR Barcode בתכנה שלך

http://lazarus-ccr.svn.sourceforge.net/viewvc/lazarus-ccr/components/lazbarcodes/לבקשת הקהל (בשיחות פרטיות), החלטתי להדגים כיצד ניתן ליצור חלון גרפי המציג QR Barcode.

מספר אנשים רצו להבין במה מדובר וכמה זה מסובך, אז הכנתי סרטון קצר (דקה ועשרים שניות) אשר מדגים את הנושא. שימו לב כי זו עריכת הווידאו הראשונה שלי (העריכה רק הוסיפה 2 כתוביות, לא שום דבר מעבר), אז תהיו עדינים בבקשה 🙂

רכיבים

הצגתי רכיב שמספק 2D Barcode, עם ברכה ומסר נוסף.

כמובן שהשתמשתי בלזרוס בשביל להשיג את ה"אפקט" הרצוי וזה אפילו ללא כתיבת שורת קוד אחת מצידי.

אז ללזרוס יש המון רכיבים שאפשר להשתמש בהם בשביל לחסוך מאיתנו כתיבת קוד, ושימוש מחודש בקוד קיים.

אז הנה סרטון קצר שמציג את מה שאני התקנתי אצלי בלזרוס נכון לעכשיו, תהנו:

Playing with web frameworks

Foreword

I'm researching several web frameworks in order to create a web application that I need to, that also should work as a web site on the Internet, and will have API to integrate things into other web-sites, if clients does not want to use that site.

For the task I started with two frameworks:

  1. fpWeb – aka fcl-web
  2. django

I do not want to try Rails, because I find the logic behind it very disturbing. The Rails framework rewrite the language, rather then adding libraries to use. I think that it is not the proper way to write libraries. So I decided not to try it at all, even though I really love the Ruby language itself.

fpWeb

So I started testing fpWeb, and I must say that it takes a while to get used to it and the way it does things, but once I figured out the basics, I find it really enjoyable to write a CGI (I always hate to write html/css stuff though, and that's regardless of the language for the server side) application.

fpWeb works in very different mindset then most modern web frameworks I have ever worked with so far. On one hand it appears that everything chosen for you, that is the template engine, session engine etc.. But  on the other hand, you can actually use what ever you want, just decide on something and go for it. להמשיך לקרוא

2 טריקים לסיוע בעריכת קוד בלזרוס

בלזרוס יש כמה דברים שאם לא נדע שאנחנו רוצים חפש אותם, לא נמצא אותם בתעוד. הטריקים כאן הם מצב שכזה – בו אנחנו לא נדע לחפש אותם בוויקי ולכן לא נדע שהם קיימים. אם תלחצו על הקישור ששמתי לכל טריק, תבינו גם למה.

לקפל קוד

אם עבדתם כבר עם העורך, אתם רואים שיש קיפול "רגיל" של חלקים שונים בקוד שאפשר להגדיר אותם אפילו. אבל מה אם כמו ב VIM אנחנו רוצים לקפל חלק מקוד ככה סתם לפי מה שנוח לנו ולא לפי הגדרה מסויימת גלובלית בסביבה ?

בשביל זה המציאו את ה"פקודה" הבאה:

{%region}
...
{%endregion}

זו הערה רגילה, אבל סימן האחוז אומר לעורך הטקסט לפרש את הפקודה שאחריו. ניתן גם להוסיף טקסט המסביר מה זה הקיפול אם רוצים, אבל לא חייבים. אפשר גם ליצור מספר "איזורים" כאלו אחד בתוך השני וליצור קיפול מקונן.

במידה ונרצה להגיד ללזרוס שכאשר הוא פותח את הקובץ האיזור יהיה מקופל, אנחנו יכולים להשתמש בregion בצורה הבאה:

{%region /fold}

במידה ונרצה להגיד לו שהוא לא יקפל בזמן פתיחת הקובץ, נעשה אותו הדבר רק עם unfold במקום. אנחנו נראה כי שfold ו unfold משפיעים רק אחרי שנפתח מחדש את הקובץ שעובדים עליו, ולא בצורה מיידית.

בגרסת הפיתוח הנוכחית (יכול להיות שזה נכנס לפני) ניתן גם לסמן בלוק של טקסט ואז ניתן לעשות עליו fold בפני עצמו ללא קשר ל region עם העכבר.

יחידת האב

פסקל תומכת בנוסף גם ב include ממש כמו C ושאר השפות בהן זה קיים, וגם בפסקל זה פשוט שם את תוכן באותה הנקודה שבה מכניסים את ה include ואז התוכן שייך לאותה יחידה.

הבעיה היא שלזרוס לא יודע לאן הקובץ שעושים עליו בסופו של דבר include שייך, היות והקובץ הוא קטע קוד ולא כל הקוד שלנו, אז אנחנו נרצה להגיד ללזרוס שהוא בעצם תלוי ביחידת האב, ואז פתאום הוא יתחיל למצוא הגדרות שהיו במקומות מעל הגדרת ה include שלנו גם בעריכת קובץ ה include. זה יתבצע בצורה הבאה:

{%MainUnit ../relative/path/unit_name.pas}

ועכשיו לזרוס יודע שהinclude שייך ליחידה ספציפית ומה המיקום שלה. אפשר גם ליצור נתיב מלא ולא חייבים נתיב מהנקודה שאנחנו נמצאים בה, אבל בד"כ בפרוייקט אנחנו נמצאים באותו איזור של הספריות, ולכן נוח יותר לשים נתיב יחסי.

במידה וזה נמצא באותה הספרייה, פשוט ניתן לכתוב את שם הקובץ ללא נתיב כלשהו.

זה הכל להפעם, תכנות נעים 🙂

ליצור ממשקים יפים גם בלינוקס

ממשק יפהאחת התלונות שיש על ממשקי עבודה בלינוקס הם שהממשקים מאוד מכוערים כאשר משווים אותם לסביבות עבודה כדוגמת זו של מיקרוסופט או של אפל.

העניין הוא שממש לא חייבים ממשק מכוער בלינוקס, אפשר גם ליצור ממשקים ממש יפים אם רוצים, וזה כמובן אם משתמשים בכלים הנכונים 🙂 ד"א, הכלים האלו הם לא רק חוצי פלטפורמות, אלא גם יעבדו גם עם GTK2 וגם עם Qt4.

התמונה בצד ימין נוצרה עם רכיב בשם BRGAControls בלזרוס, ואם השם BGRA מוכר לכם משום מה, אז זה בגלל שהזכרתי את "בד הציור" (Canvas) בעבר כאן בבלוג. השם שלו הוא BGRABitmap והוא מאפשר לנו ליצור הרבה מאוד דברים באמצעות תמיכה מלאה באלפא בנוסף לתמיכה ב RGB הרגיל, ואפשר גם להשתמש בו לציור שכבות ועוד, וכאמור יש בו שימושים רבים כדוגמת הרכיבים שאתם רואים בתמונה בצד ימין, שאלו הם:

  • TBGRAImageList
  • TBGRASpeedButton
  • TBGRAButton
  • TBGRAPanel

למשל הרקע המדורג נעשה על ידי באמצעות TBGRAPanel, בעוד שהשאר הם כפתורים, והצלמית של האפליקציה.

ניתן גם לראות גלרייה של דוגמאות של עיצובים שונים שניתן לעשות (שמעט יפים יותר מהיכולות הגרפיות שלי אני חייב לציין, למרות שאתם בטח לא תשימו לב). הגלרייה גם מכילה שורות קוד איך להשיג את התוצאה הרצוייה.

אז למה אתם מחכים ? תתחילו ליצור ממשקים יפים יותר בלינוקס 🙂

(עוד) קיצורי מקשים בלזרוס

הקדמה

כתבתי בעshortkeysבר כי לזרוס היא סביבת פיתוח שמאוד נוחה לי. לא בגלל שהיא כתובה בשפה שהיא כתובה בה, אלא בגלל שהיא ממש נוחה לעבודה.

החלטתי לספר על מספר קיצורי מקשים אשר יכולים לגרום לעבודה שלכם להיות קלה יותר, וגם אתם תרגישו את העצמה והנוחות של סביבת העבודה. חשוב להבין כי אפשר לערוך את קיצורי המקשים בלזרוס, ואני לפעמים עושה את זה, כאשר משהו לא נוח לי, ואני גם ממליץ לכם לעשות את זה במידה ואתם מרגישים כי הקיצור עצמו אינו נוח לכם, וגם לבדוק שהוא לא מתנגש עם קיצור זהה לאפשרות אחרת. כמו כן, לזרוס תומך במתן 2 קבוצות קיצורים לפעולה, כלומר פעולה אחת יכולה לקבל 2 קיצורים שונים, כך שיש לכם דרך לנסות את הרעיון החדש בלי לפגוע בישן (למשל).

כמו שאפשר לראות בתמונה בצד שמאל, אפשר לחפש פעולות מסויימות ואז אפשר למצוא תא הקישורים שמוצים אליהם (או שלא מוקצים בכלל). אחד הדברים שעוד רואים הוא שגם תוספות שלנו ללזרוס (לדוגמא עיצוב JCF ותמיכת SVN הם תוספות אצלי ולא מגיעים בנויים בתוך לזרוס בברירת מחדל) נמצאים שם.

המקשים החשובים באמת

אז יש מספר מצומצם של מקשים שמאוד מומלץ להכיר:

  • F11 – מביא לנו את Object Inspector כחלון הפעיל ביותר
  • F12 – מביא אלינו או את החלון עליו אנחנו עובדים כרגע או את העורך טקסט (תלוי אצל מי הפוקוס באותו הזמן). החלון יהיה קשור לחלון שהקוד לנו נמצא כרגע פתוח בעורך הטקסט
  • CTRL+SHIFT+C – "השילש הקדוש" – כותב בשבילנו קוד אם יש לסביבה מספיק פרטים. מה הכוונה ? ובכן נגיד וכתבתו את הקוד הבא: להמשיך לקרוא

נא להכיר את לזרוס 0.9.30

בשעה טובה ובאיחור של מספר חודשים שוחררה לה גרסה חדשה של לזרוס: 0.9.30.

הקדמה

אז אם אתם לא מכירים את לזרוס, אז אתם מפסידים הרבה מאוד. לזרוס היא סביבת עבודה משולבת המשוחררת בקוד פתוח והיא פשוט מדהימה. יש לה המון יכולות לסייע לכם לתכנת בצורה מאוד פרודקטיבית אבל היא לא תתערב לכם בעבודה אלא אם תבקשו ממנה ממש יפה (שילוב של מקשים או העכבר).

הסביבה מספקת המון תכונות כמו תכנות גרפי, אפשרות ליצור אפליקציות לטלפונם סלולריים, תכנות CGI לאתרי web, יצירת דו"חות, גרפים, ואפילו דפדפני web משל עצמכם והרשימה עוד ממשיכה. אם זה לא מספיק היא מספקת אפשרות ליצור אפליקציה אחת שתרוץ בהרבה מאוד פלטפורמות כדוגמת Windows, Linux, Mac, BSD, iPhone, Android, Maemo/MeeGo, Windows Mobile והרשימה עוד ממשיכה… ואם מעניין אותכם, אז הנה מספר קטן מאוד של אפליקציות אשר מבוססות על השימוש בלזרוס. יש כאמור עוד אפליקציות שלמות אשר לא נכנסו לרשימה, אשר חלקן אפילו נמכרות בחנות האפליקציות של אפל וגוגל.

מה חדש בגרסה 0.9.30 ? להמשיך לקרוא

BGRABitmap

Example of BGRABitmapזוכרים שהזכרתי את LazPaint ? אז אחד הדברים שבאמת מדהימים שם הוא ספרייה בשם BGRABitmap. זו ספרייה שמשוחררת בקוד פתוח, אשר מספקת תמיכה ב"מפת סיביות" (כלומר תמונה מבוססת פיקסלים ולא לינארית) חוצה פלטפורמות אשר מספקת תמיכה בהרבה מאוד תכונות מתקדמות של תכנות גרפי, כדוגמת עבודה עם אלפא (גם אם ה widget כדוגמת GTK2 אינו תומך בזה), עבודה עם "שכבות",  הוספה ומחיקה של פיקסלים, יצירת ציור עם ובלי antialiasing, קואורדינטות מבוססות נקודה צפה, רוחב קו בנקודה צפה, מילוי מדורג של תוכן והרשימה עוד ארוכה.

במידה ואתם רוצים ללמוד איך לבנות בצורה תכנותית את התמונה בצד ימין (שנעשתה בצורה תכנותית), אז אתם מוזמנים לגשת למדריך שנכתב בויקי בנושא.

צפייה ברשימה

דיברתי על פקד "עץ" באחד הפוסטים הקודמים, ולפני שאדבר על החלק השני עם עוד פקד של "עץ", החלטתי לדבר על פקד TListView היות ופקד ה"עץ" הבא, יודע להיות שניהם.tlistview

פקד ה TListView הוא עוד פקד בקבוצה של רשימות, והוא שכן של פקד העץ ברשימת הרכיבים בלזרוס. הוא מאפשר לנו לקבל תחושה של "שולחן עבודה" עם קבצים שונים כמו שאנחנו מכירים בWindows ובכמה מנהלי שולחנות עבודה בלינוקס. כלומר רשימה של איברים מפוזרים בצורה מסויימת על גבי המסך, ואפשר לבחור את מה שרוצים בעצם.

dolphin TListView מכיל מספר של מצבי תצוגה ולא רק מצב בודד. הוא מכיל רשימה עם צלמיות גדולות, רשימה עם צלמיות קטנות, רשימה לבד, ורשימה עם פרטים. בנוסף הפקד מאפשר לנו להשתמש ב checkbox על מנת לסמן איברים, דבר המזכיר מאוד את הגישה של Dolphin ב KDE.

הרשימה עם הפרטים מכילה עוד מידע על כל איבר ואיבר, וכן כותרות לכל דבר כזה באמצעות עמודות. אם אתם זוכרים את הפקד ה"עץ" של GTK, אז הוא מספק גם את זה כחלק מהיכולות שלו למעשה.

הפעם החלטתי לעשות משהו טיפה יותר רציני, וזה לנצל את כל 4 מצבי התצוגה של הפקד, ולכן הכנתי גם מערך קוד שאפשר להוריד אותו, וגם עשיתי "על הדרך" שימוש בRTTI ולהמיר את השמות התכנותיים ("סמלים") של המניה אשר מכילה בעצם את מצב התצוגה למחרוזת, והשתמשתי בקוד הזה, בתכונה שנכנסה לfor בגרסה 2.4.2 של FPC, כך שזו הגרסה המינימלית שתהיו צריכים בשביל להדר את הקוד שלי הלאה, אבל אם אין ברשותכם את הגרסה הזו או גרסה חדשה יותר, אפשר ממש בקלות להמיר את שורת הקוד הבעייתית מ

for vs in TViewStyle do

ל

for vs := Low(TViewStyle) to High(TViewStyle) do

וזה ימשיך לעבוד בצורה זהה. חשוב להבין כי כל מה שעשיתי בצורה תכנותית (למעט העברת השם של ה"סמל" למחרזות) ניתן לעשות גם בצורה וויזואלית, רק אני העדפתי להציג את הצד התכנותי של הנושא.

כמו שאפשר לראות בתמונה, השתמשתי בעוד פקד שנותן לנו אפשרות לבצע רשימה של TRadioGroup שגם בו השתמשתי רק בצורה תכנותית ולא בצורה וויזואלית, וזה רק בשביל להמחיש בעצם את גישת העבודה, למרות שבפועל סביר להניח שהיינו מכניסים את המידע הזה בזמן תכנון ולא בזמן ריצה, ובכך הקוד שלנו היה גם יעיל יותר.

את הקוד ניתן להורד מהקישור הזה.

תכנות נעים.

צפייה בעץ חלק ראשון

כאשר מבצעים תכנות גרפי (וויזואלי), הרבה פעמים אנחנו מוצאים את עצמנו צריכים ליצור היררכיה כלשהי בצורת עץ של מידע.

לשם כך נוצר פקד מאוד מוכר בשם TreeView אשר לפחות ב GTK הוא גם הבסיס לכל שאר הרכיבים מבוססי הרשימות למינהם. התפקיד של הרכיב הוא לקחת רשימה של עצמים ולהציג אותם, כאשר עצמים מסויימים יכולים גם להציג בנים שונים, ואפילו תמונות שונות בהתאם לצורך.

TTreeViewבלזרוס ודלפי הפקד נקרא TTreeView והוא מכיל פונקציות בעלות הרבה מאוד עזרים חשובים כדוגמת שיוך כתובת זיכרון לעצם כלשהו, שליטה כיצד העצמים יוצגו, בחירה האם עצם מסויים עם בן יהיה פתוח או סגורוהאם הבנים שלו גם יהיו כאלו או לא, גרירה והדבקה של איברים חדשים והרשימה עוד ארוכה.

אז איך מתחילים בעצם ? הולכים ללשונית Common Controls וזורקים במקום המתאים את הפקד של TTreeView. בתכונות שלו אפשר לשחק איתו בשביל שיתאים לצרכים שלנו. בנוסף יש לו תכונה בשם Items. התכונה הזו מאפשרת לנו גם בצורה תכנותית וגם בצורה וויזואלית להוסיף בעצם את האיברים ברשימה. אני אדגים כאן כיצד יוצרים את האיברים בצורה תכנותית, הרי וויזואלית זה מאוד פשוט.

אז במקרה שלנו, זרקתי את TTreeView על החלון, אמרתי לו להיות מיושר לאורך כל החלון, ואמרתי לו שפסי הגלילה יופיעו שניהם רק כאשר יש צורך לכך.

בקוד של החלון ב OnCreate יצרתי את הקוד הבא:

procedure TForm1.FormCreate ( Sender : TObject ) ;
var
  i : byte;
  Node : TTreeNode;
begin
  for i := 1 to 20 do
    begin
      Node := TreeView1.Items.Add(nil, 'Test ' + IntToStr(i));
    end;
end;

הקוד עושה פעולה מאוד פשוטה, רץ על כל המספרים מ1 ועד 20 ומוסיף את האיברים אל הרשימה עם מספור של האיבר עצמו. אנחנו שומרים את האיבר שנוצר ב TTreeNode לשימוש עתידי. שמתי בפרמטר הראשון של Add את הערך nil בשביל לציין שהאיבר שנוצר אינו אח של איבר אחר (שגם הוא מסוג המחלקה של TTreeNode).

אבל עכשיו יש לנו רשימה של 20 איברים, אבל הם עריריים ללא ילדים. בשביל לדאוג לכך שיהיו להם ילדים נגיד לItems להוסיף ילד לאיבר שיצרנו באמצעות AddChild אשר דומה מאוד ל Add הרגיל, אבל יוצרת בן. בשביל להשיג את התוצאה כמו בתמונה למעלה, הקוד המלא נכתב בצורה הבאה:

procedure TForm1.FormCreate ( Sender : TObject ) ;
var
  i : byte;
  Node : TTreeNode;
begin
  for i := 1 to 20 do
    begin
      Node := TreeView1.Items.Add(nil, 'Test ' + IntToStr(i));
      if i mod 2 = 0 then
        begin
          TreeView1.Items.AddChild(Node, 'Sub Test');
          if i mod 4 = 2 then
            Node.Expand(False);
        end;
    end;
end;

וזו הגישה הפשוטה ועם פחות העצמה שיש לעבודה בעצים. בחלק הבא נכיר עוד פקד לעצים הקיים ללזרוס ודלפי שהוא עם הרבה יותר עצמה ויותר מעניין.

חלון ל HTML

היום הרבה חושבים שעולם ה web חשוב יותר מעולם ה desktop, גוגל אפילו המציאו מערכת הפעלה מיוחדת רק לגישה הזו (אשר אישית אני מקווה כי לא תצלח להם).

אז כיום כאשר הכל הולך לעולם הwww, יש הרבה שצריכים להמיר תוכנות גרפיות שלמות של "שולחן עבודה" עם ממשק web במקום. לשם כך בד"כ נדרשת המון עבודה קשה ומסובכת וזה עוד לפני שמדברים על הלוגיקה שצריכה להשתנות לגמרי ולהיות גישה של גישת disconnected, כלומר גישה בה כל בקשה לא תלויה בבקשות אחרות בשביל להתבצע כך שאין משהו מאחור אשר שומר את המידע בזיכרון (ram) בכל עת. הרי זה ההבדל העיקרי בלוגיקה של פיתוח web.

אז לאחרונה הומר כלי אשר עד היום תמך רק בדלפי (עוד מ1998) ללזרוס, ותפקידו בעולם הוא להמיר מסכים גרפיים שלמים עם רכיבים (מבוססי TWinControl) לדף HTML סטטי או לדך HTML עם cgi מאחוריו.

כלומר אם אצור מסך עם רכיבים גרפיים שונים עבור שולחן העבודה אוכל לקבל אותם כ HTML בנוסף ואוכל להשתמש בהם באפליקציה שלי. כך שאפשר להשתמש בעצם בלזרוס ודלפי כסביבת WYSIWYG עבור פיתוח web, וזה אם לא משתמשים בExtJS אשר כבר פגשנו לו תוסף ללזרוס.

yes wii can

עדכנתי לאחרונה את ה svn של FPC וגיליתי פרט מעניין: נוספה תמיכה לפיתוח אפליקציות ב Nintendo Wii – עדיין בפיתוח אבל הבסיס כבר כאן.

יש עוד הרבה חדשות בעולם הזה של פסקל. למשל תוכנות הכתובות ב FPC (ולזרוס) שהצליחו להיכנס ל Apple Store וכן Google Marketplace, ובימים הקרובים צריכה לצאת גרסה חדשה של לזרוס (היתה צריכה לצאת כבר השבוע) 0.9.30.

לאחרונה אני מגלה דרך פעילות עם לזרוס גם הרבה ישראלים חדשים שנכנסים ורוצים ליצור תוכנות חוצות פלטפורמה ופתאום מגלים שיש כלי שמאפשר להם להמיר את קוד הדלפי שלהם שהם מוכרים גם ללינוקס ולאפליקציות לטלפונים "חכמים". עצוב כמה מעט פרסום יש בארץ על הכלים האלו.

הגיעו אלי כמה הצעות עבודה כמפתח דלפי וObject Pascal והפנתי אותם לכמה אנשים שהכרתי שחיפשו עבודה ויש להם רקע וידע בנושא.

יש עוד המון חידושים שאכתוב עליהם לאט לאט (בעיקר כשיהיה לי זמן), אבל יחסית לשפה מתה, יש הרבה חידושים והתענינות בה ללא הפסקה.

Features I wish to see in a text editor/IDE

I have decided to create a small list (11 ideas so far) of features I wish to see in a text editor/IDE. It's actually meant for Lazarus, but it can go for every open source text editor out there just as well. 🙂 להמשיך לקרוא

ppRuby

יש פרוייקט שאפתני ומאוד מעניין לדעתי אשר נקרא ppRuby . הפרויקט מנסה לספק מספר אספקטים לשפת רובי, מהאפשרות לקחת ספרייה משותפת הכתובה בפסקל ולקבל קוד שאפשר להריץ בשפת רובי, ועד חיבור ממשי אל תוך Lazarus עצמו, ובכך לספק עוד שפה שסביבת הפיתוח תתמוך בה, אך נכון לעכשיו עוד רחוקה הדרך.

האפשרות לגרום ללזרוס לקבל תמיכה בעוד שפות דורשת גם תמיכה בצביעת תחביר אבל זה החלק הקטן. האפשרות זקוקה לתוסף עבור CodeTools אשר יודע לדבר בשפה שאותה רוצים להוסיף וכן עוד חיבורים שונים המגיעים כתוספות אל הסביבה ובכך אפשר להריחב אותה. למעשה התמיכה בשפת פסקל בלזרוס היא גם תוסף של CodeTools, כך שבעצם אם רוצים להוסיף תמיכה לרובי, פרל או כל שפה אחרת אפילו לא חייבים לקבל תמיכה בשפת פסקל אם לא רוצים לפחות על הנייר.

עוד תמיכה שהפרוייקט מנסה לספק הוא האפשרות להריץ קוד רובי בצורה מוטבעת בתוכנה (עדיין עד כמה שאני מבין, אין תמיכה בפירוש של השפה, אלא יותר שימוש במפרש רובי חיצוני שמגיע עם mri).

כך שזהו פרוייקט שלדעתי לפחות מאוד מעניין ומאוד הייתי רוצה לראות איך הוא ממשיך להתפתח.

לכתוב תוכנית טבעית בAndroid ללא ג'אווה ולהישאר בחיים

הבהרה: אין לי ניסיון אישי עם פיתוח למערכות אנדרואיד נכון לכתיבת פוסט זה. גרסת האנדרואיד האחרונה שהשתמשתי בה היתה גרסה 1.x (אינני זוכר את תת הגרסה), ומאז הרבה FUD עבר בין חברות הסלולר השונות.

קראתי היום דיון שמתנהל כבר זמן מה לגבי פיתוח לסביבת אנדרואיד, וביקשו מאדם שיש לו ניסיון קצת בתחום להסביר במה מדובר, וההסבר שלו נמצא כאן.

זה ניסיון להציג סוג של תרגום של חלק ממה שהוא כתב וגם תוספות שלי לטקסט 🙂

אז יש כיום (החל מ2.3 עד כמה שאני מבין) תמיכה באנדרואיד לפתח ב2 צורות כאשר מדובר בקוד חיצוני:

  1. שימוש ב JNI ולטעון ספריות משותפות (קבצי so).
  2. למממש את ה API של אנדרואיד בשפה שלכם, ולרוץ בצורה כמעט לגמרי נקייה מג'אווה.

היתרון של עבודה עם תוכנה עצמאית, היא שניתן לכתוב תוכנה אחת למספר רב של פלטפורמות ובעצם ליצור סוג של ספרייה גבוהה יותר, שעבור כל פלטפורמה היא ממומשת בצורה הטבעית שנדרשת מאיתנו, אבל התוכנה עצמה אינה צריכה להשתנות כמעט בכלל בגלל סוג הפלטפורמה (כמובן שזה תלוי במספר גורמים).

אז כיצד הפיתוח מתבצע ? ובכן נוריד קודם את הספריות הממשות את ה API של אנדרואיד אלינו: להמשיך לקרוא

Precision Language Suite

Precision Language Suite היא מערכת תרגום מאוד מעניינת לתכנות חוצה פלטפורמות. בניגוד למערכת מבוססת gnu gettext למשל, המערכת מכילה הרבה יכולות נוספות, כאשר לאחרונה גם כמה מהבקשות שלי נכנסו לשם כחלק מדיון בפרומים, כדוגמת האפשרות לסמן האם שפה מסוימת היא שפה מימין לשמאל או לא, דבר שמקל מאוד על העבודה עם התוכנה, אשר לא צריכה להכיר את כל שפות העולם בשביל לדעת להתאים את הממשק לשפה.

אחד היתרונות של הגישה כאן היא טעינה דינאמית של טקסט בהתאם לצורך, ויכולת "למחזר" מחרוזות במגוון פרוייקטים וגרסאות, כך שבמקום לתרגם כל פעם מחדש דברים, פשוט אפשר לסנן מחרוזות ולמצוא את מה שצריך ולהשתמש רק בהם כאשר צריך.

התרגום עצמו נשמר בקבצי טקסט קריאים וניתנים לעריכה בכל עת, אך ניתן גם "לשווק" אותם כקובץ בינארי (קובץ מקווץ), או כספרייה משותפת (dll, so). כמו כן, ניתן לקחת תרגום של לקוח ספציפי אשר מתאים לו אישית ו"לדרוס" את התרגום הקיים על ידי טעינת הקובץ שלו במקום קובץ התרגום המקורי, ללא השפעה על התוכנה עצמה.

המערכת מכילה עוד הרבה מאוד תכונות, אבל יש להבין כי לצערי היא אינה משוחררת בקוד פתוח, והשימוש צריך להיות בהתאם לרישיון המערכת.

המערכת במקור נכתבה לדלפי, אבל נעשתה עבודה לגרום לקוד לעבוד גם עם Lazarus ו FPC, כך שיש עוד מוצר מסחרי המתאים את עצמו לרוייקטי קוד פתוח.

fpWeb – שלום עולם

עשיתי כבר סקירה ראשונים ל fpWeb, שהיא כולה היתה רק מילים. ובכן מילים זה נחמד, אבל איך אפשר ללמוד כלי מסויים אם לא משתמשים בו ?

אז דבר ראשון חשוב להתקין את התמיכה של fpWeb בלזרוס, היות ושם מהיר יותר לפתח את האפליקצייה שלנו. אני אישית תמיד משתמש בגרסאות ה SVN, גם בגלל שאני מנסה לעזור במציאת באגים ופתרון שלהם, גם כי לפעמים אני תורם קוד נוסף, וגם כי אישית מעניין אותי מאוד תהליך הפיתוח של המערכת, שכמעט תמיד יציב גם בגרסת הפיתוח (יחסית כמובן). להמשיך לקרוא