Cara menggunakan Printer perangkat font

Terjemahan Artikel Terjemahan Artikel
ID Artikel: 201978
Perbesar semua | Perkecil semua

Pada Halaman ini

RINGKASAN

Font yang berada di printer kadang-kadang dapat sangat berguna dan sulit untuk digunakan dalam kode program aplikasi. Artikel ini menjelaskan cara menentukan font printer-penduduk perangkat yang tersedia untuk digunakan dalam konteks perangkat printer Win32. Artikel ini juga menjelaskan beberapa masalah yang dapat terjadi saat Anda mencoba menggunakan font printer tersebut dalam kode aplikasi.

INFORMASI LEBIH LANJUT

Dalam kebanyakan kasus, pengembang perangkat lunak bergantung pada sistem operasi untuk menyediakan font yang akan digunakan untuk gambar yang. Untuk melakukan ini, Anda dapat memilih sistem operasi disediakan font melalui antarmuka pemrograman aplikasi (API) atau melalui umum Pilih Font kotak dialog. Namun, aplikasi biasanya tidak peduli dengan font tertentu yang digunakan, hanya itu memenuhi persyaratan tertentu dan bahwa pengguna lebih suka font. Persyaratan ini meliputi:
  • Font harus ukuran tertentu.
  • Font harus berisi karakter (atau dikenal sebagai mesin terbang).
  • Font harus memiliki gaya tertentu.
Biasanya, bila aplikasi mencetak dokumen, font (atau font yang sama untuk itu) digunakan pada printer tanpa tindakan tertentu dari aplikasi. Hal ini biasanya hasil yang benar untuk aplikasi, dan ini menghasilkan hasil cetak yang baik pada kecepatan yang wajar.

Namun, kadang-kadang pengembang aplikasi mungkin untuk memilih hanya tertentu font khusus dari target printer. Secara historis, ini adalah diperlukan pada dampak-tipe printer (misalnya, dot matrix printer) untuk mendapatkan format tertentu atau untuk mempercepat pencetakan.

Hari ini, sebagian besar printer yang pada dasarnya dirancang sebagai perangkat raster dan dapat menarik titik (piksel) pada setiap bagian dari kertas hanya sebagai efisien sebagai semua karakter mesin terbang. Untuk sebagian besar aplikasi, hal ini tidak masalah apakah karakter mesin terbang diambil sebagai bentuk seluruh dari definisi printer-penduduk atau diambil sebagai kumpulan piksel yang menyediakan sistem operasi. Namun, Anda mungkin masih ingin menggunakan font yang hanya printer menyediakan. Sebagai contoh, hal ini mungkin terjadi karena font unik dan tidak ada pengganti yang serupa dalam sistem operasi atau mungkin karena Anda ingin menghindari overhead men-download definisi font untuk printer.

Untuk keperluan artikel ini, "perangkat huruf" adalah setiap font definisi yang ada secara permanen atau transiently di memori printer. Font perangkat ini memberikan karakter mesin terbang definisi yang dapat diatasi per karakter dengan printer halaman rasterizer hardware untuk tinta bentuk ke kertas.

Perangkat font dapat dikategorikan menjadi tiga jenis dasar:
  • Benar perangkat font. Untuk keperluan artikel ini, ini adalah font yang hanya perangkat-keras printer menyediakan dan bahwa Anda dapat menggunakan hanya pada printer.
  • Perangkat font substitusi. Font yang ada dalam sistem operasi dan perangkat keras printer juga menyediakan. Dalam kasus ini, perangkat keras printer dapat menggantikan sistem operasi font.
  • Download font. Font yang menyediakan sistem operasi namun definisi yang dapat didownload pada printer dan digunakan pada printer seolah-olah perangkat keras printer disediakan font langsung.

Download font

Sistem operasi menyediakan download font, yang juga dikenal sebagai lembut font. Ketika Anda mencetak dokumen, definisi font yang disediakan sebagai bagian dari pekerjaan pencetakan. Ketika printer proses pencetakan, definisi font terinstal di memori printer sehingga definisi font dapat tinta ke halaman dicetak dokumen.

Beberapa berpendapat bahwa karena printer menggambar karakter mesin terbang dari font, Font ini adalah perangkat font. Namun, ketika definisi font yang di-download atau ketika suatu ditarik ke printer melalui suatu bitmap, hanya beberapa overhead atau cetak pekerjaan spul ukuran disimpan. Proses ini terjadi secara transparan untuk aplikasi sehingga font di sistem operasi dapat digunakan pada layar dan printer. Karena artikel ini berfokus pada bagaimana menggunakan perangkat font yang hanya printer menyediakan, artikel ini tidak menjelaskan bagaimana menggunakan download font.

