Misplaced Pages

#208791

58-480: Printer drivers should not be confused with print spoolers , which queue print jobs and send them successively to a printer. Unix and other Unix-like systems such as Linux and OS X use CUPS (short for Common Unix Printing System), a modular printing system for Unix-like computer operating systems, which allows a computer to act as a print server . A computer running CUPS is a host that can accept print jobs from client computers, process them, and send them to

116-400: A card reader , a spooler can maintain a sequence of computational jobs waiting for data, starting each job when all of the relevant input is available; see batch processing . The spool itself refers to the sequence of jobs, or the storage area where they are held. In many cases, the spooler is able to drive devices at their full rated speed with minimal impact on other processing. Spooling

174-572: A software development kit , Microsoft Windows SDK , which includes documentation and tools for building software based on the Windows API. This section lists notable services provided by the Windows API. Base services include features such as the file system , devices , processes , threads , and error handling . These functions reside in kernel.exe , krnl286.exe or krnl386.exe files on 16-bit Windows, and kernel32.dll and KernelBase.dll on 32 and 64 bit Windows. These files reside in

232-501: A DLL file called commctrl.dll on 16-bit Windows, and comctl32.dll on 32-bit Windows. It is grouped under the User Interface category of the API. The Windows Shell component provides access to the operating system shell . The component resides in shell.dll on 16-bit Windows, and shell32.dll on 32-bit Windows. The Shell Lightweight Utility Functions are in shlwapi.dll . It

290-524: A compiler that could produce the code needed for these thunks. Versions of 64-bit Windows are also able to run 32-bit applications via WoW64 . The SysWOW64 folder located in the Windows folder on the OS drive contains several tools to support 32-bit applications. Each version of Microsoft Windows contains a version of Windows API, and almost every new version of Microsoft Windows has introduced additions and changes to

348-534: A complex scheme of API thunks was used that could allow 32-bit code to call into 16-bit code (for most of Win16 APIs) and vice versa. Flat thunks allowed 32-bit code to call into 16-bit libraries, and the scheme was used extensively inside Windows 95's libraries to avoid porting the whole OS to Win32 in one batch. In Windows NT, the OS was pure 32-bit, except parts for compatibility with 16-bit applications, and only generic thunks were available to thunk from Win16 to Win32, as for Windows 95. The Platform SDK shipped with

406-405: A computer application and a slow peripheral , such as a printer . Spooling allows programs to "hand off" work to be done by the peripheral and then proceed to other tasks, or to not begin until input has been transcribed. A dedicated program, the spooler , maintains an orderly sequence of jobs for the peripheral and feeds it data at its own rate. Conversely, for slow input peripherals, such as

464-451: A driver to be controlled. In addition to being install-able on a computer, drivers could also be present in the embedded firmware of printers and made available through a networking protocol (e.g. IPP). The embedded firmware of a printer could thus eliminate the need to install any driver on a computer, by accepting print data in a general purpose format (e.g. PDF) via a networking protocol. Despite some efforts to standardize various stages of

522-524: A dynamically loadable print spooler named PRINT as well as optional support to support screen captures also in graphics mode through GRAPHICS . If the optional character device driver PRINTER.SYS is loaded, DOS provides its code page switching support also for the associated printers—different types of dot matrix and ink jet printers are supported by default. Beyond this, there are no system-wide printer-specific drivers for use at application level under MS-DOS/PC DOS. Under DR-DOS , however,

580-486: A final device-specific format that the printer hardware can process and create a print. These drivers act as the last stage in delivering a print job to the printer. These drivers are more likely to be embedded in printer firmware. Examples of manufacturer specific formats include: Install-able drivers can be packaged in various formats. PPD is a popular packaging format for drivers that accept Postscript data or PDF data as input. Due to dominance of select operating systems,

638-481: A functioning Printer Spooler into Amiga, and featured 16 million colors printing. MorphOS uses a special version of TurboPrint to pilot recent printers. Many Amiga programs like DTP programs as PageStream featured in the past its own printer drivers. USB printers are automatically recognized by the Poseidon USB Stack. This stack is capable of detecting any USB device by its class, but printers still require

SECTION 10

#1732873401209

696-424: A large organization prepares payroll cheques, the computation takes only a few minutes or even seconds, but the printing process might take hours. If the payroll program printed cheques directly, it would be unable to proceed to other computations until all the cheques were printed. Similarly, before spooling was added to PC operating systems, word processors were unable to do anything else, including interact with

