1. Podręcznik użytkownika programu Wine .

1.0.1. Przedstawienie

1.0.1.1. Cel tego doumentu

Ten dokument jest idealny dla początkujących jak i doświadczonych użytkowników wine pokazujący instalacje , konfiguracje i normalne korzystanie ze programu oferuje wszystko co powinieneś wiedzieć .

1.0.1.2. Further questions and comments

f, after examining this guide, the FAQ, and other relevant documentation there is still something you cannot figure out, we would love to hear from you. Themailing listssection contains several mailing lists and an IRC channel, all of which are great places to seek help and offer suggestions. If you are particularly savvy, and believe that something can be explained better, you can file abug reportorpost a patchon Wine's documentation itself.

1.0.1.3. Content overview / Steps to take

In order to be able to use Wine, you must first have a working installation. This guide will help you to move your system from an empty, Wineless void to one boasting a fresh, up to date Wine install. The first step,Getting Wine, illustrates the various methods of getting Wine's files onto your computer. The second step,Configuring Wine, shows how to customize a Wine installation depending on your individual needs. The final step,Running Wine, covers the specific steps you can take to get a particular application to run better under Wine, and provides useful links in case you need further help.

1.0.1.4. Szybki start

.

• The process of installing and running wine can be summarised as follows:

• Get a distribution as indicated in Getting Wine and see the Wine Downloads page. For the casual or new user the simplest is to get an rpm distribution.

• Configure wine using the winecfg command. For most people wine should now be usable.

• To test your installation run wine's Windows 3.1 like file manager using the wine winefile command.

• Run wine using the wine filespec/appname.exe command.

  • The first command you will run will be to install a package. Typically something like wine                  /media/cdrom/setup.exe or the equivalent.

1.0.2. Czym jest Wine ?

1.0.2.1. Windows i Linux

• Different software programs are designed for different operating systems, and most won't work on systems that they weren't designed for. Windows programs, for example, won't run in Linux because they contain instructions that the system can't understand until they're translated by the Windows environment. Linux programs, likewise, won't run under the Windows operating system because Windows is unable to interpret all of their instructions. This situation presents a fundamental problem for anyone who wants to run software for both Windows and Linux. A common solution to this problem is to install both operating systems on the same computer, known as "dual booting." When a Windows program is needed, the user boots the machine into Windows to run it; when a Linux program is then needed, the user then reboots the machine into Linux. This option presents great difficulty: not only must the user endure the frustration of frequent rebooting, but programs for both platforms can't be run simultaneously. Having Windows on a system also creates an added burden: the software is expensive, requires a separate disk partition, and is unable to read most filesystem formats, making the sharing of data between operating systems difficult.

1.0.2.2. Czym jest Wine, i jak może mi pomóc?

Wine jest Open Source implementacją API Windowsa of X, OpenGL, and Unix. Myśląc o wine jaką kompatybilności uruchamianych programów˝w windowsowych . Wine nie potrzebuje Microsoft Windows jest kompletna darmowa alternatywa implementacji API Windows zawierający 100% nie-Microsoft kodu ale może używać opcjonalnie natywne biblioteki dll Windowsa jeśli są dostępne . Wine przetwarza informacje Windowsa na Linux np. jeśli program prosi o stworzenie Windows pushbutton albo text-edit wien przetworzy toa na komendy na menadżer okien używający standardowego protokołu X11.Jeśli mamy dostęp do kodu programu windowsowego możemy go skompilować do formatu jakiego Linux rozum i ale nadal będzie potrzebny wine ale jest wiele możliwości i udogodnień kompilacji programu do natywnego Linux wersji więcej informacji o tym znajduje się we podręczniku winelib

1.0.2.3. Funkcje wine

• Throughout the course of its development, Wine has continually grown in the features it carries and the programs it can run. A partial list of these features follows:
• Support for running Win32 (Win 95/98, NT/2000/XP), Win16 (Win 3.1) and DOS programs
• Optional use of external vendor DLL files (such as those included with Windows)
• X11-based graphics display, allowing remote display to any X terminal, as well as a text mode console
• Desktop-in-a-box or mixable windows
• DirectX support for games
• Good support for various sound drivers including OSS and ALSA
• Support for alternative input devices

• Printing: PostScript interface driver (psdrv) to standard Unix PostScript print services

• Modem, serial device support
• Winsock TCP/IP networking support
• ASPI interface (SCSI) support for scanners, CD writers, and other devices
• Advanced unicode and foreign language support
• Full-featured Wine debugger and configurable trace logging messages for easier troubleshooting

1.0.3. Wersje wine

1.0.3.1. Wine ze Wine HQ

• Wine is an open source project, and there are accordingly many different versions of Wine for you to choose from. The standard version of Wine comes in intermittent releases (roughly twice a month), and can be downloaded over the internet in both prepackaged binary form and ready to compile source code form. Alternatively, you can install a development version of Wine by using the latest available source code from the Git repository. See the next chapter, Getting Wine, for further details.

---

1.0.3.2. Inne wersje Wine

• There are a number of programs that are derived from the standard Wine codebase in some way or another. Some of these are commercial products from companies that actively contribute to the Wine project. These products try to stand out or distinguish themselves from the standard version of Wine by offering greater compatibility, easier configuration, and commercial support. If you require such things, it is a good idea to consider purchasing these products.

Table 1-1. Various Wine offerings

||CodeWeavers CrossOver Office Server Edition||CrossOver Office Server Edition allows you to run your favorite Windows productivity applications in a distributed thin-client environment under Linux, without needing Microsoft Operating System licenses for each client machine. CrossOver Office Server Edition allows you to satisfy the needs of literally hundreds of concurrent users, all from a single server.

1.0.4. Co oprócz wien można użyc

Jest wiele sposobów żeby uruchomić programy poza wine jeżeli zastanawiasz się lub znalazłeś trudności we korzystaniu ze wine możesz pomyśleć o alternatywie

1.0.4.1. Natywne Aplikacje

Zamiast uruchamiania paru programów windowsowych możesz skorzystać ze bardzo dobrych open sorce alternatyw a nawet wersji linuksowych programów które zostały przesortować na Linux np. Adobe Reader .Mozila firefox itd.

1.0.4.2. Inny system operacyjny

• Najlepszym rozwiazaniem jest uruchomienie programó we windows ale przez bezpieczenstwa i licencje wine jest najlepszym rozwizaniem Inną alternatywa jest jest uzycie ReactOS, dlatego że jest open source alternatywa dla Windows. ReactOS dzeli się kodem ze projektem Wine project, ale zamiast uruchamiania programów we linux uruchamia się go we reactos który umozliwia instalacje sterowików windowsa zamiast korzystania ze linuxowych sterowników

1.0.4.3. Maszyna wirtualna