Perangkat Font substitusi

Perangkat font substitusi terjadi ketika terdapat dua, definisi font yang berbeda: salah satu yang menggunakan sistem operasi, dan salah satu yang menggunakan printer. Yaitu aplikasi memilih dan menggunakan font di sistem operasi dalam sebuah dokumen pada layar. Ketika Anda mencetak dokumen, output dicetak diambil dengan menggunakan juga didefinisikan font yang menyediakan printer. Oleh karena itu, font di sistem operasi telah digantikan pada printer dengan font printer-didefinisikan.

Hal ini biasanya terjadi pada printer PostScript ketika Windows TrueType font yang umum digunakan. Contoh ini adalah font TrueType Arial yang biasanya dicetak dengan menggunakan definisi font PostScript untuk font Helvetica pada sebagian besar perangkat PostScript. Ini adalah contoh substitusi dengan menggunakan font yang sama namanya font benar-benar berbeda. Dalam kasus ini, Anda biasanya dapat menemukan dan menggunakan definisi font yang sama ini secara langsung karena definisi font serupa juga terkena sebagai font benar perangkat. Ini dibahas nanti dalam artikel ini.

Perangkat font substitusi juga terjadi ketika font pada printer memiliki nama yang sama sebagai font yang menyediakan sistem operasi. Hal ini biasanya terjadi pada printer seperti Hewlett-Packard LaserJet printer. Printer yang biasanya memiliki versi mereka sendiri dari inti Windows font Arial dan kali baru Romawi. Meskipun font ini juga biasanya dapat ditemukan dengan mencari perangkat benar font, penggunaan mereka kadang-kadang tidak dapat dijamin karena driver printer sering memilih mereka sendiri atau pilih melalui pengaturan pengguna apakah akan menggunakan font yang sistem operasi menyediakan sebaliknya.

Perangkat font

Font perangkat sejati adalah mereka yang hanya memiliki definisi pada printer. Satu-satunya cara bahwa aplikasi dapat menggunakan font ini adalah untuk aplikasi khusus mengidentifikasi font dan membuat untuk digunakan dalam konteks perangkat printer.

Jika Anda tahu cukup informasi tentang perangkat, Anda dapat membuat deskripsi logis font di LOGFONT struktur yang akan mengakibatkan realisasi font perangkat. Secara khusus, sangat penting untuk memberikan informasi yang benar untuk lfFacename anggota, lfHeight anggota, dan set karakter font. Juga, lfOutPrecision anggota harus berisi OUT_DEVICE_PRECIS bendera untuk mempengaruhi proses pemetaan font untuk memilih perangkat font bukannya sistem demikian pula bernama font.

Jika deskripsi font tidak diketahui, Anda dapat menghitung font untuk menemukan perangkat font. Untuk mendapatkan daftar perangkat font yang mendukung printer, gunakan salah satu font enumerasi fungsi seperti EnumFontFamiliesEx. Kode aplikasi yang dimasukkan dalam fungsi panggilan balik dapat memeriksa data yang diberikan untuk fungsi panggilan balik untuk menentukan contoh font yang menggambarkan font perangkat.

Menggunakan benar perangkat font

Proses menggunakan font perangkat dalam konteks perangkat printer yang mengikuti langkah-langkah umum berikut:
  1. Mengidentifikasi font benar perangkat oleh enumerasi font dalam konteks perangkat printer.
  2. Pilih font yang perangkat hanya seperti yang ditunjukkan oleh FontType Bendera dan oleh proses eliminasi.
  3. Menggunakan metrik printer khusus dalam modus pemetaan MM_TEXT untuk secara akurat tempat teks yang diambil dengan menggunakan font perangkat.

Enumerasi font Printer perangkat konteks

Untuk menghitung semua font yang tersedia dalam konteks perangkat, Anda dapat menggunakan fungsi panggilan balik dan EnumFontFamiliesEx fungsi dari Win32 antarmuka pemrograman aplikasi (API). Untuk menghitung semua font untuk konteks perangkat, Anda harus menghubungi EnumFontFamiliesEx dua kali: pertama untuk mendapatkan daftar font keluarga, dan kedua kalinya untuk mendapatkan semua font yang berbeda yang ada di setiap font keluarga. Untuk informasi lebih lanjut tentang enumerasi lengkap sistem font, lihat bagian "Referensi" dari artikel ini.

