Skip to content

हिंदी में ट्यूटोरियल

विभिन्न उदाहरण जल्दी से दिखाते हैं कि fpdf2 का उपयोग कैसे करें। आपको सभी मुख्य विशेषताओं की व्याख्या मिल जाएगी।

Methods full documentation / तरीके पूर्ण प्रलेखन: fpdf.FPDF API doc

Tuto 1 - मूल उदाहरण

आइए क्लासिक उदाहरण से शुरू करें:

from fpdf import FPDF

pdf = FPDF()
pdf.add_page()
pdf.set_font("helvetica", "B", 16)
pdf.cell(40, 10, "Hello World!")
pdf.output("tuto1.pdf")

Resulting PDF

लाइब्रेरी फ़ाइल को शामिल करने के बाद, हम एक FPDF ऑब्जेक्ट बनाते हैं। FPDF कंस्ट्रक्टर का उपयोग यहां डिफ़ॉल्ट मानों के साथ किया जाता है:

पृष्ठ A4 पोर्ट्रेट में हैं और माप इकाई मिलीमीटर है। इसके साथ स्पष्ट रूप से निम्नलिखित निर्दिष्ट किये जा सकते है:

pdf = FPDF(orientation="P", unit="mm", format="A4")

पीडीएफ को लैंडस्केप मोड में सेट करना संभव है (L) या अन्य पेज प्रारूपों का उपयोग करने के लिए (जैसे कि Letter तथा Legal) और इकाइयों को मापें (pt, cm, in)।

फिलहाल कोई पेज नहीं है, इसलिए हमें इसमें एक add_page जोड़ना होगा ।

मूल ऊपरी-बाएँ कोने में है और वर्तमान स्थिति डिफ़ॉल्ट रूप से सीमाओं से 1 cm पर रखी जाती है; मार्जिन को set_margins के साथ बदला जा सकता है ।

इससे पहले कि हम टेक्स्ट प्रिंट कर सकें, इसके साथ एक फॉन्ट का चयन set_font से करना अनिवार्य है, अन्यथा दस्तावेज़ (Document) अमान्य होगा। हम Helvetica bold 16 चुनते हैं:

pdf.set_font('helvetica', 'B', 16)

हम I के साथ इटैलिक (Italic) निर्दिष्ट कर सकते हैं, U के साथ रेखांकित (Underlined) निर्दिष्ट कर सकते हैं या एक नियमित फ़ॉन्ट एक खाली स्ट्रिंग के साथ (या कोई संयोजन) निर्दिष्ट कर सकते हैं। ध्यान दें कि फ़ॉन्ट का आकार अंकों में दिया गया है, मिलीमीटर में नहीं (या अन्य उपयोगकर्ता इकाई); यह एकमात्र अपवाद है। अन्य बिल्ट-इन फॉन्ट Times, Courier, Symbol और ZapfDingbats हैं।

अब हम cell के साथ cell print कर सकते हैं। एक सेल (cell) एक आयताकार क्षेत्र है, संभवतः तैयार किया गया है, जिसमें कुछ पाठ है। यह वर्तमान स्थिति में प्रदान किया जाता है। हम इसके आयाम, इसके पाठ (केंद्रित या संरेखित) निर्दिष्ट करते हैं, अगर सीमाएं खींचा जाना चाहिए,और जहां वर्तमान स्थिति इसके बाद चलती है (दाईं ओर, नीचे या अगली पंक्ति की शुरुआत में)।

एक फ्रेम जोड़ने के लिए, हम यह करेंगे:

pdf.cell(40, 10, 'Hello World!', 1)

केन्द्रित पाठ (centered text) के साथ इसके आगे एक नया सेल (cell) जोड़ने के लिए और अगली पंक्ति पर जाने के लिए, हम करेंगे:

pdf.cell(60, 10, 'Powered by FPDF.', new_x="LMARGIN", new_y="NEXT", align='C')

टिप्पणी: लाइन ब्रेक ln के साथ भी किया जा सकता हैं। इस विधि ब्रेक की ऊंचाई के अतिरिक्त निर्दिष्ट करने की अनुमति देती है।

अंत में, दस्तावेज़ को बंद कर दिया गया है और प्रदान किए गए फ़ाइल पथ के तहत सहेजा गया है output.बिना किसी पैरामीटर के, output() PDF bytearray बफ़र लौटाता है।