• Dróga metoda zamiast instalowania systemó windows lub reactos j jest skorzystanie ze maszyny wirtualnej na której zainstalujemy cały system windows lub reactos jest parę róznych maszyn wirtualnych o open sorce np.virtualbox Bochs , QEMU , KomercyjneVMware and Microsoft's VirtualPC. Ale spwodu ze ta są emulatory jest róznica szybkosci niż uzycie wine ale mówiąc o kompletnym srodowisku systemu windows maszyna wirtualna jest najlepszym rozwiazaniem bo mamy pełne bibloteki systemowe jakie program potrzebuje jest jedna niezbyd dobra zecz ze 2d działa we wirtalnej maszynie a 3d jedynie we komercyjnym programie Vmware ale tez niedokonca bo niewszystka działa Tak jakby się chciała .

• . .

1.0.5. Getting Wine

1.0.5.1. Metody instalacji Wine

Jak zdecydowałeś ze użyjesz wine bo najlepiej tobie odpowiada trzeba pomyslec jak chcesz zainstalowac wine są trzy metody instalacji Wine ze WineHQ, Kazdy znich ma swój łatwą lub trudniejsza droge instalacji

1.0.5.2. Installacja ze paczek rpm .deb

• By far the easiest method for installing Wine is to use a prepackaged version of Wine. These packages contain ready-to-run Wine binary files specifically compiled for your distribution, and they are tested regularly by the packagers for both functionality and completeness.

  Packages are the recommended method for installing Wine. We make them easily available at the WineHQ downloads page , and these are always the latest packages available. Being popular, Wine packages can also be found elsewhere in official distribution repositories. These can, however, sometimes be out of date, depending on the distribution. Packages are easily upgradable as well, and many distributions can upgrade Wine seamlessly with a few clicks. Building your own installable binary package from a source package is also possible, although it is beyond the scope of this guide.

1.0.5.3. Installacja ze zródeł

• Sometimes the Wine packages don't fit your needs exactly. Perhaps they're not available for your architecture or distribution, or perhaps you want to build wine using your own compiler optimizations or with some options disabled, or perhaps you need to modify a specific part of the source code before compilation. Being an open source project, you are free to do all of these things with Wine's source code, which is provided with every Wine release. This method of installation can be done by downloading a Wine source archive and compiling from the command line. If you are comfortable with such things and have special needs, this option may be for you.

  Getting Wine source archives is simple. Every release, we put a source package in compressed tar.bz2 format at the WineHQ downloads page. Compiling and installing Wine from source is slightly more difficult than using a package, however we will cover it in depth and attempt to hold your hand along the way.

1.0.5.4. Installacja dzewa Git

• If you wish to try out the bleeding edge of Wine development, or would even like to help develop Wine yourself, you can download the very latest source code from our Git repository. Instructions for downloading from the Wine Git repository are available at http://www.winehq.org/site/git . Please take note that the usual warnings for using a developmental version still apply. The source code on the Git repository is largely untested and may not even compile properly. It is, however, the best way to test out how Wine will work in the next version, and if you're modifying source code it's best to get the latest copy. The Git repository is also useful for application maintainers interested in testing if an application will still work right for the next release, or if a recent patch actually improves things. If you're interested in helping us to get an application working in Wine, see the HowTo.

1.0.6. Installacja ze paczek rpm lub deb

• Installing a package on a fresh system is remarkably straightforward. Simply download and install the package using whatever utility your distribution provides. There is usually no need to explicitly remove old packages before installing, as modern Linux distributions should upgrade and replace them automatically. If you installed Wine from source code, however, you should remove it before installing a Wine package. See the section on uninstalling Wine from source for proper instructions.

---

1.0.6.1. Installacja świeżej paczki rpm,deb

1.0.6.2. Inne dystrybucje

• Wine works on a huge amount of different Linux distributions, as well other Unix-like systems such as Solaris and FreeBSD, each with their own specific way of installing and managing packages. Fortunately, however, the same general ideas apply to all of them, and installing Wine should be no more difficult than installing any other software, no matter what distribution you use. Uninstalling Wine packages is simple as well, and in modern Linux distributions is usually done through the same easy interface as package installation.

  We won't cover the specifics of installing or uninstalling Wine packages among the various systems' methods of packaging and package management in this guide, however, up to date installation notes for particular distributions can be found at the WineHQ website in the HowTo. If you need further help figuring out how to simply install a Wine package, we suggest consulting your distribution's documentation, support forums, or IRC channels.

1.0.7. Installacja wine ze zródeł

• Before installing Wine from source, make sure you uninstall any Wine binary packages you may have on your system. Installing from source requires use of the terminal window as well as a full copy of the Wine source code. Once having downloaded the source from Git or extracted it from an archive, navigate to it using the terminal and then follow the remaining steps.

---

1.0.7.1. Zdobywanie zależnosci instacyjnych wine

• Wine makes use of many open source libraries during its operation. While Wine is not strictly dependent on these libraries and will compile without most of them, much of Wine's functionality is improved by having them available at compile time. In the past, many user problems were caused by people not having the necessary development libraries when they built Wine from source; because of this reason and others, we highly recommend installing via binary packages or by building source packages which can automatically satisfy their build dependencies. If you wish to install build dependencies by hand, there are several ways to see if you're missing some useful development libraries. The most straightforward approach is to watch the configure program's output before you compile Wine and see if anything important is missing; if it is, simply install what's missing and rerun configure before compiling. You can also check the file configure generates, (include/config.h) and see if what files configure is looking for but not finding.

1.0.7.2. Kompilacja Wine?

• Once you've installed the build dependencies you need, you're ready to compile the package. In the terminal window, after having navigated to the Wine source tree, run the following commands:
• $ ./configure
• $make depend
• $make
• #make install

The last command requires root privileges. Although you should never run Wine as root, you will need to install it this way

1.0.7.3. Odinstalowywanie Wine ze żródeł

• . Aby odinstalować Wine ze źródeł trzeba wejść do tego samego katalugu gdzie śa żródła wine ze których instalowywalismy używając konsoli{terminal} logujemy się do konta root przez wpisanie komendy su i wpisujac hasło roota a potem wpisujemy tą komendę
• # make uninstall ta komenda usunie winę ze systemu ze wyjątkiem danych zawartych we katalogu uzytkownika ta musimy zrobić ręcznie

This command will require root privileges, and should remove all of the Wine binary files from your system. It will not, however, remove your Wine configuration and applications located in your user's home directory, so you are free to install another version of Wine or delete that configuration by hand.

1.0.8. KonfiguracjaWine

In the past, Wine used a special configuration file that could be found in ~/.wine/config. If you are still using a version of Wine that references this file (older than June, 2005) you should upgrade before doing anything else. All settings are now stored directly in the registry and accessed by Wine when it starts. Winecfg should have been installed on your computer along with the rest of the Wine programs. If you can't figure out how to start it, try running the command: $ /usr/local/bin/winecfg or possibly just: $ winecfg When the program starts you'll notice there are tabs along the top of the window for: * Applications * Libraries * Graphics * Desktop Integration * Drives * Audio * About Changing settings in the Applications and Libraries tab will have the most impact on getting an application to run. The other settings focus on getting Wine itself to behave the way you want it to. Note: The Applications, Libraries, and Graphics tabs are linked together! If you have Default Settings selected under Applications, all of the changes made within the Libraries and Graphics tabs will be changed for all applications. If you've configured a specfic application under the Applications tab and have it selected, then any changes made in Libraries or Graphics will affect only that application. This allows for custom settings for specific applications.