Untuk menemukan semua perangkat font pada konteks perangkat printer, Anda harus menghitung semua font printer perangkat konteks. Ketika setiap font dilewatkan ke fungsi Panggil balik, font diteliti untuk menentukan apakah itu adalah font perangkat. The PrinterDeviceFontEnum dan PrinterDeviceFontFamiliesEnum fungsi panggilan balik dalam kode contoh berikut melakukan operasi ini.
// Data structure to pass data through the font enumeration callbacks.
typedef struct PrintEnumFontData
{
    HDC             hPrinterDC;
    HDC             hEnumDC;
    int             curx, cury;
    ENUMLOGFONTEX   elf;
} PRINTENUMFONTDATA;


int CALLBACK PrinterDeviceFontEnum(
  ENUMLOGFONTEX *lpelfe,    // logical-font data
  NEWTEXTMETRICEX *lpntme,  // physical-font data
  DWORD FontType,           // type of font
  LPARAM lParam             // application-defined data
)
{
    // Crack the data out of the enumeration parameter.
    PRINTENUMFONTDATA *     ppeft = (PRINTENUMFONTDATA*) lParam;

    // Printing information
    TEXTMETRIC              tm;
    HFONT                   hfont, holdfont;
    int                     pagecx, pagecy;

    // Data to determine where this font came from
    ENUMEDFONT      df = { FontType, lpelfe };  // To look for a system version

    // What is the printable area of the page?
    pagecx = GetDeviceCaps(ppeft->hPrinterDC, HORZRES);
    pagecy = GetDeviceCaps(ppeft->hPrinterDC, VERTRES);

    // Is it a device font?
    // If it is, make sure that it is also not a TrueType font because
    // that is most likely a downloaded font.
    // Also, look for any system-provided fonts that are also 
    // masquerading as printer device fonts. This implies that they will be 
    // downloaded to the printer as is the case with Adobe Type 1 fonts.
    // If they are downloaded, you do not want to include them in this demonstration.
    if (FontType & DEVICE_FONTTYPE && 
        !(FontType & TRUETYPE_FONTTYPE) &&
        !IsSystemFont(&df))
    {
        TCHAR           Buffer[MAX_PATH];           // description of font
        LPTSTR          szFontType;                 // description of type
        LPTSTR          pStyle = "Regular";         // Fonts Style defaults to Regular 

        // At this point in this code, the lpelfe parameter has been examined
        // and found to describe a printer device font.
        // Do something interesting with it as follows:
        
        // Build a sample string that describes the font.
        if (lpelfe->elfLogFont.lfItalic)
        {
            pStyle = "Italic";
            if (lpelfe->elfLogFont.lfWeight > FW_NORMAL)
                pStyle = "Bold Italic";
        }
        else if (lpelfe->elfLogFont.lfWeight > FW_NORMAL)
            pStyle = "Bold";

        // Determine if the font is scalable or a bitmap font.
        if (FontType & RASTER_FONTTYPE)
            szFontType = TEXT("Bitmap Font");
        else
        {
            // This is an instance of a scalable font, 
            // use 12 pt because it is easy to read.
            szFontType = TEXT("Scalable Font");
            lpelfe->elfLogFont.lfHeight = MulDiv(12, GetDeviceCaps(ppeft->hPrinterDC, LOGPIXELSY), 72);
            lpelfe->elfLogFont.lfWidth = 0;
        }

        // Skip all fonts after this font that are the same scale as the last one.
        // However, let different sizes of 'bitmap' fonts through.
        // This is a cheat that relies on enumeration order.
        // Really, you should keep a 'used' list and compare against the list.
        if (FontType & RASTER_FONTTYPE || !CompareLogFontEx(&ppeft->elf, lpelfe))
        {

            hfont = CreateFontIndirect(&lpelfe->elfLogFont);
            holdfont = (HFONT)SelectObject(ppeft->hPrinterDC, hfont);
            GetTextMetrics(ppeft->hPrinterDC, &tm);
            
            // If beyond bottom of page, get a new page.
            if (pagecy < ppeft->cury + tm.tmExternalLeading + tm.tmHeight)
            {
                EndPage(ppeft->hPrinterDC);
                StartPage(ppeft->hPrinterDC);
                ppeft->cury = 0;
            }

            // Draw our sample text.
            wsprintf(Buffer, "%s %s [%s]  FontType: %s", lpelfe->elfFullName, pStyle, lpelfe->elfScript, szFontType);
            ppeft->cury += tm.tmExternalLeading;
            TextOut(ppeft->hPrinterDC, ppeft->curx, ppeft->cury, Buffer, lstrlen(Buffer));
            ppeft->cury += tm.tmHeight;

            // Clean up.
            SelectObject(ppeft->hPrinterDC, holdfont);
            DeleteObject(hfont);

            // Make a note of the font that you used so that the next time
            // this callback is called, you can skip different scales of 
            // the same font.
            CopyMemory(&ppeft->elf, lpelfe, sizeof(ENUMLOGFONTEX));
        }
    }
    // Otherwise, continue enumeration without doing anything with this
    // particular font.

    return 1;
}

