IBM Announcement Letter No. ZP92-0612 dated August 18, 1992.
Order Type Part Program Number Number Name 5604-404 41G2943 IBM Developer's Migration Kit/2
The IBM Developer's Migration Kit/2 contains conversion utilities that allow developers of Windows(*) 3.0 applications to convert their products into OS/2 2.0 applications. The kit protects the developer's investment in Windows 3.0 source code while enabling the developer's product to take advantage of OS/2 2.0's advanced function and API.
* - Windows is a trademark of the Microsoft Corporation.
Planned General Availability Date is September 1992
The IBM Developer's Migration Kit/2 allows software developers to extend beyond the limitations of their Windows 3.0 applications. Using the kit to migrate to OS/2 2.0, developers can access advanced operating system functions such as multithreading and protected memory. These OS/2-enabled products can take advantage of the operating system's capabilities. The IBM Developer's Migration Kit/2 can expand the functionality of a developer's product, enabling the creation and implementation of new solutions to customer needs.
By using the IBM Developer's Migration Kit/2 to create OS/2 applications,
developers can gain a foothold in the growing
installed base of OS/2 2.0 systems.
The IBM Developer's Migration Kit/2
to create OS/2 2.0 versions of their
a complete rewrite of
code. Their investment in the development of Windows code is
protected -- use of the kit can produce Windows and OS/2 2.0 products
from a single source.
Developer Productivity. The kit enables software developers to reuse their Windows 3.0 source code to build OS/2 products. Code reuse can significantly reduce product development time and effort. The kit also allows for the incremental addition of OS/2 function, smoothing the migration path from Windows 3.0 to OS/2 2.0 and reducing the "cost" of learning the advanced function of OS/2. Developers are able to produce OS/2 2.0 applications even before in-depth proficiencies in OS/2 APIs are developed.
Customer Productivity. Using the kit, developers can take advantage of OS/2 2.0's advanced functionality such as multiple thread support. The kit can expand the functionality of a developer's product, enabling the creation and implementation of new solutions to customer needs.
The amount of effort required to port applications using the kit is dependent upon the design and implementation of the Windows source code to be ported. Some developers may be able to migrate their products without any code changes; some may require only minor code modifications. Others may have significant design issues that must be resolved before successful migration with the kit; in-depth knowledge of the source code to be ported is essential. Refer to the Technical Information (Limitations) section for more information.
Title Order Number ----------------------------------------- ------------ IBM Developer's Migration Kit/2: Application Migration Guide and Reference 41G2944
The IBM Developer's Migration Kit/2 is designed to run as follows:
The IBM Developer's Migration Kit/2 and generated object programs will run only under IBM OS/2 2.0 (5621-077) with or without IBM Extended Services (5621-213) for OS/2.
Use of the kit also requires:
Applications using the IBM Developer's Migration Kit/2 will not run on previous versions of OS/2.
Due to the technical complexity of the porting layer in the IBM Developer's Migration Kit/2, some changes or redesign of the Windows 3.0 source code may be necessary. The following information describes some restrictions of the kit.
Applications built using the kit utilize a dynamic link library (DLL) in OS/2 2.0 named Mirrors. Mirrors is a 32-bit DLL, which provides a thunking layer to convert 16-bit ported Windows API to 32-bit internal code. A thunking layer provides a translation layer between the 16-bit and 32-bit addressing schemes. This thunk is necessary because of the different addressing schemes used in 16-bit and 32-bit environments.
For example, in the ported environment, when an application calls a Windows function such as GlobalAlloc, it is actually calling the function GlobalAlloc16, which determines the parameters (if any) that need to be converted, sets up a 32-bit stack, and makes a call to the 32-bit version of GlobalAlloc, which performs all the "real" work.
Mirrors implements the supported API as documented in Windows. Notice that no other support is guaranteed. If a Windows function behaves differently from the documented behavior, Mirrors follows the actual Windows behavior.
Mirrors maintains a number of internal data structures. Whereas a ported application would cause the creation and maintenance of a data structure within Windows, the structure is created and maintained by Mirrors. Mirrors can also create a similar structure within the Presentation Manager (PM) environment. For example, a ported Windows application might need to create a device context (DC). PM has a similar entity called a presentation space. Although similar, a presentation space is not identical to a Windows device context. Therefore, when a ported application needs to create a device context, Mirrors creates a presentation space in the PM environment and maintains structures to give the application the appearance of interacting with a device context.
When the ported Windows application opens a device context, Mirrors returns a 16-bit handle to the application. The application can act on this handle as if it were a handle to a Windows device context. In actuality, Mirrors is maintaining a structure for this device context, which also includes a 32-bit value to the PM presentation space.
Consider what happens when an application attempts to use a value from this device context. For example, if the ported Windows application tried to set the text color, the text color would be set in the Mirrors structure and also set in the PM presentation space. This arrangement enables Mirrors to perform some optimization. The application might set the text color five times in a row without realizing an object which uses that color. Although Mirrors changes the color in its internal device context structure and returns the previous color, it does not pass this change on to the PM presentation space until there is some demand for the color change such as a call to TextOut. Therefore, if the application does not make calls to use these intermediate colors, Mirrors can reduce the number of instruction cycles. This can save a considerable amount of time.
All the Windows controls, which would ordinarily be realized by Windows, are actually realized by Mirrors. They are windows that Mirrors draws and maintains to emulate a Presentation Manager control. The ported Windows application and the Mirrors DLL combined are essentially a PM application. For example, when your application creates a button, Mirrors does not create a Presentation Manager button. Mirrors creates its own window registered as a button class. Messages are sent to this window in the same fashion as they would be for Windows even though it is neither a PM button nor a Windows button.
Dialog boxes are created and maintained by Mirrors. The Presentation Manager Dialog Box Manager is not used.
The following list contains important design assumptions and constraints. Ensure that your application satisfies these items before beginning the porting process.
The previous instance handle passed to a ported application is always NULL. Windows performs in a similar manner to a shell under DOS, that is, it is aware of all the applications that might be running under it. Because Mirrors is simply an additional DLL running under OS/2 2.0, it cannot be aware of all the other processes running under OS/2 management. Therefore, Mirrors cannot determine whether any previous instances of the application are running.
Under Windows, an application does not relinquish control of the CPU until GetMessage or PeekMessage is called. Under OS/2 2.0, an application can have control taken away at any time because OS/2 2.0 is a preemptive operating system. An application dependent upon Windows-style operation might experience unexpected problems. For example, suppose Program A calls the function LoadModule to start a second application (Program B), and that Program A depends on data that Program B sets prior to calling GetMessage. Under OS/2 2.0, Program A can continue as soon as the LoadModule call is complete and prior to beginning Program B's execution. Programs A and B must synchronize their activities with a PM semaphore and the OS/2 function WinMsgSemWait.
Applications that use a PeekMessage loop to wait for a specific message to be posted from another application should call Yield() before each call to PeekMessage. This is commonly done when using DDE and the application is waiting for a WM_DDE_ACK message in response to a posted WM_DDE_DATA message. Because the applications are running in a pre-emptive multitasking environment, it is difficult to determine when a task will receive the CPU and how much CPU time a particular task will receive for processing. Typically, the currently active task has the highest priority and will receive more CPU time than other tasks. This can cause the task, which is awaiting response from a server application, to timeout of its PeekMessage loop and assume a negative acknowledgement. By calling Yield(), the application is releasing its CPU time for other applications to run. This will usually be enough time for the server application to process some messages and post its acknowledgement. For example:
dwTime = GetCurrentTime(); while (GetCurrentTime() - dwTime < DDE_TIMEOUT) Yield(); if (PeekMessage (&msg,hwnd,WM_DDE_ACK,WM_DDE_ACK,PM_REMOVE)) . . .
If a function exists within the Windows API or the Mirrors extensions to that API, use that function rather than a similar function from the library of the compiler used to develop the software. This is necessary to guarantee proper operation of certain functions within the Windows environment. For example, if a program uses the C function exit to terminate a function's operation instead of using a return, memory might not be freed by Windows or Mirrors and the proper values might not be returned in wParam and lParam.
OS/2 2.0 and Windows pass initialization data in different registers. Mirrors must correct this difference, therefore, it provides an include file MIRDLL.INC, which must be included as the first statement of the DLL initialization code. This include file will set up the registers as if they were under Windows. This file must be included if the DLL must receive the heapsize into the CX register and the address of the command line into ES :SI.
OS/2 2.0 has protected memory and Windows does not. Therefore, addressing is handled differently between the two systems. It is recommended not to assume the contents of the ES register across calls.
In OS/2 2.0, values should not be stored into segment registers that were not returned by calls to the operating system because segments are selectors, and selectors are owned by processes. If an address value that has not been assigned to your process is calculated, your application will fail with a memory protection violation. In the worst case, if the calculated value matches a value that has been assigned to your process, the contents of memory are destroyed but this might not be discovered until some later point during processing.
The Restore button menu item for maximized MDI children (child windows) does not appear entirely right-justified in the menu. However, the functionality is not affected.
The Mirrors resource compiler can issue a message similar to the following:
Code page 437 incompatible with Windows
The IBM Developer's Migration Kit/2 resource compiler uses the code page directive from the CONFIG.SYS file on the development system. Notice that not all OS/2 code pages are compatible with Windows. Code page 437, which is frequently listed in this directive, is equivalent to the default IBM or IBM-compatible personal computer code page in the United States. This code page is not identical with the ANSI character set that Windows uses. Therefore, the kit's resource compiler issues a warning to notify you of possible differences.
Generally, code page 437 will map correctly. However, code page 850 is closer to the one used by Windows. It is recommended that this code page be listed first in the code page directive of the OS/2 CONFIG.SYS on the development system, or that the -Gnnn option be used when calling the kit's resource compiler.
Many Windows applications assume that the sum of the extent of individual characters in a string is equal to the extent of the string. This is true for Windows but might not be true for OS/2 2.0. PM outline fonts support kerning pairs; Windows outline fonts do not. If your application relies on this action in Windows, it might need to be changed.
The following short code sample is an illustration.
DWORD lCharSize = 0L; DWORD lStrSize = 0L; lCharSize = LOWORD(GetTextExtent(hDC,"M",1)); lCharSize += LOWORD(GetTextExtent(hDC,"l",1)); lStrSize = LOWORD(GetTextExtent(hDC,"Ml",2));
Notice that lCharSize will not always equal lStrSize in a ported Mirrors application.
The fonts available to your ported application when it is run under OS/2 2.0 is different from those available under Windows. Therefore, some mapping must be done. The mapping algorithm used by Mirrors is the same as the font-mapping algorithm described in the Windows documentation.
This means that the font chosen for your application will be the same font that Windows would have chosen if the font had been available. For example, the algorithm will map a Modern vector font to a Courier outline font, which is what Windows would do if it were presented with the same set of choices.
Under Windows, outline and bit-map fonts do not have the same name. However, it is possible under OS/2 2.0 to have a font named HELV for both a bit map and an outline font. To prevent confusion for the ported application, Mirrors renames the outline fonts under Presentation Manager to append the string "outline" so that the ported Windows application can tell the difference between the two.
Properties associated with printers are conceptually different between OS/2 2.0 and Windows. The Presentation Manager design has two categories of information associated with printers, printer properties and job properties. Printer properties involve more permanent aspects of the printer such as whether a printer has a tractor feed or not. Job properties are properties that can easily change between output such as printing in landscape or portrait orientation.
In the ported Windows application, all references to the function DeviceMode should be changed to ExtDeviceMode. Initialization data obtained from this function should be saved and passed back to the CreateIC or CreateOC functions, which allow the program to change job properties such as orientation on a per-job basis rather than on a system-wide basis.
Mirrors must accomplish a certain amount of thunking to account for the different addressing schemes between the 32-bit memory model of OS/2 2.0 and the 16-bit world of Windows applications. Mirrors uses and expects a tiled memory scheme where the 16-bit segment addresses are evenly mapped into 64KB blocks in the 32-bit global memory. Because data segments are handled transparently by Mirrors, most programmers do not need to give this any attention. However, some programs attempt to use a scheme to read and write data from code segments. These code segments do not follow the same tiled-memory addressing scheme as data segments. Instead, they often follow a packed scheme. Therefore, Mirrors cannot correctly calculate the address to data placed in a code segment.
If your application keeps data in a code segment, then the application is responsible for maintaining this data. It is strongly recommended that the application be modified to keep data in a data segment.
All window and dialog callback functions must be exported in the DEF file. Notice that utility programs, such as FIXDS that modifies the executable file, will not work and should not be used.
Because of the differences in stacksize requirements for a Windows application and a ported application, MIRDEF modifies the stacksize used during the link process.
The icon, which OS/2 2.0 displays in a folder for the executable file, is determined by the following search order. Notice that the first icon found is used.
It is recommended that your application icon be defined as the lowest-numbered icon or cursor resource in your resource file.
The concepts of processes and threads are new to many Windows programmers. A program executing within the DOS and Windows environment can be thought of as a single process with a single thread of execution. Access to system resources is shared among individual programs without strict controls. An executable file within OS/2 2.0 is a single process but that process can have many threads of execution within it. Because OS/2 2.0 is a true multitasking system, access to system resources is managed much more closely. The granularity of memory management is at the process level in OS/2 2.0 rather than at the program level as in DOS or Windows. Separate executing programs are not simply different threads of execution; they are different processes entirely and cannot overlap system resources without explicit declaration.
Separate programs running under DOS or Windows can share blocks of memory because of the rather free manner in which DOS or Windows manage access to memory. Essentially, if a program can obtain a handle to a system resource such as global memory that program can access that memory even though it was not allocated by the program. However, due to the tighter controls which OS/2 2.0 places on memory, programs that might have acted together in a coordinated manner under the DOS and Windows combination might act differently under OS/2 2.0. A program cannot simply access memory anywhere in the system by using a memory handle.
Under OS/2 2.0, memory that belongs to one process cannot be shared with another process without explicit declaration. This difference in memory management between the two environments can be overcome by following the coding suggestions below:
The conceptual model for shared memory also applies to the differences to between Windows and OS/2 2.0 for their management of access to libraries. In Windows, a program can gain access to a DLL simply by obtaining a handle to that DLL. In OS/2 2.0, libraries must be explicitly linked against a process for the DLL to become available to that process. It can also become available to a process at run time by calling LoadLibrary.
An alphabetical list is provided of all the functions that are part of the Windows environment. Each function is either fully supported, marked as supported with change, as extended support, or not supported.
Fully supported functions perform as they would under Windows. Refer to the Windows Software Development Kit for descriptions of these functions.
Function Functional Area Support Status _lclose File I/O _lcreat File I/O _llseek File I/O _lopen File I/O _lread File I/O _lwrite File I/O AccessResource Resource management Not supported AddAtom Atom management AddFontResource Font AdjustWindowRect Window creation AdjustWindowRectEx Window creation AllocDStoCSAlias Segment Not supported AllocResource Resource management Not supported AllocSelector Segment Not supported AnimatePalette Color palette AnsiLower String manipulation AnsiLowerBuff String manipulation AnsiNext String manipulation AnsiPrev String manipulation AnsiToOem String manipulation AnsiToOemBuff String manipulation AnsiUpper String manipulation AnsiUpperBuff String manipulation AnyPopup Information AppendMenu Menu Arc Line output ArrangeIconic- Windows Display/movement BeginDefer- WindowPos Display/movement BeginPaint Painting BitBlt Bit map BringWindowToTop Display/movement BuildCommDCB Communication Not supported CallMsgFilter Hook Supported w/change CallWindowProc Message Catch Task ChangeClipboard- Chain Clipboard Supported w/change ChangeMenu Menu ChangeSelector Segment Not supported CheckDlgButton Dialog box CheckMenuItem Menu CheckRadioButton Dialog box ChildWindowFrom- Point Coordinate/Info Chord Ellipse & polygon ClearCommBreak Communication Not supported ClientToScreen Coordinate
Function Functional Area Support Status ClipCursor Cursor CloseClipboard Clipboard CloseComm Communication Not supported CloseMetaFile Metafile CloseSound Sound Not supported CloseWindow Display/movement CombineRgn Region CopyMetaFile Metafile CopyRect Rectangle CountClipboard- Formats Clipboard CountVoiceNotes Sound Not supported CreateBitmap Bit map CreateBitmap- Indirect Bit map CreateBrush- Indirect Drawing tool CreateCaret Caret CreateCompatible- Bitmap Bit map CreateCompatibleDC Device context CreateCursor Cursor CreateDC Device context CreateDialog Dialog box CreateDialog- Indirect Dialog box CreateDialog- IndirectParam Dialog box CreateDialogParam Dialog box CreateDIBitmap Device-ind. bit map CreateDIBPattern- Brush Drawing tool CreateDiscardable- Bitmap Bit map CreateEllipticRgn Region CreateEllipticRgn- Indirect Region CreateFont Font Supported w/change CreateFontIndirect Font Supported w/change CreateHatchBrush Drawing tool Supported w/change CreateIC Device context CreateIcon Painting CreateMenu Menu CreateMenuIndirect Menu Not supported CreateMetaFile Metafile CreateOC Device context Supported w/change CreatePalette Color palette CreatePatternBrush Drawing tool CreatePen Drawing tool
Function Functional Area Support Status CreatePenIndirect Drawing tool CreatePoly- PolygonRgn Region CreatePolygonRgn Region CreatePopupMenu Menu CreateRectRgn Region CreateRectRgn- Indirect Region CreateRoundRectRgn Region CreateSolidBrush Drawing tool CreateWindow Window creation CreateWindowEx Window creation DebugBreak Debugging DefDlgProc Dialog box/ Window creation DeferWindowPos Display/movement DefFrameProc Window creation DefHookProc Hook Supported w/change DefineHandleTable Memory management Not supported DefMDIChildProc Window creation DefWindowProc Window creation DeleteAtom Atom management DeleteDC Device context DeleteMenu Menu DeleteMetaFile Metafile DeleteObject Drawing tool DestroyCaret Caret DestroyCursor Cursor DestroyIcon Painting DestroyMenu Menu DestroyWindow Window creation DeviceCapabilities Printer control Supported w/change DeviceMode Printer control DialogBox Dialog box DialogBoxIndirect Dialog box DialogBoxIndirect- Param Dialog box DialogBoxParam Dialog box DispatchMessage Message DlgDirList Dialog box DlgDirListComboBox Dialog box DlgDirSelect Dialog box DlgDirSelect- ComboBox Dialog box Supported w/change DOS3CALL OS interrupt DPtoLP Coordinate DrawFocusRect Ellipse & polygon/ Painting DrawIcon Painting
Function Functional Area Support Status DrawMenuBar Menu DrawText Painting Ellipse Ellipse & polygon EmptyClipboard Clipboard EnableHardware- Input Hardware EnableMenuItem Menu EnableWindow Input EndDeferWindowPos Display/movement EndDialog Dialog box EndPaint Painting EnumChildWindows Information Supported w/change EnumClipboard- Formats Clipboard EnumFonts Font EnumMetaFile Metafile Not supported EnumObjects Drawing tool EnumProps Property Supported w/change EnumTaskWindows Information EnumWindows Information EqualRect Rectangle EqualRgn Region Escape Printer escape EscapeCommFunction Communication Not supported ExcludeClipRect Clipping ExcludeUpdateRgn Painting ExitWindows Task Supported w/change ExtDeviceMode Printer control Supported w/change ExtFloodFill Bit map ExtTextOut Text FatalAppExit Debugging FatalExit Debugging FillRect Painting FillRgn Region FindAtom Atom management FindResource Resource management FindWindow Information FlashWindow Error FloodFill Bit map FlushComm Communication Not supported FrameRect Painting FrameRgn Region FreeLibrary Module management FreeModule Module management FreeProcInstance Module management FreeResource Resource management FreeSelector Segment Not supported GetActiveWindow Input GetAspect- RatioFilter Font
Function Functional Area Support Status GetAsyncKeyState Hardware GetAtomHandle Atom management GetAtomName Atom management GetBitmapBits Bit map GetBitmap- Dimension Bit map GetBkColor Drawing attribute GetBkMode Drawing attribute GetBrushOrg Drawing tool GetCapture Input GetCaretBlinkTime Caret GetCaretPos Caret GetCharWidth Font GetClassInfo Window creation GetClassLong Window creation GetClassName Window creation GetClassWord Window creation GetClientRect Display/movement GetClipboardData Clipboard GetClipboard- FormatName Clipboard GetClipboardOwner Clipboard GetClipboardViewer Clipboard GetClipBox Clipping GetCodeHandle Module management Not supported GetCodeInfo Segment Not supported GetCommError Communication Not supported GetCommEventMask Communication Not supported GetCommState Communication Not supported GetCurrentPDB Task Not supported GetCurrentPosition Line output GetCurrentTask Task GetCurrentTime System GetCursorPos Cursor GetDC Painting GetDCOrg Device context GetDesktopWindow Information GetDeviceCaps Information GetDialogBaseUnits Dialog box GetDIBits Device-ind. bit map GetDlgCtrlID Dialog box GetDlgItem Dialog box GetDlgItemInt Dialog box GetDlgItemText Dialog box GetDOSEnvironment Task GetDoubleClickTime Input GetDriveType File I/O GetEnvironment Environment GetFocus Input
Function Functional Area Support Status GetFreeSpace Memory management GetInputState Hardware GetInstanceData Module management Not supported GetKBCodePage Hardware GetKeyboardState Hardware GetKeyboardType Hardware GetKeyNameText Hardware Not supported GetKeyState Hardware GetLastActivePopup Window creation GetMapMode Mapping GetMenu Menu GetMenuCheckMark Dimensions Menu GetMenuItemCount Menu GetMenuItemID Menu GetMenuState Menu GetMenuString Menu GetMessage Message Supported w/change GetMessagePos Message GetMessageTime Message GetMetaFile Metafile GetMetaFileBits Metafile Supported w/change GetModuleFileName Module management GetModuleHandle Module management GetModuleUsage Module management GetNearestColor Color palette GetNearestPalette- Index Color palette GetNextDlg- GroupItem Dialog box GetNextDlgTabItem Dialog box GetNextWindow Information GetNumTasks Task GetObject Drawing tool GetPaletteEntries Color palette GetParent Information GetPixel Bit map GetPolyFillMode Drawing attribute GetPriority- ClipboardFormat Clipboard GetPrivate- ProfileInt Initialization file GetPrivate- ProfileString Initialization file Supported w/change GetProcAddress Module management GetProfileInt Initialization file GetProfileString Initialization file Supported w/change GetProp Property GetRgnBox Region
Function Functional Area Support Status GetROP2 Drawing attribute GetScrollPos Scrolling GetScrollRange Scrolling GetStockObject Drawing tool GetStretchBltMode Drawing attribute GetSubMenu Menu GetSysColors System Supported w/change GetSysModalWindow Information GetSystemDirectory File I/O GetSystemMenu Menu GetSystemMetrics System Supported w/change GetSystem- PaletteEntries Color palette GetSystem- PaletteUse Color palette GetTabbed- TextExtent Text GetTempDrive File I/O GetTempFileName File I/O GetTextAlign Text GetTextCharacter- Extra Text GetTextColor Drawing attribute GetTextExtent Text GetTextFace Text GetTextMetrics Text GetThresholdBuffer Sound Not supported GetThresholdEvent Sound Not supported GetThresholdStatus Sound Not supported GetTickCount Input GetTopWindow Information GetUpdateRect Painting GetUpdateRgn Painting GetVersion Module management GetViewportExt Mapping GetViewportOrg Mapping GetWindow Information GetWindowDC Painting GetWindowExt Mapping GetWindowLong Window creation GetWindowOrg Mapping GetWindowRect Display/movement GetWindows- Directory File I/O GetWindowTask Information GetWindowText Display/movement GetWindow- TextLength Display/movement GetWindowWord Window creation
Function Functional Area Support Status GetWinFlags Memory management Extended support Global16Pointer- Alloc WINMEM32.DLL Not supported Global16Pointer- Free WINMEM32.DLL Not supported Global32Alloc WINMEM32.DLL Not supported Global32CodeAlias WINMEM32.DLL Not supported Global32Code- AliasFree WINMEM32.DLL Not supported Global32Free WINMEM32.DLL Not supported Global32Realloc WINMEM32.DLL Not supported GlobalAddAtom Atom management GlobalAlloc Memory management Supported w/change GlobalCompact Memory management Not supported GlobalDeleteAtom Atom management GlobalDiscard Memory management Not supported GlobalDosAlloc Memory management Not supported GlobalDosFree Memory management Not supported GlobalFindAtom Atom management GlobalFix Segment Not supported GlobalFlags Memory management GlobalFree Memory management GlobalGetAtomName Atom management GlobalHandle Memory management Supported w/change GlobalLock Memory management GlobalLRUNewest Memory management GlobalLRUOldest Memory management GlobalNotify Memory management Not supported GlobalPageLock Segment Not supported GlobalPageUnlock Segment Not supported GlobalReAlloc Memory management GlobalSize Memory management GlobalUnfix Segment Not supported GlobalUnlock Memory management GlobalUnwire Memory management Supported w/change GlobalWire Memory management Supported w/change GrayString Painting HideCaret Caret HiliteMenuItem Menu InflateRect Rectangle InitAtomTable Atom management InSendMessage Message InsertMenu Menu IntersectClipRect Clipping IntersectRect Rectangle InvalidateRect Region InvalidateRgn Painting InvertRect Painting InvertRgn Region
Function Functional Area Support Status IsCharAlpha String manipulation IsCharAlphaNumeric String manipulation IsCharLower String manipulation IsCharUpper String manipulation IsChild Information IsClipboard- FormatAvailable Clipboard IsDialogMessage Dialog box IsDlgButtonChecked Dialog box IsIconic Display/movement IsRectEmpty Rectangle IsWindow Information IsWindowEnabled Input IsWindowVisible Display/movement IsZoomed Display/movement KillTimer Input LimitEMSPages Memory management Not supported LineDDA Line output LineTo Line output LoadAccelerators Resource management LoadBitmap Bit map/Resource mgmt. LoadCursor Cursor/Resource mgmt. LoadIcon Resource management LoadLibrary Module management Supported w/change LoadMenu Resource management LoadMenuIndirect Menu Not supported LoadModule App. execution LoadResource Resource management LoadString Resource management LocalAlloc Memory management LocalCompact Memory management LocalDiscard Memory management LocalFlags Memory management LocalFree Memory management LocalHandle Memory management LocalInit Memory management LocalLock Memory management LocalReAlloc Memory management Supported w/change LocalShrink Memory management LocalSize Memory management LocalUnlock Memory management LockResource Resource management LockSegment Memory management LPtoDP Coordinate lstrcat String manipulation lstrcmp String manipulation lstrcmpi String manipulation lstrcpy String manipulation lstrlen String manipulation
Function Functional Area Support Status MakeProcInstance Module management MapDialogRect Dialog box MapVirtualKey Hardware MessageBeep Error MessageBox Error/Message Supported w/change ModifyMenu Menu MoveTo Line output MoveWindow Display/movement NetBIOSCall OS interrupt Not supported OemKeyScan Hardware OemToAnsi String manipulation OemToAnsiBuff String manipulation OffsetClipRgn Clipping OffsetRect Rectangle OffsetRgn Region OffsetViewportOrg Mapping OffsetWindowOrg Mapping OpenClipboard Clipboard OpenComm Communication Not supported OpenFile File I/O OpenIcon Display/movement OpenSound Sound Not supported OutputDebugString Debugging PaintRgn Region PatBlt Bit map PeekMessage Message Supported w/change Pie Ellipse & polygon PlayMetaFile Metafile PlayMetaFileRecord Metafile Not supported Polygon Ellipse & polygon Polyline Line output PolyPolygon Region Supported w/change PostAppMessage Message PostMessage Message PostQuitMessage Message ProfClear Optimization tool Not supported ProfFinish Optimization tool Not supported ProfFlush Optimization tool Not supported ProfInsChk Optimization tool Not supported ProfSampRate Optimization tool Not supported ProfSetup Optimization tool Not supported ProfStart Optimization tool Not supported ProfStop Optimization tool Not supported PtInRect Rectangle PtInRegion Region PtVisible Clipping ReadComm Communication Not supported RealizePalette Color palette Rectangle Ellipse & polygon
Function Functional Area Support Status RectInRegion Region RectVisible Clipping RegisterClass Window creation Supported w/change Register- ClipboardFormat Clipboard Register- WindowMessage Message ReleaseCapture Input ReleaseDC Painting RemoveFontResource Font RemoveMenu Menu RemoveProp Property ReplyMessage Message ResizePalette Color palette Resource Resource management RestoreDC Device context RoundRect Ellipse & polygon SaveDC Device context ScaleViewportExt Mapping ScaleWindowExt Mapping ScreenToClient Coordinate ScrollDC Scrolling ScrollWindow Scrolling SelectClipRgn Clipping SelectObject Drawing tool SelectPalette Color palette SendDlgItemMessage Dialog box SendMessage Message Supported w/change SetActiveWindow Input SetBitmapBits Bit map SetBitmapDimension Bit map SetBkColor Drawing attribute SetBkMode Drawing attribute SetBrushOrg Drawing tool SetCapture Input SetCaretBlinkTime Caret SetCaretPos Caret SetClassLong Window creation SetClassWord Window creation Supported w/change SetClipboardData Clipboard SetClipboardViewer Clipboard Supported w/change SetCommBreak Communication Not supported SetCommEventMask Communication Not supported SetCommState Communication Not supported SetCursor Cursor SetCursorPos Cursor SetDIBits Device-ind. bit map SetDIBitsToDevice Device-ind. bit map SetDlgItemInt Dialog box
Function Functional Area Support Status SetDlgItemText Dialog box SetDoubleClickTime Input SetEnvironment Environment Supported w/change SetErrorMode Task SetFocus Input Supported w/change SetHandleCount File I/O SetKeyboardState Hardware SetMapMode Mapping SetMapperFlags Font SetMenu Menu SetMenuItemBitmaps Menu SetMessageQueue Message Supported w/change SetMetaFileBits Metafile Supported w/change SetPaletteEntries Color palette SetParent Information SetPixel Bit map SetPolyFillMode Drawing attribute SetProp Property SetRect Rectangle SetRectEmpty Rectangle SetRectRgn Region SetResourceHandler Resource management Not supported SetROP2 Drawing attribute SetScrollPos Scrolling SetScrollRange Scrolling SetSoundNoise Sound Not supported SetStretchBltMode Drawing attribute SetSwapAreaSize Memory management SetSysColors System SetSysModalWindow Input SetSystem- PaletteUse Color palette SetTextAlign Text SetTextCharacter- Extra Text SetTextColor Drawing attribute SetText- Justification Text SetTimer Input SetViewportExt Mapping SetViewportOrg Mapping SetVoiceAccent Sound Not supported SetVoiceEnvelope Sound Not supported SetVoiceNote Sound Not supported SetVoiceQueueSize Sound Not supported SetVoiceSound Sound Not supported SetVoiceThreshold Sound Not supported SetWindowExt Mapping SetWindowLong Window creation
Function Functional Area Support Status SetWindowOrg Mapping SetWindowPos Display/movement SetWindowsHook Hook Supported w/change SetWindowText Display/movement SetWindowWord Window creation ShowCaret Caret ShowCursor Cursor ShowOwnedPopups Display/movement ShowScrollBar Scrolling ShowWindow Display/movement SizeofResource Resource management StartSound Sound Not supported StopSound Sound Not supported StretchBlt Bit map StretchDIBits Device-ind. bit map SwapMouseButton Input SwapRecording Optimization tool Not supported SwitchStackBack Memory management Not supported SwitchStackTo Memory management Not supported SyncAllVoices Sound Not supported TabbedTextOut Text TextOut Text Throw String manip./Task ToAscii String manipulation TrackPopupMenu Menu Translate- Accelerator Message Translate- MDISysAccel Message TranslateMessage Message TransmitCommChar Communication Not supported UngetCommChar Communication Not supported UnhookWindowsHook Hook Supported w/change UnionRect Rectangle UnlockResource Resource management UnlockSegment Segment Not supported UnrealizeObject Drawing tool UnregisterClass Window creation UpdateColors Color palette UpdateWindow Painting ValidateCode- Segments Debugging Not supported ValidateFreeSpaces Debugging Not supported ValidateRect Painting ValidateRgn Region VkKeyScan Hardware WaitMessage Message WaitSoundState Sound Not supported WindowFromPoint Coordinate/Info.
Function Functional Area Support Status WinExec Application execution WinHelp Application execution WriteComm Communication Not supported WritePrivate- ProfileString Initialization file Supported w/change WriteProfileString Initialization file wsprintf String manipulation wvsprintf String manipulation Yield Task
Customers should be aware of the technical limitations of the IBM Developer's Migration Kit/2 before purchase. The previously discussed restrictions should be communicated so that the customer is able to estimate the amount of work required for a successful port. The ship-group documentation, also available separately, provides further information on pre-migration considerations.
IBM Conditions of Use apply to all Dual Media packages, thus the program in a package may only be used on a single machine at any one time, even though the program may be provided in the package on two different sized media. If a customer wishes to use an IBM Conditions of Use program concurrently on more than one machine at a time, irrespective of the size of the medium, he must acquire that number of program packages equal to the number of concurrent users of the program.
The IBM Developer's Migration Kit/2 program package contains the following:
User management is responsible for evaluation, selection, and implementation of security features, administrative procedures, and appropriate controls in application systems and communication facilities.
Consult your IBM Marketing Representative for the applicable One-Time Charge.
This program is available from IBM under the Terms and Conditions for Purchase, and is subject to the Conditions of Use contained in the program package.
The Conditions of Use authorize the customer to use the program on only one machine at any one time.
Volume Discounting is available under the Terms and Conditions for IBM Volume Discount. Contact your IBM Marketing Representative for details.
This program will be included into Category A Discount Group 1 of Exhibits COU-02 and COUED-02.
Education Discount is available, please contact your IBM Marketing Representative for details.
This product is available under the Special Educational Allowance for Volume Orders of Selected IBM PC-PS/2 Conditions of Use Programs. Consult your IBM Marketing Representative for details.
IBM standard warranty of media. Warranty period 3 months (or the period required by local legislation, if greater).
Program service via Customer Technical Support Locations (CTSL's) is not available for this product. Customers are required to contact their remarketer/distributor, or IBM in writing, for program-defect related problems. Program service will be in accordance with the Service Statement included in the program package, and will be available until the Service End Date, July 28, 1994
All European, Middle Eastern and African Countries.
The data in this letter is subject to the disclaimer in Letter ZS90-0112, which is available from IBM on request.