यहाँ शीर्ष लेख (Header), पादलेख (Footer) और लोगो (Logo) के साथ दो पृष्ठ का उदाहरण दिया गया है:

from fpdf import FPDF


class PDF(FPDF):
    def header(self):
        # Rendering logo:
        self.image("../docs/fpdf2-logo.png", 10, 8, 33)
        # Setting font: helvetica bold 15
        self.set_font("helvetica", "B", 15)
        # Moving cursor to the right:
        self.cell(80)
        # Printing title:
        self.cell(30, 10, "Title", border=1, align="C")
        # Performing a line break:
        self.ln(20)

    def footer(self):
        # Position cursor at 1.5 cm from bottom:
        self.set_y(-15)
        # Setting font: helvetica italic 8
        self.set_font("helvetica", "I", 8)
        # Printing page number:
        self.cell(0, 10, f"Page {self.page_no()}/{{nb}}", align="C")


# Instantiation of inherited class
pdf = PDF()
pdf.add_page()
pdf.set_font("Times", size=12)
for i in range(1, 41):
    pdf.cell(0, 10, f"Printing line number {i}", new_x="LMARGIN", new_y="NEXT")
pdf.output("new-tuto2.pdf")

Resulting PDF

यह उदाहरण header और footer को संसाधित करने के लिए header और footer लेख विधियों का उपयोग करता है। उन्हें स्वचालित रूप से (automatically) बुलाया जाता है। वे पहले से ही FPDF वर्ग में मौजूद हैं लेकिन कुछ नहीं करते हैं, इसलिए हमें class का विस्तार करना होगा और उन्हें override करना होगा।

Logo को निर्दिष्ट करके image विधि से इसका ऊपरी-बाएँ कोना और इसकी चौड़ाई निर्दिष्ट करके मुद्रित किया जाता है। छवि अनुपात का सम्मान करने के लिए ऊंचाई की गणना स्वचालित रूप से की जाती है।

पृष्ठ संख्या (Page number) मुद्रित (print) करने के लिए, सेल चौड़ाई (cell width) के रूप में एक शून्य मान(null value) पास किया जाता है।

इसका मतलब है कि सेल को पेज के दाहिने हाशिये (right margin) तक बढ़ाया जाना चाहिए; यह पाठ को केंद्र(center) में रखने के लिए आसान है।

वर्तमान पृष्ठ संख्या page_no विधि द्वारा वापस की जाती है; पृष्ठों की कुल संख्या के लिए, यह विशेष मूल्य {nb} के माध्यम से प्राप्त किया जाता है जिसे दस्तावेज़ बंद होने पर प्रतिस्थापित किया जाएगा कहा जाता है)।

set_y पद्धति के उपयोग पर ध्यान दें जो पृष्ठ में एक पूर्ण स्थान पर स्थिति सेट करने की अनुमति देता है, ऊपर या नीचे से शुरू होता है।

यहाँ एक और दिलचस्प विशेषता का उपयोग किया गया है: the automatic page breaking. जैसे ही कोई सेल पृष्ठ में एक सीमा को पार करेगा (डिफ़ॉल्ट रूप से नीचे से 2 सेंटीमीटर पर), एक ब्रेक किया जाता है और फ़ॉन्ट को पुनर्स्थापित किया जाता है।

हालांकि शीर्ष लेख (Header) और पाद लेख (Footer) अपने स्वयं के फ़ॉन्ट (Helvetica) का चयन करते हैं, body Times के साथ जारी रहता है। स्वचालित बहाली का यह तंत्र रंगों और रेखा की चौड़ाई पर भी लागू होता है। पृष्ठ विराम को ट्रिगर करने वाली सीमा को set_auto_page_break के साथ सेट किया जा सकता है।

Tuto 3 - लाइन ब्रेक और रंग

आइए एक उदाहरण के साथ जारी रखें जो Justified अनुच्छेदों को प्रिंट करता है। यह रंगों के उपयोग को भी दर्शाता है।

from fpdf import FPDF