int CALLBACK PrinterDeviceFontFamiliesEnum(
  ENUMLOGFONTEX *lpelfe,    // logical-font data
  NEWTEXTMETRICEX *lpntme,  // physical-font data
  DWORD FontType,           // type of font
  LPARAM lParam             // application-defined data
)
{
    PRINTENUMFONTDATA * ppeft = (PRINTENUMFONTDATA*) lParam;

    ZeroMemory(&ppeft->elf, sizeof(ppeft->elf));

    // Is it a device font?
    // If it is, make sure that it is also not a TrueType font because
    // that is most likely a downloaded font.
    if (FontType & DEVICE_FONTTYPE && !(FontType & (TRUETYPE_FONTTYPE)))
    {
    
        // Enumerate all of the font instances that are part of this 
        // font family.
        return EnumFontFamiliesEx(ppeft->hEnumDC, 
            &lpelfe->elfLogFont, 
            (FONTENUMPROC)PrinterDeviceFontEnum, 
            lParam, 
            0);
    }

    // Otherwise, if you are not interested in this particular font, 
    // continue enumeration so that you can find more.
    return 1;
}

BOOL CALLBACK AbortProc(HDC hdc, int iError)
/*
    This minimal AbortProc implementation stops the print
    job when an error occurs.
 */ 
{
    if (iError)
        return FALSE;
    return TRUE;
}

BOOL PrintDeviceFontList(HDC hPrinterDC)
{
    int ret;
    LOGFONT             lf;     // Describes the start of the font enumeration
    PRINTENUMFONTDATA peft = 
    { 
        hPrinterDC,             // Device Context on which to print
        hPrinterDC,             // Device Context to enumerate 
        0, 0,                   // Current print location
        NULL                    // Last device font that is used to print
    };
    DOCINFO di;                 // Description of the print job

    // Start the print job.
    ZeroMemory(&di, sizeof(di));
    di.cbSize = sizeof(di);
    di.lpszDocName = TEXT("Printer Font List");

    // Set a minimal AbortProc because there should always be one.
    ret = SetAbortProc(hPrinterDC, (ABORTPROC) AbortProc);
    if (ret < 1) return false;

    ret = StartDoc(hPrinterDC, &di);
    if (ret < 1) return false;

    ret = StartPage(hPrinterDC);
    if (ret < 1)
    {
        AbortDoc(hPrinterDC);
        return false;
    }

    // Enumerate everything to start, weed out non-device fonts, 
    // and then print non-device fonts during enumeration.
    ZeroMemory(&lf, sizeof(lf));
    lf.lfCharSet = DEFAULT_CHARSET;

    // Call the enumeration with your callback function that prints
    // the device fonts that it finds.
    ret = EnumFontFamiliesEx(hPrinterDC, 
        &lf, 
        (FONTENUMPROC)PrinterDeviceFontFamiliesEnum, 
        (LPARAM)&peft, 
        0);

    // The value 1 is returned by the callback functions to continue
    // the enumeration. When the enumeration completes, EnumFontFamiliesEx
    // returns the last value that the callback returns.
    // Therefore, you succeed if you get 1. Let it print.
    if (ret == 1)
    {
        EndPage(hPrinterDC);
        EndDoc(hPrinterDC);
        return true;
    }

    // Otherwise, exit because you failed somewhere in the process.
    AbortDoc(hPrinterDC);
    return false;
}
				
Anda dapat melihat dalam kode contoh di mana EnumFontFamiliesEx fungsi disebut dua kali. Panggilan pertama dibuat di PrintDeviceFontList fungsi. Panggilan kedua PrinterDeviceFontFamiliesEnum fungsi callback.