1.0.8.1. Używanie Winecfg

1.0.8.2. Ustawienia aplikacji

Wine umożliwia emulowanie zachowania różnych wersji Windows np win 98 największą różnice miedzy nimi ta nazwy i polecenia jakie wymaga dany program Standardowymi ustawieniami od wine 9.61 jest winxp ale np program który chcemy zainstalować jest za czasów Windowsa 3.1 więc trzeba zmienić na win31 a żeby to zrobić mamy dwie możliwości zmienić dla całego systemu na win3.1 ale jest lepszy sposób 1Kliknij na dodaj aplikacje 2otworzy się okienka ze nazwą wybierz plik wykonywalny i podajemy gdzie nasz plik się znajduje 3jak dodaliśmy nasz program możemy teraz wybrać wersje systemu do emulowania na win31 i wciskamy zastosuj i ok dla każdego pliku exe możemy emulować inny system dzięki o dzielnemu dodaniu wersji dla programu można dzięki temu ustawić inne ustawienia bibliotek które będą połączone jedynie ze wybrana aplikacją anie ze całym wine a także dzięki temu od nowszych wersji wine można uruchamiać programy we oknie wirtualnym wybrany program nie ustawiając wirtualnego pulpitu dla całego wine

1.0.8.3. Ustawienia bibliotek