class PDF(FPDF):
    def header(self):
        # Setting font: helvetica bold 15
        self.set_font("helvetica", "B", 15)
        # Calculating width of title and setting cursor position:
        width = self.get_string_width(self.title) + 6
        self.set_x((210 - width) / 2)
        # Setting colors for frame, background and text:
        self.set_draw_color(0, 80, 180)
        self.set_fill_color(230, 230, 0)
        self.set_text_color(220, 50, 50)
        # Setting thickness of the frame (1 mm)
        self.set_line_width(1)
        # Printing title:
        self.cell(
            width,
            9,
            self.title,
            border=1,
            new_x="LMARGIN",
            new_y="NEXT",
            align="C",
            fill=True,
        )
        # Performing a line break:
        self.ln(10)

    def footer(self):
        # Setting position at 1.5 cm from bottom:
        self.set_y(-15)
        # Setting font: helvetica italic 8
        self.set_font("helvetica", "I", 8)
        # Setting text color to gray:
        self.set_text_color(128)
        # Printing page number
        self.cell(0, 10, f"Page {self.page_no()}", align="C")

    def chapter_title(self, num, label):
        # Setting font: helvetica 12
        self.set_font("helvetica", "", 12)
        # Setting background color
        self.set_fill_color(200, 220, 255)
        # Printing chapter name:
        self.cell(
            0,
            6,
            f"Chapter {num} : {label}",
            new_x="LMARGIN",
            new_y="NEXT",
            align="L",
            fill=True,
        )
        # Performing a line break:
        self.ln(4)

    def chapter_body(self, filepath):
        # Reading text file:
        with open(filepath, "rb") as fh:
            txt = fh.read().decode("latin-1")
        # Setting font: Times 12
        self.set_font("Times", size=12)
        # Printing justified text:
        self.multi_cell(0, 5, txt)
        # Performing a line break:
        self.ln()
        # Final mention in italics:
        self.set_font(style="I")
        self.cell(0, 5, "(end of excerpt)")

    def print_chapter(self, num, title, filepath):
        self.add_page()
        self.chapter_title(num, title)
        self.chapter_body(filepath)


pdf = PDF()
pdf.set_title("20000 Leagues Under the Seas")
pdf.set_author("Jules Verne")
pdf.print_chapter(1, "A RUNAWAY REEF", "20k_c1.txt")
pdf.print_chapter(2, "THE PROS AND CONS", "20k_c1.txt")
pdf.output("tuto3.pdf")

Resulting PDF

Jules Verne text

get_string_width विधि वर्तमान फ़ॉन्ट में एक स्ट्रिंग की लंबाई निर्धारित करने की अनुमति देती है, जिसका उपयोग शीर्षक के आसपास के फ्रेम की स्थिति और चौड़ाई की गणना करने के लिए यहां किया जाता है।

फिर रंग सेट किए जाते हैं (set_draw_color, सेट फिल कलर और सेट टेक्स्ट कलर के माध्यम से) और लाइन की मोटाई सेटलाइन चौड़ाई के साथ 1 मिमी (डिफ़ॉल्ट रूप से 0.2 के खिलाफ) पर सेट की जाती है।

फिर रंग सेट किए जाते हैं (set_draw_color, set_fill_color और set_text_color के माध्यम से) और लाइन की मोटाई set_line_width के साथ 1 मिमी (डिफ़ॉल्ट रूप से 0.2 के विरुद्ध) पर सेट की जाती है। अंत में, हम सेल को आउटपुट करते हैं (अंतिम पैरामीटर के true होने से हमे पता चलता है कि पृष्ठभूमि को भरा जाना चाहिए)।

पैराग्राफ को प्रिंट करने के लिए इस्तेमाल की जाने वाली विधि multi_cell है। हर बार जब कोई लाइन cell के दाहिने छोर तक पहुँचती है या carriage return कैरेक्टर मिलता है, तो एक लाइन ब्रेक जारी किया जाता है और current cell के तहत एक नया सेल स्वचालित रूप से बनाया जाता है। Text डिफ़ॉल्ट रूप से Justified है।

दो दस्तावेज़ गुण परिभाषित हैं: शीर्षक (set_title) और लेखक (set_author). गुणों को दो तरीकों से देखा जा सकता है। सबसे पहले दस्तावेज़ को सीधे एक्रोबेट रीडर के साथ खोलना है, फ़ाइल मेनू पर जाएँ और दस्तावेज़ गुण विकल्प चुनें। दूसरा, प्लग-इन से भी उपलब्ध है, राइट-क्लिक करना और दस्तावेज़ गुण चुनना है।