PrintDeviceFontList adalah tingkat atas fungsi. PrintDeviceFontList melakukan dua tugas oleh memulai pekerjaan pencetakan pada printer perangkat konteks dan kemudian menerapkan panggilan pertama untuk EnumFontFamiliesEx untuk memulai proses penghitungan font. Menurut dokumentasi Platform Software Development Kit (SDK), ketika Anda mengatur LOGFONT struktur lfCharSet anggota DEFAULT_CHARSET nilai, EnumFontFamiliesEx enumerates semua font keluarga. Setelah penghitungan font selesai, kode melengkapi pencetakan manajemen tugas dengan memanggil EndDoc metode.

The PrinterDeviceFontFamiliesEnum fungsi panggilan balik disebut untuk setiap keluarga font oleh EnumFontFamiliesEx fungsi. Dalam fungsi panggilan balik itu, kode awalnya layar font keluarga untuk menemukan hanya font perangkat yang ditandai oleh FontType parameter. Itu juga layar keluar font yang ditandai sebagai TrueType karena font tersebut cenderung download font. Untuk orang-orang font keluarga yang dianggap perangkat font, EnumFontFamiliesEx fungsi disebut lagi tetapi dilewatkan ENUMLOGFONTEX struktur yang fungsi panggilan balik menerima. Penggunaan parameter panggilan balik sebagai parameter input untuk panggilan fungsi enumerasi kedua menyebabkan enumerasi kedua untuk daftar semua font yang berbeda dalam keluarga font.

Memilih perangkat font

Anda dapat menggunakan kriteria tertentu printer perangkat font untuk membedakan font ini dari font lain yang adalah dihitung. Secara khusus, mencari DEVICE_FONTTYPE nilai dalam FontType fungsi panggilan balik DWORD parameter. Hampir semua dari font yang diserahkan untuk fungsi panggilan balik dengan set nilai ini adalah perangkat font untuk konteks perangkat printer (kecuali dengan Adobe font).

Dalam kode contoh, PrinterDeviceFontEnum fungsi panggilan balik disebut oleh enumerasi kedua untuk setiap font yang berbeda di keluarga font. The PrinterDeviceFontEnum fungsi panggilan balik menjalankan 3 tugas:
  • Menggunakan kriteria font perangkat lagi untuk memastikan bahwa fungsi hanya proses font yang diakui sebagai perangkat font.
  • Mencari font dengan menggunakan pencacahan font lain untuk melihat apakah perangkat font juga digunakan dalam sistem layar perangkat konteks.
  • Mencetak contoh font ke pekerjaan pencetakan yang sedang dibuat untuk menunjukkan penggunaan font.
Fungsi panggilan balik ini menggunakan fungsi yang bernama IsSystemFont, yang merupakan bagian dari kode contoh berikut:
BOOL CompareLogFontEx(
  CONST ENUMLOGFONTEX * Destination,   // copy destination
  CONST ENUMLOGFONTEX * Source  // memory block
)
/*
    Returns true if the two ENUMLOGFONTEX buffers compare.
    Return false if the two buffers differ in someway as described by the 
    criteria below.
 */ 
{

    // Compare the string descriptions:
    if (lstrcmpi((LPCTSTR )Destination->elfFullName, (LPCTSTR )Source->elfFullName) != 0)
        return false;
    if (lstrcmpi((LPCTSTR )Destination->elfScript, (LPCTSTR )Source->elfScript) != 0)
        return false;
    if (lstrcmpi((LPCTSTR )Destination->elfStyle, (LPCTSTR )Source->elfStyle) != 0)
        return false;

    // Height and Width are not compared because they will change
    // based upon the device on which the font is enumerated.
    //  LONG lfHeight; 
    //  LONG lfWidth; 

    // Compare the LOGFONT properties:
    //  LONG lfEscapement; 
    if (Destination->elfLogFont.lfEscapement != Source->elfLogFont.lfEscapement) return false;
    //  LONG lfOrientation; 
    if (Destination->elfLogFont.lfOrientation != Source->elfLogFont.lfOrientation) return false;
    //  LONG lfWeight; 
    if (Destination->elfLogFont.lfWeight != Source->elfLogFont.lfWeight) return false;
    //  BYTE lfItalic; 
    if (Destination->elfLogFont.lfItalic != Source->elfLogFont.lfItalic) return false;
    //  BYTE lfUnderline; 
    if (Destination->elfLogFont.lfUnderline != Source->elfLogFont.lfUnderline) return false;
    //  BYTE lfStrikeOut; 
    if (Destination->elfLogFont.lfStrikeOut != Source->elfLogFont.lfStrikeOut) return false;
    //  BYTE lfCharSet; 
    if (Destination->elfLogFont.lfCharSet != Source->elfLogFont.lfCharSet) return false;
    //  BYTE lfOutPrecision; 
    if (Destination->elfLogFont.lfOutPrecision != Source->elfLogFont.lfOutPrecision) return false;
    //  BYTE lfClipPrecision; 
    if (Destination->elfLogFont.lfClipPrecision != Source->elfLogFont.lfClipPrecision) return false;
    //  BYTE lfQuality; 
    if (Destination->elfLogFont.lfQuality != Source->elfLogFont.lfQuality) return false;
    //  BYTE lfPitchAndFamily; 
    if (Destination->elfLogFont.lfPitchAndFamily != Source->elfLogFont.lfPitchAndFamily) return false;
    //  TCHAR lfFaceName[LF_FACESIZE]; 
    if (lstrcmpi((LPCTSTR )Destination->elfLogFont.lfFaceName, (LPCTSTR )Source->elfLogFont.lfFaceName) != 0) return false;

    // Conclusion: the two LOGFONT enumeration buffers are comparable.
    return true;
}

