LittlevGL test for Hebrew font and Bidi algorithm

lvgl_heb_test1.py

# Helper function to set fonts

def set_font(obj, font = lv.font_heb_16):
    if type(obj) == lv.style_t:
        obj.text.font = font
    else:
        for style_type_str in dir(obj.STYLE):
            if not style_type_str.startswith('_'):
                style_type = getattr(obj.STYLE, style_type_str)
                style = obj.get_style(style_type)
                if style:
                    new_style = lv.style_t()
                    lv.style_copy(new_style, style)
                    new_style.text.font = font
                    obj.set_style(style_type, new_style)

# Create screen

scr = lv.obj()
scr.set_base_dir(lv.BIDI_DIR.RTL)

# Create 3 tabs

tabview = lv.tabview(scr)
set_font(tabview)

tab1 = tabview.add_tab("1. אחד")
tab2 = tabview.add_tab("2. שתיים")
tab3 = tabview.add_tab("3. שלוש")

# Create a table on tab 1

style_cell1 = lv.style_t()
lv.style_copy(style_cell1, lv.style_plain)
style_cell1.body.border.width = 1
style_cell1.body.border.color = lv.color_hex3(0xFFF)
set_font(style_cell1)

style_cell2 = lv.style_t()
lv.style_copy(style_cell2, lv.style_plain)
style_cell2.body.border.width = 1
style_cell2.body.border.color = lv.color_hex3(0xFFF)
style_cell2.body.main_color = lv.color_hex3(0xAAA)
style_cell2.body.grad_color = lv.color_hex3(0xAAA)
set_font(style_cell2)

table = lv.table(tab1)
table.set_style(table.STYLE.CELL1, style_cell1);
table.set_style(table.STYLE.CELL2, style_cell2);
table.set_style(table.STYLE.BG, lv.style_transp_tight);
table.set_col_cnt(2);
table.set_row_cnt(4);

table.set_cell_align(0, 0, lv.label.ALIGN.CENTER);
table.set_cell_align(0, 1, lv.label.ALIGN.CENTER);

table.set_cell_type(0, 0, 2);
table.set_cell_type(0, 1, 2);

table.set_cell_value(0, 0, "שם");
table.set_cell_value(1, 0, "תפוח");
table.set_cell_value(2, 0, "בנננה");
table.set_cell_value(3, 0, "לימון");

table.set_cell_value(0, 1, "מחיר");
table.set_cell_value(1, 1, "$7");
table.set_cell_value(2, 1, "$4");
table.set_cell_value(3, 1, "$6");

# Create a ddlist on tab 2

ddlist = lv.ddlist(tab2)
ddlist.set_options("1. שלוםםםם\n2. שלום\n3. שלום")
ddlist.set_y(120)
set_font(ddlist)

# Create a text area on tab3

txt1 = """
שימושים
סרטיפיקטים נפוצים כגון של תעודות X.509 בפורמט PEM[1], נשמרים בפורמט Base64 עקב קריאותם הרבה. באופן דומה, תוצאות של פונקציות גיבוב (Hash functions) מוצגות בדרך כלל ב Base64 מפני שהתוצר הגולמי שלהן עלול להכיל תווים לא קריאים.

נפוץ למצוא מידע מקודד ב-Base64 בתוך מסמכי XML שונים, במיוחד כאשר נעשה שימוש בתקשורת להעברת המסמכים. 
סכמה פשוטה לדוגמה של שיבוץ קידוד כזה במסמך XML‏: <data encoding="base64">TextEncodedInBase64ComesHere</data>

OpenPGP
OpenPGP[2], המתואר ב-RFC 4880 מגדיר קידוד Radix-64 (מכונה גם ASCII Armor).‏ Radix-64 הוא למעשה זהה ל Base64, בתוספת (אופציונלית) של 24 סיביות CRC. ה-Checksum, מחושב על המידע לפני הקידוד ואחר כך עובר בעצמו קידוד Base64, בתוספת תחילית של = המשמשת כתו מפריד, ומשורשר למידע המקודד.

HTML
המתודות atob() ו btoa() של שפת JavaScript, המוגדרות במפרט של HTML5[3] נותנות שירות קידוד ל Base64 עבור קוד JS שרץ בדף אינטרנט. btoa() מוציאה את תווי הריפוד, אך אלו אופציונאליים בקלט של atob()

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

דוגמה
הטקסט הבא: "War @ Peace+"

יוצג בקידוד ASCII הקסדצימלי 57 61 72 20 40 20 50 65 61 63 65 2B ובקידוד ASCII בינארי: 01010111 01100001 01110010 00100000 01000000 00100000 01010000 01100101 01100001 01100011 01100101 00101011. כל 8 סיביות ברצף זה של 96 סיביות מייצגות תו אחד של הטקסט המקורי. הרצף הראשון 01010111, למשל, מייצג את האות 'W'.

רצף סיביות זה יופרד לקטעים של 6 סיביות כל אחד, וכל קטע של 6 סיביות יוצג באמצעות תו ASCII המתאים לו, לפי הטבלה דלעיל, ובכך יקודד למחרוזת הבאה Base64 של תווי ASCII:‏ V2FyIEAgUGVhY2Ur

ריפוד
כיוון שכל 3 בתים (24 סיביות) ממופים ל-4 תווי Base64, יכול להווצר מצב שהרצף המקורי אינו מתחלק ב-3 וחייב להתבצע "ריפוד" המשלים את הבתים החסרים בקבוצה האחרונה. בציטוט שבדוגמה יש 12 תווים, שהם 96 סיביות, שאותם ניתן לחלק בדיוק ל-16 קטעים של 6 סיביות. אם נגדיל את הטקסט, בתוספת תו אחד בסופו, כך: War @ Peace+- נקבל מחרוזת של 13 תוים, שהם 104 סיביות, מספר שבחלוקתו לקטעים של 6 סיביות נותן 17 קטעים שלמים, ועוד קטע שבו שתי סיביות בלבד. הקידוד ל-Base64 של טקסט זה נותן את המחרוזת הבאה: V2FyIEAgUGVhY2UrLQ==

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

קישורים חיצוניים
מקודד מקוון של מחרוזות ל Base64, באתר codebeautify
דף לימוד על קידוד Base64 בשפת Javascript באתר W3Schools
הסברים על שימושים של קידוד Base64, באתר StackOverflow
הערות שוליים
 PEM Files, באתר How2SSL
 קוד פתוח פופולרי להצפנה המבוסס על הסטנדרט PGP
 "7.3. Base64 utility methods". HTML 5.2 Editor's Draft. World Wide Web Consortium. בדיקה אחרונה ב-2 בינואר 2017. Introduced by changeset 5814, 2011-02-01."""


ta = lv.ta(tab3)
ta.set_height(250)
ta.set_width(470)
ta.set_text(txt1)
ta.set_cursor_pos(0)
set_font(ta)

lv.scr_load(scr)