Tuto 4 - मल्टी कॉलम

यह उदाहरण पिछले एक का एक प्रकार है, जिसमें दिखाया गया है कि टेक्स्ट को कई कॉलम में कैसे रखा जाए।

from fpdf import FPDF


class PDF(FPDF):
    def __init__(self):
        super().__init__()
        self.col = 0  # Current column
        self.y0 = 0  # Ordinate of column start

    def header(self):
        self.set_font("helvetica", "B", 15)
        width = self.get_string_width(self.title) + 6
        self.set_x((210 - width) / 2)
        self.set_draw_color(0, 80, 180)
        self.set_fill_color(230, 230, 0)
        self.set_text_color(220, 50, 50)
        self.set_line_width(1)
        self.cell(
            width,
            9,
            self.title,
            border=1,
            new_x="LMARGIN",
            new_y="NEXT",
            align="C",
            fill=True,
        )
        self.ln(10)
        # Saving ordinate position:
        self.y0 = self.get_y()

    def footer(self):
        self.set_y(-15)
        self.set_font("helvetica", "I", 8)
        self.set_text_color(128)
        self.cell(0, 10, f"Page {self.page_no()}", align="C")

    def set_col(self, col):
        # Set column position:
        self.col = col
        x = 10 + col * 65
        self.set_left_margin(x)
        self.set_x(x)

    @property
    def accept_page_break(self):
        if self.col < 2:
            # Go to next column:
            self.set_col(self.col + 1)
            # Set ordinate to top:
            self.set_y(self.y0)
            # Stay on the same page:
            return False
        # Go back to first column:
        self.set_col(0)
        # Trigger a page break:
        return True

    def chapter_title(self, num, label):
        self.set_font("helvetica", "", 12)
        self.set_fill_color(200, 220, 255)
        self.cell(
            0,
            6,
            f"Chapter {num} : {label}",
            new_x="LMARGIN",
            new_y="NEXT",
            border="L",
            fill=True,
        )
        self.ln(4)
        # Saving ordinate position:
        self.y0 = self.get_y()

    def chapter_body(self, name):
        # Reading text file:
        with open(name, "rb") as fh:
            txt = fh.read().decode("latin-1")
        # Setting font: Times 12
        self.set_font("Times", size=12)
        # Printing text in a 6cm width column:
        self.multi_cell(60, 5, txt)
        self.ln()
        # Final mention in italics:
        self.set_font(style="I")
        self.cell(0, 5, "(end of excerpt)")
        # Start back at first column:
        self.set_col(0)

    def print_chapter(self, num, title, name):
        self.add_page()
        self.chapter_title(num, title)
        self.chapter_body(name)


pdf = PDF()
pdf.set_title("20000 Leagues Under the Seas")
pdf.set_author("Jules Verne")
pdf.print_chapter(1, "A RUNAWAY REEF", "20k_c1.txt")
pdf.print_chapter(2, "THE PROS AND CONS", "20k_c1.txt")
pdf.output("tuto4.pdf")

Resulting PDF

Jules Verne text

पिछले ट्यूटोरियल से मुख्य अंतर accept_page_break और set_col विधियों का उपयोग है।

accept_page_break विधि का उपयोग करते हुए, एक बार जब सेल पृष्ठ की निचली सीमा को पार कर जाता है, तो यह वर्तमान कॉलम संख्या की जांच करेगा। यदि यह 2 से कम है (हमने पृष्ठ को तीन स्तंभों में विभाजित करना चुना है) तो यह set_col विधि को कॉल करेगा, कॉलम संख्या बढ़ाना और अगले कॉलम की स्थिति बदलना ताकि टेक्स्ट वहां जारी रह सके। एक बार तीसरे कॉलम की निचली सीमा तक पहुँच जाने पर, accept_page_break विधि रीसेट हो जाएगी और पहले कॉलम पर वापस जाएगी और एक पेज ब्रेक को ट्रिगर करेगी।

Tuto 5 - टेबल बनाना

यह ट्यूटोरियल समझाएगा कि टेबल को आसानी से कैसे बनाया जाए।

कुछ सरल समायोजनों के साथ क्या हासिल किया जा सकता है, यह समझाने के लिए कोड तीन अलग-अलग टेबल बनाएगा।

import csv
from fpdf import FPDF