typedef struct structEnumedFont
{
    DWORD FontType;
    ENUMLOGFONTEX * elfx;
} ENUMEDFONT;

int CALLBACK FindSystemFontEnum(
  ENUMLOGFONTEX *lpelfe,    // logical-font data
  NEWTEXTMETRICEX *lpntme,  // physical-font data
  DWORD FontType,           // type of font
  LPARAM lParam             // application-defined data
)
{
    ENUMEDFONT  *   pdf  = (ENUMEDFONT *)lParam;
    ENUMLOGFONTEX * lpelfeSrc = pdf->elfx;

    lpelfe->elfLogFont.lfHeight = lpelfeSrc->elfLogFont.lfHeight;
    lpelfe->elfLogFont.lfWidth = lpelfeSrc->elfLogFont.lfWidth;

    if (CompareLogFontEx(lpelfeSrc, lpelfe) && FontType == pdf->FontType)
        return 0;       // System font found. Stop enumeration.
    return 1;
}

BOOL IsSystemFont(ENUMEDFONT *pdf)
/*
    Utility function that takes a font that is enumerated from a printer device
    that is in the pdf parameter and that looks for it on a Screen Device
    Context to conclude that the font passed in that came from the 
    printer is really supplied by the system.
 */ 
{
    HDC hScreenDC = GetDC(NULL);    // Get the screen device context.

    // If the enumeration stops by returning zero (0),
    // the font was found on the screen device context so it is a 
    // system-supplied font.
    BOOL fFound = !EnumFontFamiliesEx(hScreenDC, 
        &pdf->elfx->elfLogFont, 
        (FONTENUMPROC)FindSystemFontEnum, 
        (LPARAM)pdf, 
        0);

    // Cleanup
    ReleaseDC(NULL, hScreenDC);
    return fFound;
}
				
Fungsi ini mendeteksi ketika font yang ditandai sebagai font perangkat tetapi tidak benar perangkat font (menurut definisi dalam artikel ini). Hal ini terjadi ketika Adobe font yang diinstal ke dalam sistem melalui salah satu Pengelola Jenis Adobe atau melalui rasterizer Adobe asli yang hadir di Microsoft Windows 2000 atau Microsoft Windows XP.

Ketika ini terjadi, font benar-benar adalah font disediakan sistem yang di-download ke printer, yang kadang-kadang terjadi dengan font TrueType. Sayangnya, ada tidak ada bendera yang dapat Anda gunakan di Windows 98, Windows Millennium Edition (Me), Windows 2000 dan Windows XP yang menunjukkan bahwa font adalah Adobe font yang menyediakan sistem (tidak seperti font TrueType, yang meliputi bendera). Ada indikasi pada NEWTEXTMETRIC struktur ntmFlags anggota, tetapi ini adalah hanya tersedia di Windows 2000 dan kemudian. Oleh karena itu, kode harus resor untuk proses eliminasi. Font dihapus ketika IsSystemFont menentukan bahwa font perangkat disediakan oleh konteks perangkat layar dan konteks perangkat printer.