754-471: A personal failure." One of the largest changes to the Windows API was the transition from Win16 (shipped in Windows 3.1 and older) to Win32 (Windows NT and Windows 95 and up). While Win32 was originally introduced with Windows NT 3.1 and Win32s allowed use of a Win32 subset before Windows 95, it was not until Windows 95 that widespread porting of applications to Win32 began. To ease the transition, in Windows 95, for developers outside and inside Microsoft,

812-460: A small number of printers. They are also valuable when a single job can produce multiple documents. Depending on the configuration, banner pages might be generated on each client computer, on a centralized print server, or by the printer itself. On printers using fanfold continuous forms a leading banner page would often be printed twice, so that one copy would always be face-up when the jobs were separated. The page might include lines printed over

870-422: Is a combination of buffering and queueing . Nowadays, the most common use of spooling is printing: documents formatted for printing are stored in a queue at the speed of the computer, then retrieved and printed at the speed of the printer. Multiple processes can write documents to the spool without waiting, and can then perform other tasks, while the "spooler" process operates the printer. For example, when

928-563: Is debatable since they don't provide or expose all of the capabilities of Windows API. Although almost all Windows programs use the Windows API, on the Windows NT line of operating systems, programs that start early in the Windows startup process use the Native API instead. The Windows API has always exposed a large part of the underlying structure of the Windows systems to programmers. This had

986-420: Is grouped under the User Interface category of the API. Network Services provide access to the various networking abilities of the operating system. Its subcomponents include NetBIOS , Winsock , NetDDE , remote procedure call (RPC) and many more. This component resides in netapi32.dll on 32-bit Windows. The Internet Explorer (IE) web browser exposes APIs and as such could be considered part of

1044-492: Is provided by win32k.sys which communicates directly with the graphics driver. The User Interface component provides features to create and manage screen windows and most basic controls, such as buttons and scrollbars , receive mouse and keyboard input, and other functions associated with the graphical user interface (GUI) part of Windows. This functional unit resides in user.exe on 16-bit Windows, and user32.dll on 32-bit Windows. Since Windows XP versions,

1102-627: Is still found in the documentation for email and Usenet software. Peripheral devices have always been much slower than core processing units. This was an especially severe problem for early mainframes . For example, a job which read punched cards or generated printed output directly was forced to run at the speed of the slow mechanical devices. The first spooling programs, such as IBM's "SPOOL System" (7070-IO-076) copied data from punched cards to magnetic tape, and from tape back to punched cards and printers. Hard disks , which offered faster I/O speeds and support for random access , started to replace

1160-503: Is uncertain, however. Simultaneous peripheral operations on-line may be a backronym . Another explanation is that it refers to "spools" or reels of magnetic tape, although “spool” is an uncommon usage. Win32 The Windows API , informally WinAPI , is the foundational application programming interface (API) that allows a computer program to access the features of the Microsoft Windows operating system in which

1218-474: The Amiga could use the same standard set of control sequences and wouldn't need to know which printer is actually connected. The printer driver then translated these standard sequences into the special sequences a certain printer understands. Amiga internal function "PWrite" of printer.device writes 'length' bytes directly to the printer. This function is generally called on by printer drivers to send their buffer(s) to

SECTION 20

#1732873401209

1276-581: The Platform SDK. Flat assembler FASM allows building Windows programs without using an external linker, even when running on Linux. Windows specific compiler support is also needed for Structured Exception Handling (SEH). This system serves two purposes: it provides a substrate on which language-specific exception handling can be implemented, and it is how the kernel notifies applications of exceptional conditions such as dereferencing an invalid pointer or stack overflow. The Microsoft/Borland C++ compilers had

1334-557: The SCRIPT command can be loaded to run in the background in order to intercept and convert printer output from applications into PostScript to support PS-capable printers also by applications not supporting them directly. In order to support more complex printing for different models of printers, each application (e.g. a word processor ) may be shipped with its own printer drivers, which were essentially descriptions of printer escape sequences . Printers, too, have been supplied with drivers for

1392-518: The Win32-specific DLLs simple. LCC-Win32 is a C compiler maintained by Jacob Navia, freeware for non-commercial use. Pelles C is a freeware C compiler maintained by Pelle Orinius. Free Pascal is a free software Object Pascal compiler that supports the Windows API. The MASM32 package is a mature project providing support for the Windows API under Microsoft Macro Assembler (MASM) by using custom made or converted headers and libraries from