class PDF(FPDF):
    def basic_table(self, headings, rows):
        for heading in headings:
            self.cell(40, 7, heading, 1)
        self.ln()
        for row in rows:
            for col in row:
                self.cell(40, 6, col, 1)
            self.ln()

    def improved_table(self, headings, rows, col_widths=(42, 39, 35, 40)):
        for col_width, heading in zip(col_widths, headings):
            self.cell(col_width, 7, heading, border=1, align="C")
        self.ln()
        for row in rows:
            self.cell(col_widths[0], 6, row[0], border="LR")
            self.cell(col_widths[1], 6, row[1], border="LR")
            self.cell(col_widths[2], 6, row[2], border="LR", align="R")
            self.cell(col_widths[3], 6, row[3], border="LR", align="R")
            self.ln()
        # Closure line:
        self.cell(sum(col_widths), 0, "", border="T")

    def colored_table(self, headings, rows, col_widths=(42, 39, 35, 42)):
        # Colors, line width and bold font:
        self.set_fill_color(255, 100, 0)
        self.set_text_color(255)
        self.set_draw_color(255, 0, 0)
        self.set_line_width(0.3)
        self.set_font(style="B")
        for col_width, heading in zip(col_widths, headings):
            self.cell(col_width, 7, heading, border=1, align="C", fill=True)
        self.ln()
        # Color and font restoration:
        self.set_fill_color(224, 235, 255)
        self.set_text_color(0)
        self.set_font()
        fill = False
        for row in rows:
            self.cell(col_widths[0], 6, row[0], border="LR", align="L", fill=fill)
            self.cell(col_widths[1], 6, row[1], border="LR", align="L", fill=fill)
            self.cell(col_widths[2], 6, row[2], border="LR", align="R", fill=fill)
            self.cell(col_widths[3], 6, row[3], border="LR", align="R", fill=fill)
            self.ln()
            fill = not fill
        self.cell(sum(col_widths), 0, "", "T")


def load_data_from_csv(csv_filepath):
    headings, rows = [], []
    with open(csv_filepath, encoding="utf8") as csv_file:
        for row in csv.reader(csv_file, delimiter=","):
            if not headings:  # extracting column names from first row:
                headings = row
            else:
                rows.append(row)
    return headings, rows


col_names, data = load_data_from_csv("countries.txt")
pdf = PDF()
pdf.set_font("helvetica", size=14)
pdf.add_page()
pdf.basic_table(col_names, data)
pdf.add_page()
pdf.improved_table(col_names, data)
pdf.add_page()
pdf.colored_table(col_names, data)
pdf.output("tuto5.pdf")

Resulting PDF - Countries text

चूंकि तालिका (Table) केवल कोशिकाओं (Cells) का एक संग्रह (Collection) है, इसलिए उनमें से एक का निर्माण करना स्वाभाविक है।