Untuk menghindari sampel yang berulang-ulang font yang skala, kode juga catatan ketika font calon telah digunakan. Implementasi ini bergantung pada perintah enumerasi font untuk melihat ketika berurutan enumerasi font font yang sama tetapi dalam skala yang berbeda. Untuk menghapus font yang hanya skala berbeda, kode menggunakan CompareLogFontEx fungsi.

CATATAN: Dokumentasi untuk pemrograman sistem operasi Windows tidak menyatakan bahwa contoh font yang berbeda hanya oleh skala akan dihitung secara berurutan. Contoh kode menggunakan teknik ini karena enumerasi terlihat untuk bekerja dengan cara ini, dan penurunan jumlah sampel baris pada halaman dicetak bukanlah fitur kritis kode demonstrasi. Jika Anda ingin bergantung pada menghilangkan skala yang berbeda dari font yang sama, Anda harus menjaga struktur data perangkat font yang digunakan. Kemudian program harus memeriksa font saat ini dihitung terhadap struktur data itu.

Scalable vs font Bitmap

Ada dua jenis perangkat font yang dapat dihitung pada printer:
  • Font bitmap atau raster
  • Scalable font
Font bitmap adalah font yang memiliki karakter mesin terbang definisi dari ukuran yang tetap. Scalable font yang font yang memiliki definisi yang berbasis matematika di printer sehingga mereka dapat ditarik setiap ukuran. Dengan kata lain, mereka ukuran skala.

Contoh klasik bitmap font adalah kurir 10 cpi. Sesuai namanya, font ini adalah terus di atas dari transisi dari mesin tik untuk dampak-tipe printer. Hal ini disebut bitmap font karena dengan definisi font yang paling umum terletak di ROM bitmap image dari sebuah dot matrix printer.

Contoh scalable, penduduk printer-font dapat ditemukan di sebagian besar printer PostScript di mana biasanya ada seperangkat standar font PostScript Helvetica dan kali.

Font perangkat yang tidak scalable memiliki sedikit yang diatur dalam FontType parameter fungsi callback. Sedikit diwakili oleh simbol RASTER_FONTTYPE di SDK. Jika FontType parameter untuk fungsi panggilan balik tidak memiliki RASTER_FONTTYPE bit set, font adalah scalable font. Untuk contoh cara menentukan ini, lihat PrinterDeviceFontEnum fungsi panggilan balik dari kode contoh.

Gambar perangkat font

Setelah font font perangkat yang menemukan, sampel menggunakan mereka dalam konteks perangkat printer yang pencacahan dilakukan. Perangkat font yang digunakan banyak seperti font lain dengan membuat deskripsi logis dengan CreateFontIndirect fungsi. Panggilan fungsi ini berlalu LOGFONT yang dilewatkan ke dalam fungsi panggilan balik enumerasi font. Setelah HFONT adalah dibuat, digunakan dalam konteks perangkat printer dengan memilih ke dalam konteks perangkat dengan SelectObject fungsi panggilan.

Metrik perangkat font yang diperoleh melalui GetTextMetrics fungsi panggilan. Yang terbaik untuk beroperasi pada printer perangkat konteks dengan menggunakan modus pemetaan MM_TEXT yang adalah modus default pemetaan untuk konteks perangkat. Ketika Anda menggunakan MM_TEXT pemetaan mode, Anda menghindari kesalahan matematika yang dapat terjadi selama proses konversi unit lain pemetaan mode.

Ketika Anda menggunakan font perangkat dalam konteks perangkat printer, Anda harus hati-hati tidak untuk mengangkut metrik untuk font dan string untuk konteks perangkat lain. Hal ini benar terutama dari memori perangkat konteks. Menurut definisi, konteks perangkat memori tidak pekerjaan pencetakan tetapi adalah buffer memori sementara raster grafis dan karena itu tidak dapat menggunakan font perangkat.

Ada pertimbangan penting lainnya ketika Anda menggunakan font perangkat printer: Anda tidak dapat memberikan preview jenis What-You-See-Is-What-You-Get pekerjaan pencetakan. Jelas, font yang berada di perangkat keras printer tidak ditarik ke layar. Terdekat Anda bisa melihat pratinjau pekerjaan pencetakan adalah untuk menemukan font disediakan sistem yang memiliki karakteristik umum printer perangkat font dan kemudian menarik terbang dari font yang pada layar dengan menggunakan ExtTextOut fungsi untuk mensimulasikan penempatan karakter mesin terbang pada halaman dicetak.