1450-642: The Windows API and the WinRT API, which is implemented in C++ and is object-oriented by design. Windows.pas is a Delphi unit that exposes the features of Windows API – the Pascal equivalent of windows.h . Many Microsoft technologies use the Windows API -- as most software running on Windows does. As middle-ware between Windows API and an application, the following technologies provide some access to Windows API. Some technologies are described as wrapping Windows API, but this

1508-748: The Windows API bindingly. To develop software that uses the Windows API, a compiler must be able to use the Microsoft-specific DLLs listed above (COM-objects are outside Win32 and assume a certain vtable layout). The compiler must either handle the header files that expose the interior API function names, or supply such files. For the language C++, Zortech (later Symantec , then Digital Mars ), Watcom and Borland have all produced well known commercial compilers that have been used often with Win16, Win32s, and Win32. Some of them supplied memory extenders , allowing Win32 programs to run on Win16 with Microsoft's redistributable Win32s DLL. The Zortech compiler

1566-444: The Windows API support thousands. However, in general, the interface remained fairly consistent, and an old Windows 1.0 application will still look familiar to a programmer who is used to the modern Windows API. Microsoft has made an effort to maintain backward compatibility . To achieve this, when developing new versions of Windows, Microsoft sometimes implemented workarounds to allow compatibility with third-party software that used

1624-545: The Windows API to allow executing simple Windows programs from a DOS command line. Odin is a project to emulate Win32 on OS/2 , superseding the original Win-OS/2 emulation which was based on Microsoft code. Other minor implementations include the MEWEL and Zinc libraries which were intended to implement a subset of the Win16 API on DOS (see List of platform-independent GUI libraries ). Windows Interface Source Environment (WISE)

1682-416: The Windows API. The name, Windows API, refers to essentially the same capability in each version of Windows, but there is another name for this capability that is based on major architectural aspects of the Windows version that contains it. When there was only one version, it was simply called Windows API. Then, when the first major update was made, Microsoft gave it the name Win32 and gave the first version

1740-479: The Windows API. IE has been included with the operating system since Windows 95 OSR2 and has provided web-related services to applications since Windows 98 . The Windows API is a C language -based API. Functions and data structures are consumable via C syntax by including windows.h , but the API can be consumed via any programming language that can inter-operate with the API data structures and calling conventions for function calls and callbacks . Of note,

1798-530: The Windows hello-world program." Petzold explains that while it was the first Windows sample programs developers were introduced to, it was quite "fancy" and more complex than needed. Tired of people ridiculing the length of the sample, he eventually reduced it to a simple MessageBox call. Over the years, various changes and additions were made to Windows systems, and the Windows API changed and grew to reflect this. The Windows API for Windows 1.0 supported fewer than 450 function calls , whereas modern versions of

Printer driver - Misplaced Pages Continue

1856-454: The ability to use this system as soon as it was introduced in Windows 95 and NT, however the actual implementation was undocumented and had to be reverse engineered for the Wine project and free compilers. SEH is based on pushing exception handler frames onto the stack, then adding them to a linked list stored in thread-local storage (the first field of the thread environment block). When an exception

1914-426: The advantage of giving them much flexibility and power over their applications, but also creates great responsibility in how applications handle various low-level, sometimes tedious, operations that are associated with a graphical user interface . For example, a beginning C programmer will often write the simple "hello world" as their first assignment. The working part of the program is only a single printf line within

1972-470: The application to run at the speed of the CPU while operating peripheral devices at their full rated speed. A batch processing system uses spooling to maintain a queue of ready-to-run tasks, which can be started as soon as the system has the resources to process them. Some store and forward messaging systems, such as uucp , used "spool" to refer to their inbound and outbound message queues, and this terminology

2030-512: The appropriate printer. Printer drivers are typically implemented as filters . They are usually named the front end of the printing system, while the printer spoolers constitute the back end . Backends are also used to determine the available devices. On startup, each backend is asked for a list of devices it supports, and any information that is available. DOS supports predefined character devices PRN: , LPT1: , LPT2: and LPT3: associated with parallel printers supported in

2088-578: The basic controls reside in comctl32.dll , together with the common controls (Common Control Library). The Common Dialog Box Library provides standard dialog boxes to open and save files, choose color and font, etc. The library resides in a file called commdlg.dll on 16-bit Windows, and comdlg32.dll on 32-bit Windows. It is grouped under the User Interface category of the API. The Common Control Library provides access to advanced user interface controls include things like status bars , progress bars , toolbars and tabs . The library resides in