Likewise, some applications require specific libraries in order to run. Wine reproduces the Windows system libraries (so-called native DLL's) with completely custom versions designed to function exactly the same way but without requiring licenses from Microsoft. Wine has many known deficiencies in it's built-in versions, but in many instances the functionality is sufficient. Using only builtin DLL's ensures that your system is Microsoft-free. However, Wine has the ability to load native Windows DLL's. DLL Overrides

• It's not always possible to run an application on builtin DLL's. Sometimes native DLL's simply work better. After you've located a native DLL on a Windows system, you'll need to put it in suitable place for Wine to find it and then configure it to be used. Generally the place you need to put it is in the directory you've configured to be c:\windows\system32 (more on that in the drives section). There are four DLL's you should never try to use the native versions of: kernel32.dll, gdi32.dll, user32.dll, and ntdll.dll. These libraries require low-level Windows kernel access that simply doesn't exist within Wine. With that in mind, once you've copied the DLL you just need to tell Wine to try to use it. You can configure Wine to choose between native and builtin DLL's at two different levels. If you have Default Settings selected in the Applications tab, the changes you make will affect all applications. Or, you can override the global settings on a per-application level by adding and selecting an application in the Applications tab.

• To add an override for FOO.DLL, enter "FOO" into the box labeled New override for library: and click on the Add button. To change how the DLL behaves, select it within the Existing overrides: box and choose Edit. By default the new load order will be native Windows libraries before Wine's own builtin ones (Native then Builtin). You can also choose native only, builtin only, or disable it altogether.

Notak o biblotekach The Wine team has determined that it is necessary to create fake DLL files to trick many programs that check for file existence to determine whether a particular feature (such as Winsock and its TCP/IP networking) is available. If this is a problem for you, you can create empty files in the configured c:\windows\system32 directory to make the program think it's there, and Wine's built-in DLL will be loaded when the program actually asks for it. (Unfortunately, tools/wineinstall does not create such empty files itself.)

• Applications sometimes also try to inspect the version resources from the physical files (for example, to determine the DirectX version). Empty files will not do in this case, it is rather necessary to install files with complete version resources. This problem is already fixed for many files. For others, you may still need to grab some real DLL files to fool these apps with. There are of course DLLs that Wine does not currently implement very well (or at all). If you do not have a real Windows you can copy necessary DLLs from, you can always get some from one of the Windows DLL archive sites that can be found via internet search engine. Please make sure to obey any licenses on the DLLs you fetch; some are redistributable, some aren't.

Brakujace bibloteki

• In case Wine complains about a missing DLL, you should check whether this file is a publicly available DLL or a custom DLL belonging to your program (by searching for its name on the internet). After you've located the DLL, you need to make sure Wine is able to use it. DLLs usually get loaded in the following order:
• The directory the program was started from.
• The current directory.
• The Windows system directory.
• The Windows directory.
• The PATH variable directories.

In short: either put the required DLL into your program directory (might be ugly), or put it into the Windows system directory. Also, if possible you probably shouldn't use NT-based native DLLs, since Wine's NT API support is somewhat weaker than its Win9x API support (possibly leading to even worse compatibility with NT DLLs than with a no-windows setup!).

1.0.8.4. Ustawienia grafiki

• Ta zakładka służy do konfiguracji zachowań uruchamiania programów wine

Napis 1{Zezwalaj aplikacjom Directx na zablokowanie opuszczania okna przez kursor} służy jak napis mówi zapobiega wyjścia kursora poza okienko gry lub programu ta funkcja warto ustawić jak wiemy że dana gra lub program działa dobrze i nam będzie lepiej sterować np. gry którymi przesuwamy kursor we Iną część planszy Napis2 {Pozwól menadżerowi okien dekorować okna} ustawia wygląd okienek programów np. jak jest wcisnienty to mamy okienko ze guzikami zamknij znane ze KDE GNOME itd. a jak nieustawiony to mamy okienko znane ze Windowsa Napis 3{Pozwól menadżerowi okien zarządzać oknami wine] umożliwia zakrywanie okien wine prze inne programy np. Mozilla Firefox jak nie jest włączony to każde okno nie ze wine jest pod wine anie na wiesz ku Napis 4 {Emuluj wirtualny pulpit} Każdy program i gra jest uruchamiana we okienku wirtualnym jest to ważna funkcja jak by program nie chciał włóczyć we zwykłym pulpicie Linux lub blokował się jak mamy włączone te okienko łatwiej nam będzie wyłączyć ten program możemy sami wybrać jaką rozdzielczość ma mieć wirtualne okienko standardowa jest to 800x600 ostatnie ustawienia to direct 3d gdzie wybieramy czy ma być obsługa vertex shader sprzętowa czy jej brak ta funkcja jest przydatna we niektórych grach ostatnia to ustawienia dpi czyli wielkości czcionek we programach czasami jest przydatna .

• .

1.0.8.5. Ustawienia dysków

Windows ma dyski rożnego typu ustawione literami np. A: to naped dyskietek c: to dysk twardy d: napęd dvd/cd itd. Wine używa tej samej koncepcji mapując dla każdego systemu pików i napędu literę np. litera z: to cały dysk linuksowy d:to katalog użytkownika a; napęd dyskietek a :c to dysk twardy itd. konfiguracja dysków jest bardzo prosta we zakładce Dyski we Winecfg {Konfigurator} możemy wykryć automatycznie jaki mamy dyski poprzez wciśniecie .Automatyczne wykrywanie lub przez ręczne dodanie oczywiście możemy usuwać dyski i zmieniać zeby dodac naciskamy dodaj i podajemy sciezke do tego dysku a żeby usunąć wybieramy usuń

• wszystkie urządzenia są widoczne we katalog użytkownika/.wine/dosdevices/

1.0.8.6. Ustawienia dzwieku

ta zakładka służy żeby dźwięk był słyszalny we grach i innych programach np winamp i wiedźmin na liście gdzie pisze sterowniki dźwiękowe możemy wybrać sterownik dla całego wine można wybrać miedzy innymi ALSA , OSS ,JACK i Esound do gier służy directsound we którym możemy wybrać czy ma być pełne przyspieszeni dźwiękowe czy standardowe czy emulowane czy podstawowe po directsound możemy wybrać częstotliwość lub bity na próbę we tych konfiguracji możemy ustawić czy próbka ma miec 16 lu 8 czy częstotliwość ma mięć 44100 lub 800 czy ma mięć 48000 ostatnia opcja to emulacja sterownika która możemy włączyć jakby były problemy ze dźwiękiem jest tez możliwość testu dźwięku przez naciśnięcie test dźwięk po naciśnięciu powinniśmy usłyszeć dźwięk jak nie to znaczy ze coś jest źle skonfigurowane lub karta dźwiękowa źle wykrywana jest przez wine . Standardowa nic nie trzeba zmieniać

1.0.8.7. Integracja pulpitu

Wine can load Windows themes if you have them available. While this certainly isn't necessary in order to use Wine or applications, it does allow you to customize the look and feel of a program. Wine supports the newer MSStyles typ of themese. Unlike the older Microsoft Plus! style themes, the uxtheme engine supports special .msstyles files that can retheme all of the Windows controls. This is more or less the same kind of theming that modern Linux desktops have supported for years. If you'd like to try this out: 1. Download a Windows XP theme. Be sure it contains a .msstyles file. 2. Create a set of new directories in your fake Windows drive: $ mkdir -p ~/.wine/drive_c/windows/Resources/themes/name-of-your-theme 3. Move the .msstyles to that new name-of-your-theme directory. 4. Use the Desktop Integration tab of winecfg to select the new theme.

1.0.9. Using the Registry and Regedit

All of the settings you change in Winecfg, with exception of the drive settings, are ultimately stored in the registry. In Windows, this is a central repository for the configuration of applications and the operating system. Likewise, Wine implements a registry and some settings not found in Winecfg can be changed within it. (There's actually more of a chance you'll need to dip into the registry to change an applications' settings than Wine itself.) Now, the fact that Wine itself uses the registry to store settings has been controversial. Some people argue that it's too much like Windows. To counter this, there's several things to consider. First, it's impossible to avoid implementing a registry simply because applications expect to be able to store their settings there. In order for Wine to store and access settings in a separate configuration file would require a separate set of code to basically do the same thing as the Win32 API's Wine already implements. Finally, unlike Windows, the Wine registry is written in plain text and can be changed using your favorite text editor. While most sane system administrators (and Wine developers) curse madly at the twisted nature of the Windows registry, it is still necessary for Wine to support it somehow.

1.0.9.1. Structura rejestru

Okay.. with that out of the way, let's dig into the registry a bit to see how it's laid out. The Windows registry is an elaborate tree structure, and not even most Windows programmers are fully aware of how the registry is laid out, with its different "hives" and numerous links between them; a full coverage is out of the scope of this document. But here are the basic registry keys you might need to know about for now: HKEY_LOCAL_MACHINE This fundamental root key (in win9x it's stored in the hidden file system.dat) contains everything pertaining to the current Windows installation. This is often abbreviated HKLM. HKEY_USERS This fundamental root key (in win9x it's stored in the hidden file user.dat) contains configuration data for every user of the installation. HKEY_CLASSES_ROOT This is a link to HKEY_LOCAL_MACHINE\Software\Classes. It contains data describing things like file associations, OLE document handlers, and COM classes. HKEY_CURRENT_USER This is a link to HKEY_USERS\your_username, i.e., your personal configuration.

1.0.9.2. Pliki rejestru

Now, what you're probably wondering is how that translates into Wine's structure. The registry layout described above actually lives in three different files within each user's ~/.wine directory: system.reg This file contains HKEY_LOCAL_MACHINE. user.reg This file contains HKEY_CURRENT_USER. userdef.reg This file contains HKEY_USERS\.Default (i.e. the default user settings). These files are automatically created the first time you use Wine. A set of global settings is stored in the wine.inf file and is processed by the rundll32.exe program. The first time you run Wine the wine.inf file gets processed to populate the initial registry. The registry is also updated automatically if wine.inf changes, for instance when upgrading to a newer Wine version. Note: Older Wine versions (before 1.0) required you to run the wineprefixcreate command manually to upgrade your settings. This is no longer necessary. Like we mentioned, you can edit those .reg files using whatever text editor you want. Just make sure Wine isn't running when you do it, otherwise all of the changes will be lost.

1.0.9.3. Używanie Regedit

• An easier way to access and change the registry is with the tool regedit. Similar to the Windows program it replaces, regedit serves to provide a system level view of the registry containing all of the keys. Simply run regedit and it should pop up. You'll immediately notice that the cryptic keys displayed in the text file are organized in a hierarchical fashion. To navigate through the registry, click on the keys on the left to drill down deeper. To delete a key, click on it and choose "Delete" from the Edit menu. To add a key or value, locate where you want to put it and choose "New" from the Edit menu. Likewise, you modify an existing key by highlighting it in the right-hand window pane and choosing "Modify" from the Edit menu. Another way to perform these same actions is to right-click on the key or value. Of particular interest to Wine users are the settings stored in HKEY_CURRENT_USER\Software\Wine. Most of the settings you change within winecfg are written to this area of the registry.

1.0.9.4. System Administration Tips

With the above file structure, it is possible for a system administrator to configure the system so that a system Wine installation (and applications) can be shared by all the users, and still let the users all have their own personalized configuration. An administrator can, after having installed Wine and any Windows application software he wants the users to have access to, copy the resulting system.reg and over to the global registry files (which we assume will reside in /usr/local/etc here), with: cd ~root/.wine cp system.reg /usr/local/etc/wine.systemreg and perhaps even symlink these back to the administrator's account, to make it easier to install apps system-wide later: ln -sf /usr/local/etc/wine.systemreg system.reg You might be tempted to do the same for user.reg as well, however that file contains user specific settings. Every user should have their own copy of that file along with the permissions to modify it. You'll want to pay attention to drive mappings. If you're sharing the system.reg file you'll want to make sure the registry settings are compatible with the drive mappings in ~/.wine/dosdevices of each individual user. As a general rule of thumb, the closer you keep your drive mappings to the default configuration, the easier this will be to manage. You may or may not be able to share some or all of the actual "c:" drive you originally installed the application to. Some applications require the ability to write specific settings to the drive, especially those designed for Windows 95/98/ME. Note that the tools/wineinstall script used to do some of this if you installed Wine source as root, however it no longer does. A final word of caution: be careful with what you do with the administrator account - if you do copy or link the administrator's registry to the global registry, any user might be able to read the administrator's preferences, which might not be good if sensitive information (passwords, personal information, etc) is stored there. Only use the administrator account to install software, not for daily work; use an ordinary user account for that.

1.0.9.5. Completna lista kluczy rejestru

You'll find an up-to-date list of useful registry keys and values in the developer's wiki.

1.0.10. Inne zeczy do konfiguracji

This section is meant to cover the rest of the things you can configure. It also serves as a collection of tips and tricks to get the most out of using Wine.

1.0.10.1. Serial and Parallel Ports

Serial and parallel port configuration is very similar to drive configuration - simply create a symbolic link in ~/.wine/dosdevices with the name of the device. Windows serial ports follow a naming convention of the word "com" followed by a number, such as com1, com2, etc. Similarly, parallel ports use "lpt" followed by a number, such as lpt1. You should link these directly to the corresponding Unix devices, such as /dev/ttyS0 and /dev/lp0. For example, to configure one serial port and one parallel port, run the following commands: ln -s /dev/ttyS0 com1 ln -s /dev/lp0 lpt1

1.0.10.2. Network Shares

Windows shares can are mapped into the unc/ directory so anything trying to access \\myserver\some\file will look in ~/.wine/dosdevices/unc/myserver/some/file/. For example, if you used Samba to mount \\myserver\some on /mnt/smb/myserver/some then you can do ln -s /mnt/smb/myserver/some unc/myserver/some to make it available in wine (don't forget to create the unc directory if it doesn't alrady exist)

1.0.10.3. Czcinki

Konfiguracji czcionek jest bardzo łatwa jak mamy jakieś czcionki , TrueType ze rozszezeniem .ttf to musimy je tylko skopiowac do katalog uźytkonika/.wine c:\windows\fonts.

1.0.10.4. Drukarki

vWine can interact directly with the local CUPS printing system to find the printers available on your system. Configuring printers with Wine is as simple as making sure your CUPS configuration works. Wine still needs the command lpr(from CUPS), when printing a Document. If you do not use CUPS, the old BSD-Printing system is used: * All Printers from /etc/printcap are installed automatically in Wine. * Wine needs a PPD-File for every Printer (generic.ppd comes with Wine) * The command lpr is called when printing a Document

1.0.10.5. Skanery

In Windows, scanners use the TWAIN API to access the underlying hardware. Wine's builtin TWAIN DLL simply forwards those requests to the Linux SANE libraries. So, to utilize your scanner under Wine you'll first need to make sure you can access it using SANE. After that you'll need to make sure you have xscanimage available for use. Currently xscanimage is shipped with the sane-frontends package but it may not be installed with your distribution. Scanner access is currently known to have problems. If you find it works for you, please consider updating this section of the user guide to provide details on using SANE with Wine.

1.0.10.6. ODBC Databases

The ODBC system within Wine, as with the printing system, is designed to hook across to the Unix system at a high level. Rather than ensuring that all the windows code works under wine it uses a suitable Unix ODBC provider, such as UnixODBC. Thus if you configure Wine to use the built-in odbc32.dll, that Wine DLL will interface to your Unix ODBC package and let that do the work, whereas if you configure Wine to use the native odbc32.dll it will try to use the native ODBC32 drivers etc.

• Configuring ODBC on Unix

The first step in using a Unix ODBC system with Wine is, of course, to get the Unix ODBC system working itself. This may involve downloading code or RPMs etc. There are several Unix ODBC systems available; the one the author is used to is unixODBC (with the IBM DB2 driver). There is also and ODBC-ODBC bridge that can be used to access a Microsoft Access database. Typically such systems will include a tool, such as isql, which will allow you to access the data from the command line so that you can check that the system is working. The next step is to hook the Unix ODBC library to the wine built-in odbc32 DLL. The built-in odbc32 (currently) looks to the environment variable LIB_ODBC_DRIVER_MANAGER for the name of the ODBC library. For example in the author's .bashrc file is the line: export LIB_ODBC_DRIVER_MANAGER=/usr/lib/libodbc.so.1.0.0 If that environment variable is not set then it looks for a library called libodbc.so and so you can add a symbolic link to equate that to your own library. For example as root you could run the commands: $ ln -s libodbc.so.1.0.0 /usr/lib/libodbc.so $ /sbin/ldconfig The last step in configuring this is to ensure that Wine is set up to run the built-in version of odbc32.dll, by modifying the DLL configuration. This built-in DLL merely acts as a stub between the calling code and the Unix ODBC library. If you have any problems then you can use WINEDEBUG=+odbc32 command before running wine to trace what is happening. One word of warning. Some programs actually cheat a little and bypass the ODBC library. For example the Crystal Reports engine goes to the registry to check on the DSN. The fix for this is documented at unixODBC's site where there is a section on using unixODBC with Wine.

Using Windows ODBC drivers Native ODBC drivers have been reported to work for many types of databases including MSSQL and Oracle. In fact, some like MSSQL can only be accessed on Linux through a Winelib app. Rather than just copying DLL files, most ODBC drivers require a Windows-based installer to run to properly configure things such as registry keys. In order to set up MSSQL support you will first need to download and run the mdac_typ.exe installer from microsoft.com. In order to configure your ODBC connections you must then run CLICONFG.EXE and ODBCAD32.EXE under Wine. You can find them in the windows\system directory after mdac_typ runs. Compare the output of these programs with the output on a native Windows machine. Some things, such as protocols, may be missing because they rely on being installed along with the operating system. If so, you may be able to copy missing functionality from an existing Windows installation as well as any registry values required. A native Windows installation configured to be used by Wine should work the same way it did when run natively. Types successfully tested under wine:

DB Type Usefulness MS SQL 100%

Please report any other successes to the wine-devel mailing list.

1.0.11. Uruchamianie Wine

This chapter will describe all aspects of running Wine, like e.g. basic Wine invocation, command line parameters of various Wine support programs etc.

1.0.11.1. Basic usage: applications and control panel applets

Assuming you are using a fake Windows installation, you install applications into Wine in the same way you would in Windows: by running the installer. You can just accept the defaults for where to install, most installers will default to "C:\Program Files", which is fine. If the application installer requests it, you may find that Wine creates icons on your desktop and in your app menu. If that happens, you can start the app by clicking on them. The standard way to uninstall things is for the application to provide an uninstaller, usually registered with the "Add/Remove Programs" control panel applet. To access the Wine equivalent, run the uninstaller program (it is located in the programs/uninstaller/ directory in a Wine source directory) in a terminal: $ uninstaller Some programs install associated control panel applets, examples of this would be Internet Explorer and QuickTime. You can access the Wine control panel by running in a terminal: $ wine control which will open a window with the installed control panel applets in it, as in Windows. If the application doesn't install menu or desktop items, you'll need to run the app from the command line. Remembering where you installed to, something like: $ wine "c:\program files\appname\appname.exe" will probably do the trick. The path isn't case sensitive, but remember to include the double quotes. Some programs don't always use obvious naming for their directories and EXE files, so you might have to look inside the program files directory to see what was put where.

1.0.11.2. Jak uruchomic Wine

You can simply invoke the wine command to get a small help message: Usage: wine PROGRAM [ARGUMENTS...] Run the specified program wine --help Display this help and exit wine --version Output version information and exit The first argument should be the name of the file you want wine to execute. If the executable is in the Path environment variable, you can simply give the executable file name. However, if the executable is not in Path, you must give the full path to the executable (in Windows format, not UNIX format!). For example, given a Path of the following: Path="c:\windows;c:\windows\system;e:\;e:\test;f:\" You could run the file c:\windows\system\foo.exe with: $ wine foo.exe However, you would have to run the file c:\myapps\foo.exe with this command: $ wine c:\\myapps\\foo.exe (note the backslash-escaped "\" !) For details on running text mode (CUI) executables, read thesectionbelow.

1.0.11.3. Explorer-like graphical Wine environmentsWine

If you prefer using a graphical interface to manage your files you might want to consider using Winefile. This Winelib application comes with Wine and can be found with the other Wine programs. It is a useful way to view your drive configuration and locate files, plus you can execute programs directly from Winefile. Please note, many functions are not yet implemented.

1.0.12. Wine Command Line Options

1.0.12.1. --help

Shows a small command line help page.

1.0.12.2. --version

Shows the Wine version string. Useful to verify your installation.

1.0.13. Environment variables

1.0.13.1. WINEDEBUG=[channels]

Wine isn't perfect, and many Windows applications still don't run without bugs under Wine (but then, a lot of programs don't run without bugs under native Windows either!). To make it easier for people to track down the causes behind each bug, Wine provides a number of debug channels that you can tap into. Each debug channel, when activated, will trigger logging messages to be displayed to the console where you invoked wine. From there you can redirect the messages to a file and examine it at your leisure. But be forewarned! Some debug channels can generate incredible volumes of log messages. Among the most prolific offenders are relay which spits out a log message every time a win32 function is called, win which tracks windows message passing, and of course all which is an alias for every single debug channel that exists. For a complex application, your debug logs can easily top 1 MB and higher. A relay trace can often generate more than 10 MB of log messages, depending on how long you run the application. (You'll want to check out RelayExclude registry key to modify what the relay trace reports). Logging does slow down Wine quite a bit, so don't use WINEDEBUG unless you really do want log files. Within each debug channel, you can further specify a message class, to filter out the different severities of errors. The four message classes are: trace, fixme, warn, err. To turn on a debug channel, use the form class+channel. To turn it off, use class-channel. To list more than one channel in the same WINEDEBUG option, separate them with commas. For example, to request warn class messages in the heap debug channel, you could invoke wine like this: $ WINEDEBUG=warn+heap wine program_name If you leave off the message class, wine will display messages from all four classes for that channel: $ WINEDEBUG=heap wine program_name If you wanted to see log messages for everything except the relay channel, you might do something like this: $ WINEDEBUG=+all,-relay wine program_name Here is a list of the debug channels and classes in Wine. More channels will be added to (or subtracted from) later versions. Table 4-1. Debug Channels accel adpcm advapi animate aspi atom avicap avifile bidi bitblt bitmap cabinet capi caret cdrom cfgmgr32 class clipboard clipping combo comboex comm commctrl commdlg computername console crtdll crypt curses cursor d3d d3d_shader d3d_surface datetime dc ddeml ddraw ddraw_fps ddraw_geom ddraw_tex debugstr devenum dialog dinput dll dma dmband dmcompos dmfile dmfiledat dmime dmloader dmscript dmstyle dmsynth dmusic dosfs dosmem dplay dplayx dpnhpast driver dsound dsound3d edit enhmetafile environ event eventlog exec file fixup font fps g711 gdi global glu graphics header heap hook hotkey icmp icon imagehlp imagelist imm int int21 int31 io ipaddress iphlpapi jack joystick key keyboard listbox listview loaddll local mapi mci mcianim mciavi mcicda mcimidi mciwave mdi menu menubuilder message metafile midi mmaux mmio mmsys mmtime module monthcal mpeg3 mpr msacm msdmo msg mshtml msi msimg32 msisys msrle32 msvcrt msvideo mswsock nativefont netapi32 netbios nls nonclient ntdll odbc ole oledlg olerelay opengl pager palette pidl powermgnt print process profile progress propsheet psapi psdrv qcap quartz ras rebar reg region relay resource richedit rundll32 sblaster scroll seh selector server setupapi shdocvw shell shlctrl snmpapi snoop sound static statusbar storage stress string syscolor system tab tape tapi task text thread thunk tid timer toolbar toolhelp tooltips trackbar treeview ttydrv twain typelib uninstaller updown urlmon uxtheme ver virtual vxd wave wc_font win win32 wineboot winecfg wineconsole wine_d3d winevdm wing winhelp wininet winmm winsock winspool wintab wintab32 wnet x11drv x11settings xdnd xrandr xrender xvidmode For more details about debug channels, check out theThe Wine Developer's Guide.

1.0.13.2. WINEDLLOVERRIDES=[DLL Overrides]

• It's not always possible to run an application on builtin DLL's. Sometimes native DLL's simply work better. Altough these DLL overrides can be set using winecfg you might want to use the WINEDLLOVERRIDES environment variable to set them.

  For example, if you wanted wine to use native ole32.dll, oleaut32.dll and rpcrt4 you could run wine like this:

$ WINEDLLOVERRIDES="ole32,oleaut32,rpcrt4=n" wine program_name

• For more information about DLL overrides, please refer to the DLL overrides section of this guide.

1.0.13.3. OSS Audio Driver Settings

If you are using the OSS audio driver and you have multiple devices, (i.e. /dev/dsp*, /dev/mixer*) you can specify which one you want to use with the following environment variables: * AUDIODEV=[audio device] * MIXERDEV=[mixer device] * MIDIDEV=[MIDI device] As an example: $ AUDIODEV=/dev/dsp4 MIXERDEV=/dev/mixer1 MIDIDEV=/dev/midi3 wine program_name

1.0.14. Komendy opcje Wineserver

wineserver usually gets started automatically by Wine whenever the first wine process gets started. However, wineserver has some useful command line options that you can add if you start it up manually, e.g. via a user login script or so.

1.0.14.1. -d<n>

Sets the debug level for debug output in the terminal that wineserver got started in at level <n>. In other words: everything greater than 0 will enable wineserver specific debugging output.

1.0.14.2. -h

Display wineserver command line options help message.

1.0.14.3. -k[n]

Kill the current wineserver, optionally with signal n.

1.0.14.4. -p[n]

• This parameter makes wineserver persistent, optionally for n seconds. It will prevent wineserver from shutting down immediately. Usually, wineserver quits almost immediately after the last wine process using this wineserver terminated. However, since wineserver loads a lot of things on startup (such as the whole Windows registry data), its startup might be so slow that it's very useful to keep it from exiting after the end of all Wine sessions, by making it persistent.

1.0.14.5. -w

This parameter makes a newly started wineserver wait until the currently active wineserver instance terminates.

1.0.15. Setting Windows/DOS environment variables

Your program might require some environment variable to be set properly in order to run successfully. In this case you need to set this environment variable in the Linux shell, since Wine will pass on the entire shell environment variable settings to the Windows environment variable space. Example for the bash shell (other shells may have a different syntax !): export MYENVIRONMENTVAR=myenvironmentvarsetting This will make sure your Windows program can access the MYENVIRONMENTVAR environment variable once you start your program using Wine. If you want to have MYENVIRONMENTVAR set permanently, then you can place the setting into /etc/profile, or also ~/.bashrc in the case of bash. Note however that there are some exceptions to the rule: If you want to change the PATH, SYSTEM or TEMP variables, the of course you can't modify it that way, since this will alter the Unix environment settings. Instead, you should set them into the registry. To set them you should launch wine regedit and then go to the HKEY_CURRENT_USER/Environment key. Now you can create or modify the values of the variables you need "System" = "c:\\windows\\system" This sets up where the windows system files are. The Windows system directory should reside below the directory used for the Windows setting. Thus when using /usr/local/wine_c_windows as Windows path, the system directory would be /usr/local/wine_c/windows/system. It must be set with no trailing slash, and you must be sure that you have write access to it. "Temp" = "c:\\temp" This should be the directory you want your temp files stored in, /usr/local/wine_c/temp in our previous example. Again, no trailing slash, and write access!! "Path" = "c:\\windows;c:\\windows\\system;c:\\blanco" Behaves like the PATH setting on UNIX boxes. When wine is run like wine sol.exe, if sol.exe resides in a directory specified in the Path setting, wine will run it (Of course, if sol.exe resides in the current directory, wine will run that one). Make sure it always has your windows directory and system directory (For this setup, it must have "c:\\windows;c:\\windows\\system").

1.0.15.1. Text mode programs (CUI: Console User Interface)

Text mode programs are program which output is only made out of text (surprise!). In Windows terminology, they are called CUI (Console User Interface) executables, by opposition to GUI (Graphical User Interface) executables. Win32 API provide a complete set of APIs to handle this situation, which goes from basic features like text printing, up to high level functionalities (like full screen editing, color support, cursor motion, mouse support), going through features like line editing or raw/cooked input stream support Given the wide scope of features above, and the current usage in Un*x world, Wine comes out with three different ways for running a console program (aka a CUI executable): * bare streams * wineconsole with user backend * wineconsole with curses backend The names here are a bit obscure. "bare streams" means that no extra support of wine is provide to map between the unix console access and Windows console access. The two other ways require the use of a specific Wine program (wineconsole) which provide extended facilities. The following table describes what you can do (and cannot do) with those three ways. Table 4-2. Basic differences in consoles ||<tablewidth="765px" tableheight="242px" tablealign="">Funkcja ||Bare strams||Wineconsole & user backend||Wineconsole & curses backend || ||How to run (assuming executable is called foo.exe)||$ wine foo.exe||$ wineconsole -- --backend=user foo.exe||$ wineconsole foo.exe You can also use --backend=curses as an option||

1.0.15.2. Konfiguracja of CUI executables

When wineconsole is used, several configuration options are available. Wine (as Windows do) stores, on a per application basis, several options in the registry. This let a user, for example, define the default screen-buffer size he would like to have for a given application. As of today, only the USER backend allows you to edit those options (we don't recommend editing by hand the registry contents). This edition is fired when a user right click in the console (this popups a menu), where you can either choose from: * Default: this will edit the settings shared by all applications which haven't been configured yet. So, when an application is first run (on your machine, under your account) in wineconsole, wineconsole will inherit this default settings for the application. Afterwards, the application will have its own settings, that you'll be able to modify at your will. Properties: this will edit the application's settings. When you're done, with the edition, you'll be prompted whether you want to: 1. Keep these modified settings only for this session (next time you run the application, you will not see the modification you've just made). 2. Use the settings for this session and save them as well, so that next you run your application, you'll use these new settings again. Here's the list of the items you can configure, and their meanings: Table 4-3. Wineconsole configuration options

1.0.16. Problemy / Reportowanie błedów

1.0.16.1. Co mam zrobić jak pewne programy nadal niedziałaja

There are times when you've been trying everything, you even killed a cat at full moon and ate it with rotten garlic and foul fish while doing the Devil's Dance, yet nothing helped to make some damn program work on some Wine version. Don't despair, we're here to help you... (in other words: how much do you want to pay ?)

1.0.16.2. Weryfikacja twojej konfiguracji wine

Look at the output from $ wine --version to make sure you're running a recent version of Wine. Launch winecfg and look over the settings to make sure you have settings that look normal. Look in ~/.wine/dosdevices to make sure you're c: points to where you think it should.

1.0.16.3. Użyj innej uemulacji wersji windows

In several cases usingdifferent windows version settingscan help

1.0.16.4. Użyj innej sciezki dostepu

This sometimes helps, too: Try to use bothwine prg.exeandwine x:\\full\\path\\to\\prg.exe

1.0.16.5. Fiddle with DLL configuration

• Run with WINEDEBUG=+loaddll to figure out which DLLs are being used, and whether they're being loaded as native or built-in. Then make sure you have proper native DLL files in your configured C:\windows\system directory and fiddle with DLL load order settings at command line or in config file.

---

1.0.16.6. Check your system environment !

Just an idea: could it be that your Wine build/execution environment is broken ? Make sure that there are no problems whatsoever with the packages that Wine depends on (gcc, glibc, X libraries, OpenGL (!), ...)

1.0.16.7. Użyj rónych GUI (Window Manager )

Instruct Wine via Winecfg to use either desktop mode, or normal managed mode. That can make a lot of difference, too.

1.0.16.8. Sprawdz swoja aplikacje !

Maybe your app is using some kind of copy protection ? Many copy protections currently don't work on Wine. Some might work in the future, though. (the CD-ROM layer isn't really full-featured yet)

1.0.16.9. Check your Wine environment !

Running with or without a Windows partition can have a dramatic impact. Configure Wine to do the opposite of what you used to have.

1.0.16.10. Rekonfiguracja

Sometimes wine installation process changes and new versions of Wine account on these changes. This is especially true if your setup was created long time ago. Rename your existing ~/.wine directory for backup purposes. Use the setup process that's recommended for your Wine distribution to create new configuration. Use information in old ~/.wine directory as a reference. Later you can remove the new ~/.wine directory and rename your old one back.

1.0.16.11. WineSprawdz wczesniejsze informacje

• There is a really good chance that someone has already tried to do the same thing as you. You may find the following resources helpful:

• Search WineHQ's Application Database to check for any tips relating to the program. If your specific version of the program isn't listed you may find a different one contains enough information to help you out.

• Frank's Corner contains a list of applications and detailed instructions for setting them up. Further help can be found in the user forums.

• Google can be useful depending on how you use it. You may find it helpful to search Google Groups, in particular the comp.emulators.ms-windows.wine group.

• Freenode.net hosts an IRC channel for Wine. You can access it by using any IRC client such as Xchat. The settings you'll need are: server = irc.freenode.net, port = 6667, and channel = #winehq

• If you have a program that needs the Visual Basic Runtime Environment, you can download it from this Microsoft site

• If you know you are missing a DLL, such as mfc42, you may be able to find it at www.dll-files.com

• Wine's mailing lists may also help, especially wine-users. The wine-devel list may be appropriate depending on the type of problem you are experiencing. If you post to wine-devel you should be prepared to do a little work to help diagnose the problem. Read the section below to find out how to debug the source of your problem.

• If all else fails, you may wish to investigate commercial versions of Wine to see if your application is supported.

1.0.16.12. Debuguj program!

• Finding the source of your problem is the next step to take. There is a wide spectrum of possible problems ranging from simple configurations issues to completely unimplemented functionality in Wine. The next section will describe how to file a bug report and how to begin debugging a crash. For more information on using Wine's debugging facilities be sure to read the Wine Developers Guide.

1.0.17. Jak zaraportowac błedy

Please report all bugs along any relevant information toWine Bugzilla. Please, search the Bugzilla database to check whether your problem is already reported. If it is already reported please add any relevant information to the original bug report.

1.0.17.1. Raportowanie błedów

Some simple advice on making your bug report more useful (and thus more likely to get answered and fixed): 1. Post as much relevant information as possible. This means we need more information than a simple "MS Word crashes whenever I run it. Do you know why?" Include at least the following information: * Which version of Wine you're using (run wine --version) * The name of the Operating system you're using, what distribution (if any), and what version. (i.e., Linux Red Hat 7.2) * Which compiler and version, (run gcc -v). If you didn't compile wine then the name of the package and where you got it from. * Windows version, if used with Wine. Mention if you don't use Windows. * The name of the program you're trying to run, its version number, and a URL for where the program can be obtained (if available). * The exact command line you used to start wine. (i.e., wine "C:\Program Files\Test\program.exe"). * The exact steps required to reproduce the bug. * Any other information you think may be relevant or helpful, such as X server version in case of X problems, libc version etc. 2. Re-run the program with the WINEDEBUG environment variable WINEDEBUG=+relay option (i.e., WINEDEBUG=+relay wine sol.exe). This will output additional information at the console that may be helpful in debugging the program. It also slows the execution of program. There are some cases where the bug seems to disappear when +relay is used. Please mention that in the bug report.

1.0.17.2. Zawieszanie

If Wine crashes while running your program, it is important that we have this information to have a chance at figuring out what is causing the crash. This can put out quite a lot (several MB) of information, though, so it's best to output it to a file. When the Wine-dbg> prompt appears, type quit. You might want to try +relay,+snoop instead of +relay, but please note that +snoop is pretty unstable and often will crash earlier than a simple +relay! If this is the case, then please use only +relay!! A bug report with a crash in +snoop code is useless in most cases! You can also turn on other parameters, depending on the nature of the problem you are researching. See wine man page for full list of the parameters. It is likely that only the last 100 or so lines of the trace are necessary to find out where the program crashes. In order to get those last 100 lines we need to do the following 1. Redirect all the output of WINEDEBUG to a file. 2. Separate the last 100 lines to another file using tail. This can be done using one of the following methods. all shells: $ echo quit | WINEDEBUG=+relay wine [other_options] program_name >& filename.out; $ tail -n 100 filename.out > report_file (This will print wine's debug messages only to the file and then auto-quit. It's probably a good idea to use this command, since wine prints out so many debug msgs that they flood the terminal, eating CPU cycles.) tcsh and other csh-like shells: $ WINEDEBUG=+relay wine [other_options] program_name |& tee filename.out; $ tail -n 100 filename.out > report_file bash and other sh-like shells: $ WINEDEBUG=+relay wine [other_options] program_name 2>&1 | tee filename.out; $ tail -n 100 filename.out > report_file report_file will now contain the last hundred lines of the debugging output, including the register dump and backtrace, which are the most important pieces of information. Please do not delete this part, even if you don't understand what it means. Post the bug to Wine Bugzilla. You need to attach the output file report_file from part 2). Along with the the relevant information used to create it. Do not cut and paste the report in the bug description - it is pretty big and it will make a mess of the bug report. If you do this, your chances of receiving some sort of helpful response should be very good. Please, search the Bugzilla database to check whether your problem is already reported. If it is already reported attach the output file report_file to the original bug report and add any other relevant information.

1.0.18. Słownik

Binary A file which is in machine executable, compiled form: hex data (as opposed to a source code file).

• Distribution
• A distribution is usually the way in which some "vendor" ships operating system CDs (usually mentioned in the context of Linux). A Linux environment can be shipped in lots of different configurations: e.g. distributions could be built to be suitable for games, scientific applications, server operation, desktop systems, etc. DLL A DLL (Dynamic Link Library) is a file that can be loaded and executed by programs dynamically. Basically it's an external code repository for programs. Since usually several different programs reuse the same DLL instead of having that code in their own file, this dramatically reduces required storage space. A synonym for a DLL would be library. Editor An editor is usually a program to create or modify text files. There are various graphical and text mode editors available on Linux. Examples of graphical editors are: nedit, gedit, kedit, xemacs, gxedit. Examples of text mode editors are: joe, ae, emacs, vim, vi. In a terminal, simply run them via: $ editorname filename Environment variable Environment variables are text definitions used in a Shell to store important system settings. In a bash shell (the most commonly used one in Linux), you can view all environment variables by executing: set If you want to change an environment variable, you could run: export MYVARIABLE=mycontent For deleting an environment variable, use: unset MYVARIABLE Git Git is a fast directory content manager, originally written for use with large repositories, such as the Linux Kernel source. See the Git chapter in the Wine Developers Guide for detailed usage information. Package A package is a compressed file in a distribution specific format. It contains the files for a particular program you want to install. Packages are usually installed via the dpkg or rpm package managers. root root is the account name of the system administrator. In order to run programs as root, simply open a Terminal window, then run: $ su - This will prompt you for the password of the root user of your system, and after that you will be able to system administration tasks that require special root privileges. The root account is indicated by the # prompt, whereas '$' indicates a normal user account. Shell A shell is a tool to enable users to interact with the system. Usually shells are text based and command line oriented. Examples of popular shells include bash, tcsh and ksh. Wine assumes that for Wine installation tasks, you use bash, since this is the most popular shell on Linux. Shells are usually run in a Terminal window. Source code Source code is the code that a program consists of before the program is being compiled, i.e. it's the original building instructions of a program that tell a compiler what the program should look like once it's been compiled to a Binary.
• Terminal A terminal window is usually a graphical window that one uses to execute a Shell. If Wine asks you to open a terminal, then you usually need to click on an icon on your desktop that shows a big black window (or, in other cases, an icon displaying a maritime shell). Wine assumes you're using the bash shell in a terminal window, so if your terminal happens to use a different shell program, simply type: bash in the terminal window.

1.0.19. List of Tables

1.0.19.1. Kanały debugowania

1.0.19.2. Standardowe rónice we konsoli

1.0.19.3. Opcje ustawien wineconsoli