Masalah menggunakan perangkat font

Anda mungkin mengalami masalah berikut ketika Anda menggunakan font perangkat:
  • Ada perangkat font, tetapi pengandar printer tidak menyebutkan itu.

    Ada dua alasan mengapa Anda mungkin tidak dapat menemukan perangkat font dengan enumerasi font yang tersedia untuk digunakan pada printer perangkat konteks:
    • Pengandar printer ditulis untuk mengecualikan font perangkat yang untuk beberapa alasan.
    • Pengandar printer enumerates font, tapi font tidak benar ditandai dalam FontType parameter sebagai perangkat font.
  • Ada sistem font yang tampaknya menghitung sebagai perangkat font.

    Masalah ini terjadi ketika font yang disediakan sistem yang di-download ke printer.

    Ketika hal ini terjadi dengan font TrueType, fungsi panggilan balik enumerasi font menerima panggilan dengan TRUETYPE_FONTTYPE dan DEVICE_FONTTYPE bit set pada FontType parameter. Ini ditangani dalam kode contoh oleh tidak termasuk font yang berisi kombinasi ini bit.

    Hal ini juga terjadi dengan Adobe PostScript font yang diinstal pada sistem yang di-download ke printer. Salah satu cara untuk membedakan font ini dari font perangkat lain adalah untuk mencari mereka dalam konteks perangkat layar sistem dan konteks perangkat printer. Jika font yang sama dapat dihitung pada konteks perangkat kedua, font akan kemungkinan didownload ke printer bila digunakan pada konteks perangkat printer.
  • Pengandar printer enumerates beberapa perangkat scalable font, tapi mereka tampaknya sama kecuali untuk ukuran mereka.

    Banyak driver printer menghitung scalable font dengan menyediakan beberapa contoh yang berbeda dari font yang sama dengan ukuran yang berbeda. Ini ditangani dalam kode contoh dengan membandingkan berbagai contoh font yang dianggap untuk menjadi terukur dengan menggunakan CompareLogFontEx fungsi.

    CATATAN: Ketika FontType parameter untuk fungsi panggilan balik telah RASTER_FONTTYPE bit set, beberapa enumerasi menyediakan deskripsi dari contoh-contoh spesifik font non-scalable untuk setiap ukuran. Setiap panggilan balik enumerates ukuran hanya di mana font yang tersedia.
  • Beberapa printer tidak muncul untuk memiliki perangkat font.

    Hal ini benar. Beberapa printer, yaitu tinta jet-tipe printer, tidak memberikan perangkat font. Printer ini secara ketat raster perangkat dan karena itu tidak memiliki definisi font printer-penduduk.

REFERENSI

Untuk informasi tambahan, klik nomor artikel di bawah ini untuk melihat artikel di dalam Basis Pengetahuan Microsoft:
99672 INFO: Enumerasi lengkap sistem font
75469 Bagaimana untuk secara akurat menampilkan pada layar apa akan mencetak
230342 Cara menentukan ketika Font penciptaan adalah sukses

Properti

ID Artikel: 201978 - Kajian Terakhir: 19 September 2011 - Revisi: 2.0
Kata kunci: 
kbdswgdi2003swept kbgdi kbhowto kbmt KB201978 KbMtid
Penerjemahan Mesin
PENTING: Artikel ini diterjemahkan menggunakan perangkat lunak mesin penerjemah Microsoft dan bukan oleh seorang penerjemah. Microsoft menawarkan artikel yang diterjemahkan oleh seorang penerjemah maupun artikel yang diterjemahkan menggunakan mesin sehingga Anda akan memiliki akses ke seluruh artikel baru yang diterbitkan di Pangkalan Pengetahuan (Knowledge Base) dalam bahasa yang Anda gunakan. Namun, artikel yang diterjemahkan menggunakan mesin tidak selalu sempurna. Artikel tersebut mungkin memiliki kesalahan kosa kata, sintaksis, atau tata bahasa, hampir sama seperti orang asing yang berbicara dalam bahasa Anda. Microsoft tidak bertanggung jawab terhadap akurasi, kesalahan atau kerusakan yang disebabkan karena kesalahan penerjemahan konten atau penggunaannya oleh para pelanggan. Microsoft juga sering memperbarui perangkat lunak mesin penerjemah.
Klik disini untuk melihat versi Inggris dari artikel ini:201978

Berikan Masukan

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com