2146-413: The fold, which would be visible along the edge of a stack of printed output, allowing the operator to easily separate the jobs. Some systems would also print a banner page at the end of each job, assuring users that they had collected all of their printout. Spooling is also used to mediate access to punched card readers and punches, magnetic tape drives, and other slow, sequential I/O devices. It allows

2204-603: The folder \Windows\System32 on all versions of Windows. Advanced services include features beyond the kernel like the Windows registry , shutdown/restart the system (or abort), start/stop/create a Windows service , manage user accounts. These functions reside in advapi32.dll and advapires32.dll on 32-bit Windows. The Graphics Device Interface (GDI) component provides features to output graphics content to monitors , printers , and other output devices . It resides in gdi.exe on 16-bit Windows, and gdi32.dll on 32-bit Windows in user-mode. Kernel-mode GDI support

2262-504: The implementation of API functions has been developed in several languages other than C. Despite the fact that C is not an object-oriented programming (OOP) language, the Windows API is somewhat object-oriented due to its use of handles. Various other technologies from Microsoft and others make this object-oriented aspect more apparent by using an OOP language such as C++ -- see Microsoft Foundation Class Library (MFC), Visual Component Library (VCL), GDI+ . Of note, Windows 8 provides

2320-499: The main subroutine. The overhead for linking to the standard I/O library is also only one line: Charles Petzold , who wrote several books about programming for the Windows API, said: "The original hello world program in the Windows 1.0 SDK was a bit of a scandal. HELLO.C was about 150 lines long, and the HELLO.RC resource script had another 20 or so more lines. (...) Veteran programmers often curled up in horror or laughter when encountering

2378-661: The most popular applications. In addition, it's possible for applications to include tools for editing printer description, in case there was no ready driver. In the days when DOS was widely used, many printers had emulation modes for Epson FX-80 and IBM Proprinter commands. Many more recent laser printers also have emulation modes for HP PCL (HP LaserJet) or PostScript printers which will work in DOS. It appears that these are also compatible with Windows 3.x. On Microsoft Windows systems, printer drivers make use of GDI ( Unidrv or PScript -based) or XPS (XPSDrv). Programs then use

Printer driver - Misplaced Pages Continue

2436-501: The name Win16. The term Windows API refers to both versions and all subsequently developed major versions. The Wine project provides a Win32 API compatibility layer for Unix-like platforms, between Linux kernel API and programs written for the Windows API. ReactOS goes a step further and aims to implement the full Windows operating system, working closely with the Wine project to promote code re-use and compatibility. DosWin32 and HX DOS Extender are other projects which emulate

2494-572: The only integrated development environments (IDEs) that could provide this (although, the SDK is downloadable for free separately from the entire IDE suite, from Microsoft Windows SDK for Windows 7 and .NET Framework 4 ). As of 2016 , the MinGW and Cygwin projects also provide such an environment based on the GNU Compiler Collection (GCC), using a stand-alone header file set, to make linking against

2552-430: The operating system–driver interface is more standardized than driver–printer interfaces. Hence there is more standardization in packaging formats of drivers than the actual functions performed by drivers. Print spooler In computing , spooling is a specialized form of multi-programming for the purpose of copying data between different devices. In contemporary systems, it is usually used for mediating between

2610-641: The printer driver; however, few applications actually use this option. The printer driver is usually located on the C:\Windows\System32\DriverStore\FileRepository folder on a Windows machine. The original AmigaOS up to 1.3 supported printers through a standard series of drivers stored at the required path "DEVS:Printers". All printer drivers were stored in that directory, and covered the standard printers in 1985-1989 circa, included Epson FX standard driver, Xerox 4020, HP, etcetera. Any Amiga printer driver had to communicate though

2668-773: The printer. Number of buffers are decided by the persons who created the driver. Amiga lacked a standard Printer Spooler. Since AmigaOS 2.0 a standard printer.device was changed to control various printers at same time. The Printer preferences were divided in three main panels: Prefs:Printer which selects main printer and other basic elements such as "Print Spacing" and "Paper Size". PrinterGFX controlled features like Dithering and Scaling. PrinterPS controlled Postscript Printers. The printer drivers surprisingly remained almost same of Workbench 1.3, with 4096 limits. This fact led Amiga users to prefer third party Printer Systems with their own drivers, like TurboPrint and PrintStudio , which introduced not only recent drivers, but also featured