पहला उदाहरण सबसे बुनियादी संभव तरीके से हासिल किया गया है: सरल फ़्रेमयुक्त कोशिकाएं (simple framed cells, सभी समान आकार कोशिकाएं (same sized cells) और बाएं संरेखित कोशिकाएं (left aligned cells)। परिणाम अल्पविकसित है लेकिन प्राप्त करने के लिए बहुत जल्दी है।

दूसरी तालिका कुछ सुधार लाती है: प्रत्येक कॉलम की अपनी चौड़ाई होती है, शीर्षक केंद्रित होते हैं और आंकड़े सही संरेखित होते हैं। इसके अलावा, क्षैतिज रेखाओं को हटा दिया गया है। यह Cell() विधि के बॉर्डर पैरामीटर के माध्यम से किया जाता है, जो निर्दिष्ट करता है कि सेल के किन पक्षों को खींचा जाना चाहिए। यहां हम बाएं (L) और दाएं (R) वाले चाहते हैं। अब केवल क्षैतिज रेखा की तालिका (Table) को Finish करने की समस्या बनी हुई है।

इसे हल करने की दो संभावनाएं हैं: लूप में अंतिम पंक्ति की जाँच करें, जिस स्थिति में हम सीमा पैरामीटर के लिए LRB का उपयोग करते हैं; या जैसा कि यहां किया गया है, लूप खत्म होने के बाद लाइन जोड़ें।

तीसरी तालिका दूसरे के समान है लेकिन रंगों का उपयोग करती है। Fill, टेक्स्ट और लाइन रंग बस निर्दिष्ट हैं। वैकल्पिक(Alternate) रूप से पारदर्शी और भरी हुई कोशिकाओं का उपयोग करके पंक्तियों के लिए वैकल्पिक रंग प्राप्त किया जाता है।

Tuto 6 - लिंक बनाना और टेक्स्ट शैलियों को मिलाना

यह ट्यूटोरियल पीडीएफ दस्तावेज़ के अंदर लिंक डालने के साथ-साथ बाहरी स्रोतों के लिंक जोड़ने के कई तरीकों की व्याख्या करेगा। यह कई तरीके भी दिखाएगा जिससे हम एक ही टेक्स्ट के भीतर विभिन्न टेक्स्ट शैलियों, (बोल्ड, इटैलिक, अंडरलाइन) का उपयोग कर सकते हैं।

from fpdf import FPDF


pdf = FPDF()

# First page:
pdf.add_page()
pdf.set_font("helvetica", size=20)
pdf.write(5, "To find out what's new in self tutorial, click ")
pdf.set_font(style="U")
link = pdf.add_link()
pdf.write(5, "here", link)
pdf.set_font()

# Second page:
pdf.add_page()
pdf.set_link(link)
pdf.image(
    "../docs/fpdf2-logo.png", 10, 10, 50, 0, "", "https://pyfpdf.github.io/fpdf2/"
)
pdf.set_left_margin(60)
pdf.set_font_size(18)
pdf.write_html(
    """You can print text mixing different styles using HTML tags: <b>bold</b>, <i>italic</i>,
<u>underlined</u>, or <b><i><u>all at once</u></i></b>!
<br><br>You can also insert links on text, such as <a href="https://pyfpdf.github.io/fpdf2/">https://pyfpdf.github.io/fpdf2/</a>,
or on an image: the logo is clickable!"""
)
pdf.output("tuto6.pdf")

Resulting PDF - fpdf2-logo

टेक्स्ट प्रिंट करने के लिए यहां दिखाया गया नया तरीका write() है। यह बहुत हद तक multi_cell() के समान है, मुख्य अंतर यह है: - पंक्ति का अंत दाएं हाशिये पर है और अगली पंक्ति बाएं हाशिये पर शुरू होती है। - वर्तमान स्थिति पाठ के अंत में चली जाती है।

इसलिए विधि हमें पाठ का एक हिस्सा लिखने, फ़ॉन्ट शैली को बदलने और ठीक उसी स्थान से जारी रखने की अनुमति देती है जहां से हमने छोड़ा था। दूसरी ओर, इसका मुख्य दोष यह है कि हम टेक्स्ट को जस्टिफाई नहीं कर सकते जैसे हम multi_cell() मेथड के साथ करते हैं।

उदाहरण के पहले पृष्ठ में, हमने इस उद्देश्य के लिए write() का उपयोग किया। वाक्य की शुरुआत नियमित शैली के पाठ में लिखी जाती है, फिर set_font() विधि का उपयोग करके, हमने रेखांकित करने के लिए स्विच किया और वाक्य को समाप्त किया।

दूसरे पृष्ठ की ओर इशारा करते हुए एक आंतरिक लिंक जोड़ने के लिए, हमने add_link() विधि का उपयोग किया, जो एक क्लिक करने योग्य क्षेत्र बनाता है जिसे हमने "Link" नाम दिया है जो दस्तावेज़ के भीतर किसी अन्य स्थान पर निर्देशित करता है।

दूसरे पृष्ठ पर, हमने अभी-अभी बनाए गए लिंक के लिए गंतव्य क्षेत्र को परिभाषित करने के लिए set_link() का उपयोग किया।

Image का उपयोग करके बाहरी लिंक बनाने के लिए, हमने image() का उपयोग किया। विधि में एक लिंक को इसके तर्कों में से एक के रूप में पारित करने का विकल्प होता है। लिंक आंतरिक या बाहरी दोनों हो सकता है।

एक विकल्प के रूप में, फ़ॉन्ट शैली बदलने और लिंक जोड़ने का दूसरा विकल्प write_html() पद्धति का उपयोग करना है। यह एक HTML पार्सर है, जो टेक्स्ट जोड़ने, फ़ॉन्ट शैली बदलने और html का उपयोग करके लिंक जोड़ने की अनुमति देता है।