2726-482: The printing pipeline, printer interfaces are largely still very proprietary and manufacturer-specific. Hence, nature of functions performed by drivers can vary. Nonetheless, based on the function performed, drivers can be classified as follows. These drivers can convert print data from one general purpose format (e.g. PDF, DVI etc) to another general purpose format (e.g. PS). Examples include Ghostscript, etc. These drivers convert print data from one format (e.g. PS) to

2784-473: The prior version in an undocumented or even inadvisable way. Raymond Chen , a Microsoft developer who works on the Windows API, has said: "I could probably write for months solely about bad things apps do and what we had to do to get them to work again (often in spite of themselves). Which is why I get particularly furious when people accuse Microsoft of maliciously breaking applications during OS upgrades. If any application failed to run on Windows 95, I took it as

2842-435: The program is running. Programs access API functionality via dynamic-link library (DLL) technology. Each major version of the Windows API has a distinct name that identifies a compatibility aspect of that version. For example, Win32 is the major version of Windows API that runs on 32-bit systems. The name, Windows API, collectively refers to all versions of this capability of Windows. Microsoft provides developer support via

2900-450: The same printer or group of printers. Print spoolers can be configured to add a banner page , also called a burst page , job sheet , or printer separator , to the beginning and end of each document and job. These separate documents from each other, identify each document (e.g. with its title ) and often also state who printed it (e.g. by username or job name). Banner pages are valuable in office environments where many people share

2958-416: The same standard APIs to draw text and pictures both on screen and on paper. Printers which use GDI natively are commonly referred to as Winprinters and are considered incompatible with other operating systems, although there is software (such as PrintFil) which will make these printers work in a DOS prompt within Windows. Win32 APIs also allow applications to send data directly to the spooler, bypassing

SECTION 50

#1732873401209

3016-422: The standard Amiga printer.device (the default standard hardware device of Amiga dealing with printers), and the standard parallel.device (which controlled parallel port) and the driver would then control the printer on its own. Amiga printer drivers were an innovation for their time. They spared users from individually configuring each of their applications. They had the ability to print up to 4096 colors. Through

3074-516: The system. Similarly, serial printers can be used with AUX: , COM1: , COM2: , COM3: and COM4: . Users can use commands like, for example, " COPY file1 LPT1: " to print the content of a file to a printer. The contents is transferred to the printer without any interpretation. Therefore, this method of printing is either for files already stored in the corresponding printer's language or for generic text files without more than simple line-oriented formatting. DOS also provides

3132-511: The use of magnetic tape for spooling in the middle 1960s, and by the 1970s had largely replaced it altogether. Because the unit record equipment on IBM mainframes of the early 1960s was slow, it was common for larger systems to use a small offline computer such as an IBM 1401 instead of spooling. The term "spool" may originate with the Simultaneous Peripheral Operations On-Line (SPOOL) software; this derivation

3190-516: The use of the Printer Preferences program printers could be connected to the serial port as well. Amiga also had support for a virtual device "PRT:" to refer to printer.device so, for example the command "COPY file TO PRT:" caused the file to be printed directly bypassing parallel.device and the default printer driver. Amiga used ANSI escape codes , not the special ones defined by the various printer manufacturers. This way every application on

3248-404: The user, while printing. Spooler or print management software often includes a variety of related features, such as allowing priorities to be assigned to print jobs, notifying users when their documents have been printed, distributing print jobs among several printers, selecting appropriate paper for each document, etc. A print server applies spooling techniques to allow many computers to share

3306-562: Was a licensing program from Microsoft which allowed developers to recompile and run Windows-based applications on Unix and Macintosh platforms. WISE SDKs were based on an emulator of the Windows API that could run on those platforms. Efforts toward standardization included Sun's Public Windows Interface (PWI) for Win16 (see also: Sun Windows Application Binary Interface ( Wabi )), Willows Software's Application Programming Interface for Windows (APIW) for Win16 and Win32 (see also: Willows TWIN ), and ECMA-234 , which attempted to standardize

3364-602: Was probably one of the first stable and usable C++ compilers for Windows programming, before Microsoft had a C++ compiler. For certain classes of applications, the compiler system should also be able to handle interface description language (IDL) files. Collectively, these prerequisites (compilers, tools, libraries, and headers) are known as the Microsoft Platform SDK . For a time, the Microsoft Visual Studio and Borland 's integrated development system were

#208791