dwindows: os2/dw.c comparison

comparison os2/dw.c @ 174:75bf3051235f

Fixes so you can mix compilers.

author	bsmith@81767d24-ef19-dc11-ae90-00e081727c95
date	Sun, 01 Dec 2002 12:59:24 +0000
parents	0fc45e386376
children	d78d08440246

comparison

equal deleted inserted replaced

-:c2b5d0019ec3
+:75bf3051235f
 * Initializes the Dynamic Windows engine.
 * Parameters:
 *           newthread: True if this is the only thread.
 *                      False if there is already a message loop running.
 */
-int dw_init(int newthread, int argc, char *argv[])
+int API dw_init(int newthread, int argc, char *argv[])
 {
 	APIRET rc;
 	if(newthread)
 	{
 }
 /*
 * Runs a message loop for Dynamic Windows.
 */
-void dw_main(void)
+void API dw_main(void)
 {
 	QMSG qmsg;
 	_dwtid = dw_thread_id();
 /*
 * Runs a message loop for Dynamic Windows, for a period of milliseconds.
 * Parameters:
 *           milliseconds: Number of milliseconds to run the loop for.
 */
-void dw_main_sleep(int milliseconds)
+void API dw_main_sleep(int milliseconds)
 {
 	QMSG qmsg;
 	double start = (double)clock();
 	while(((clock() - start) / (CLOCKS_PER_SEC/1000)) <= milliseconds)
 * Free's memory allocated by dynamic windows.
 * Parameters:
 *           ptr: Pointer to dynamic windows allocated
 *                memory to be free()'d.
 */
-void dw_free(void *ptr)
+void API dw_free(void *ptr)
 {
 	free(ptr);
 }
 /*
 * Allocates and initializes a dialog struct.
 * Parameters:
 *           data: User defined data to be passed to functions.
 */
-DWDialog *dw_dialog_new(void *data)
+DWDialog * API dw_dialog_new(void *data)
 {
 	DWDialog *tmp = malloc(sizeof(DWDialog));
 	tmp->eve = dw_event_new();
 	dw_event_reset(tmp->eve);
 * initial called of dw_dialog_wait().
 * Parameters:
 *           dialog: Pointer to a dialog struct aquired by dw_dialog_new).
 *           result: Data to be returned by dw_dialog_wait().
 */
-int dw_dialog_dismiss(DWDialog *dialog, void *result)
+int API dw_dialog_dismiss(DWDialog *dialog, void *result)
 {
 	dialog->result = result;
 	dw_event_post(dialog->eve);
 	dialog->done = TRUE;
 	return 0;
 * Accepts a dialog struct waits for dw_dialog_dismiss() to be
 * called by a signal handler with the given dialog struct.
 * Parameters:
 *           dialog: Pointer to a dialog struct aquired by dw_dialog_new).
 */
-void *dw_dialog_wait(DWDialog *dialog)
+void * API dw_dialog_wait(DWDialog *dialog)
 {
 	QMSG qmsg;
 	void *tmp;
 	while (WinGetMsg(dwhab, &qmsg, 0, 0, 0))
 * Parameters:
 *           title: The title of the message box.
 *           format: printf style format string.
 *           ...: Additional variables for use in the format.
 */
-int dw_messagebox(char *title, char *format, ...)
+int API dw_messagebox(char *title, char *format, ...)
 {
 	va_list args;
 	char outbuf[1024];
 	va_start(args, format);
 *           title: The title of the message box.
 *           text: The text to display in the box.
 * Returns:
 *           True if YES False of NO.
 */
-int dw_yesno(char *title, char *text)
+int API dw_yesno(char *title, char *text)
 {
 	if(WinMessageBox(HWND_DESKTOP, HWND_DESKTOP, text, title, 0, MB_YESNO | MB_INFORMATION | MB_MOVEABLE | MB_SYSTEMMODAL)==MBID_YES)
 		return TRUE;
 	return FALSE;
 }
 /*
 * Makes the window topmost.
 * Parameters:
 *           handle: The window handle to make topmost.
 */
-int dw_window_raise(HWND handle)
+int API dw_window_raise(HWND handle)
 {
 	return WinSetWindowPos(handle, HWND_TOP, 0, 0, 0, 0, SWP_ZORDER);
 }
 /*
 * Makes the window bottommost.
 * Parameters:
 *           handle: The window handle to make bottommost.
 */
-int dw_window_lower(HWND handle)
+int API dw_window_lower(HWND handle)
 {
 	return WinSetWindowPos(handle, HWND_BOTTOM, 0, 0, 0, 0, SWP_ZORDER);
 }
 /*
 * Makes the window visible.
 * Parameters:
 *           handle: The window handle to make visible.
 */
-int dw_window_show(HWND handle)
+int API dw_window_show(HWND handle)
 {
 	int rc = WinSetWindowPos(handle, NULLHANDLE, 0, 0, 0, 0, SWP_SHOW);
 	HSWITCH hswitch;
 	SWCNTRL swcntrl;
 /*
 * Minimizes or Iconifies a top-level window.
 * Parameters:
 *           handle: The window handle to minimize.
 */
-int dw_window_minimize(HWND handle)
+int API dw_window_minimize(HWND handle)
 {
 	HWND hwndclient = WinWindowFromID(handle, FID_CLIENT);
 	if(hwndclient)
 	{
 /*
 * Makes the window invisible.
 * Parameters:
 *           handle: The window handle to make visible.
 */
-int dw_window_hide(HWND handle)
+int API dw_window_hide(HWND handle)
 {
 	HSWITCH hswitch;
 	SWCNTRL swcntrl;
 	/* If this window has a  switch list entry make sure it is invisible */
 /*
 * Destroys a window and all of it's children.
 * Parameters:
 *           handle: The window handle to destroy.
 */
-int dw_window_destroy(HWND handle)
+int API dw_window_destroy(HWND handle)
 {
 	HWND parent = WinQueryWindow(handle, QW_PARENT);
 	Box *thisbox = WinQueryWindowPtr(parent, QWP_USER);
 	if(!handle)
 /* Causes entire window to be invalidated and redrawn.
 * Parameters:
 *           handle: Toplevel window handle to be redrawn.
 */
-void dw_window_redraw(HWND handle)
+void API dw_window_redraw(HWND handle)
 {
 	HWND client = WinWindowFromID(handle, FID_CLIENT);
 	HWND window = client ? client : handle;
 	Box *mybox = (Box *)WinQueryWindowPtr(window, QWP_USER);
 * Changes a window's parent to newparent.
 * Parameters:
 *           handle: The window handle to destroy.
 *           newparent: The window's new parent window.
 */
-void dw_window_reparent(HWND handle, HWND newparent)
+void API dw_window_reparent(HWND handle, HWND newparent)
 {
 	HWND blah = WinWindowFromID(newparent, FID_CLIENT);
 	WinSetParent(handle, blah ? blah : newparent, TRUE);
 }
 * Sets the font used by a specified window (widget) handle.
 * Parameters:
 *          handle: The window (widget) handle.
 *          fontname: Name and size of the font in the form "size.fontname"
 */
-int dw_window_set_font(HWND handle, char *fontname)
+int API dw_window_set_font(HWND handle, char *fontname)
 {
 	return WinSetPresParam(handle, PP_FONTNAMESIZE, strlen(fontname)+1, fontname);
 }
 /* Internal version */
 * Parameters:
 *          handle: The window (widget) handle.
 *          fore: Foreground color in DW_RGB format or a default color index.
 *          back: Background color in DW_RGB format or a default color index.
 */
-int dw_window_set_color(HWND handle, ULONG fore, ULONG back)
+int API dw_window_set_color(HWND handle, ULONG fore, ULONG back)
 {
 	dw_window_set_data(handle, "_dw_fore", (void *)fore);
 	dw_window_set_data(handle, "_dw_back", (void *)back);
 	return _dw_window_set_color(handle, fore, back);
 * Sets the font used by a specified window (widget) handle.
 * Parameters:
 *          handle: The window (widget) handle.
 *          border: Size of the window border in pixels.
 */
-int dw_window_set_border(HWND handle, int border)
+int API dw_window_set_border(HWND handle, int border)
 {
 	WinSendMsg(handle, WM_SETBORDERSIZE, MPFROMSHORT(border), MPFROMSHORT(border));
 	return 0;
 }
 /*
 * Captures the mouse input to this window.
 * Parameters:
 *       handle: Handle to receive mouse input.
 */
-void dw_window_capture(HWND handle)
+void API dw_window_capture(HWND handle)
 {
 	WinSetCapture(HWND_DESKTOP, handle);
 }
 /*
 * Releases previous mouse capture.
 */
-void dw_window_release(void)
+void API dw_window_release(void)
 {
 	WinSetCapture(HWND_DESKTOP, NULLHANDLE);
 }
 /*
 * Tracks this window movement.
 * Parameters:
 *       handle: Handle to frame to be tracked.
 */
-void dw_window_track(HWND handle)
+void API dw_window_track(HWND handle)
 {
 	WinSendMsg(handle, WM_TRACKFRAME, MPFROMSHORT(TF_MOVE), 0);
 }
 /*
 * Changes the appearance of the mouse pointer.
 * Parameters:
 *       handle: Handle to widget for which to change.
 *       cursortype: ID of the pointer you want.
 */
-void dw_window_pointer(HWND handle, int pointertype)
+void API dw_window_pointer(HWND handle, int pointertype)
 {
 	WinSetPointer(handle,
 				  WinQuerySysPointer(HWND_DESKTOP,
 									 pointertype,
 									 FALSE));
 * Parameters:
 *       owner: The Owner's window handle or HWND_DESKTOP.
 *       title: The Window title.
 *       flStyle: Style flags, see the PM reference.
 */
-HWND dw_window_new(HWND hwndOwner, char *title, ULONG flStyle)
+HWND API dw_window_new(HWND hwndOwner, char *title, ULONG flStyle)
 {
 	HWND hwndclient = 0, hwndframe;
 	Box *newbox = calloc(1, sizeof(Box));
 	WindowData *blah = calloc(1, sizeof(WindowData));
 * Create a new Box to be packed.
 * Parameters:
 *       type: Either BOXVERT (vertical) or BOXHORZ (horizontal).
 *       pad: Number of pixels to pad around the box.
 */
-HWND dw_box_new(int type, int pad)
+HWND API dw_box_new(int type, int pad)
 {
 	Box *newbox = calloc(1, sizeof(Box));
 	HWND hwndframe;
 	newbox->pad = pad;
 * Parameters:
 *       type: Either BOXVERT (vertical) or BOXHORZ (horizontal).
 *       pad: Number of pixels to pad around the box.
 *       title: Text to be displayined in the group outline.
 */
-HWND dw_groupbox_new(int type, int pad, char *title)
+HWND API dw_groupbox_new(int type, int pad, char *title)
 {
 	Box *newbox = calloc(1, sizeof(Box));
 	HWND hwndframe;
 	newbox->pad = pad;
 /*
 * Create a new MDI Frame to be packed.
 * Parameters:
 *       id: An ID to be used with dw_window_from_id or 0L.
 */
-HWND dw_mdi_new(unsigned long id)
+HWND API dw_mdi_new(unsigned long id)
 {
 	HWND hwndframe;
 	hwndframe = WinCreateWindow(HWND_OBJECT,
 								WC_FRAME,
 /*
 * Create a bitmap object to be packed.
 * Parameters:
 *       id: An ID to be used with WinWindowFromID() or 0L.
 */
-HWND dw_bitmap_new(ULONG id)
+HWND API dw_bitmap_new(ULONG id)
 {
 	return WinCreateWindow(HWND_OBJECT,
 						   WC_STATIC,
 						   NULL,
 						   WS_VISIBLE | SS_TEXT,
 * Create a notebook object to be packed.
 * Parameters:
 *       id: An ID to be used for getting the resource from the
 *           resource file.
 */
-HWND dw_notebook_new(ULONG id, int top)
+HWND API dw_notebook_new(ULONG id, int top)
 {
 	ULONG flags;
 	HWND tmp;
 	if(top)
 * Create a menu object to be popped up.
 * Parameters:
 *       id: An ID to be used for getting the resource from the
 *           resource file.
 */
-HMENUI dw_menu_new(ULONG id)
+HMENUI API dw_menu_new(ULONG id)
 {
 	HMENUI tmp = malloc(sizeof(struct _hmenui));
 	if(!tmp)
 		return NULL;
 /*
 * Create a menubar on a window.
 * Parameters:
 *       location: Handle of a window frame to be attached to.
 */
-HMENUI dw_menubar_new(HWND location)
+HMENUI API dw_menubar_new(HWND location)
 {
 	HMENUI tmp = malloc(sizeof(struct _hmenui));
 	if(!tmp)
 		return NULL;
 /*
 * Destroys a menu created with dw_menubar_new or dw_menu_new.
 * Parameters:
 *       menu: Handle of a menu.
 */
-void dw_menu_destroy(HMENUI *menu)
+void API dw_menu_destroy(HMENUI *menu)
 {
 	if(menu && *menu)
 	{
 		WinDestroyWindow((*menu)->menu);
 		free(*menu);
 *       flags: Extended attributes to set on the menu.
 *       end: If TRUE memu is positioned at the end of the menu.
 *       check: If TRUE menu is "check"able.
 *       submenu: Handle to an existing menu to be a submenu or NULL.
 */
-HWND dw_menu_append_item(HMENUI menux, char *title, ULONG id, ULONG flags, int end, int check, HMENUI submenu)
+HWND API dw_menu_append_item(HMENUI menux, char *title, ULONG id, ULONG flags, int end, int check, HMENUI submenu)
 {
 	MENUITEM miSubMenu;
 	HWND menu;
 	if(!menux)
 * Parameters:
 *       menu: The handle the the existing menu.
 *       id: Menuitem id.
 *       check: TRUE for checked FALSE for not checked.
 */
-void dw_menu_item_set_check(HMENUI menux, unsigned long id, int check)
+void API dw_menu_item_set_check(HMENUI menux, unsigned long id, int check)
 {
 	HWND menu;
 	if(!menux)
 		return;
 *       menu: The handle the the existing menu.
 *       parent: Handle to the window initiating the popup.
 *       x: X coordinate.
 *       y: Y coordinate.
 */
-void dw_menu_popup(HMENUI *menu, HWND parent, int x, int y)
+void API dw_menu_popup(HMENUI *menu, HWND parent, int x, int y)
 {
 	if(menu && *menu)
 	{
 		popup = parent;
 		WinPopupMenu(HWND_DESKTOP, parent, (*menu)->menu, x, dw_screen_height() - y, 0, PU_KEYBOARD | PU_MOUSEBUTTON1 | PU_VCONSTRAIN | PU_HCONSTRAIN);
 * Returns the current X and Y coordinates of the mouse pointer.
 * Parameters:
 *       x: Pointer to variable to store X coordinate.
 *       y: Pointer to variable to store Y coordinate.
 */
-void dw_pointer_query_pos(long *x, long *y)
+void API dw_pointer_query_pos(long *x, long *y)
 {
 	POINTL ptl;
 	WinQueryPointerPos(HWND_DESKTOP, &ptl);
 	if(x && y)
 * Sets the X and Y coordinates of the mouse pointer.
 * Parameters:
 *       x: X coordinate.
 *       y: Y coordinate.
 */
-void dw_pointer_set_pos(long x, long y)
+void API dw_pointer_set_pos(long x, long y)
 {
 	WinSetPointerPos(HWND_DESKTOP, x, dw_screen_height() - y);
 }
 /*
 * Create a container object to be packed.
 * Parameters:
 *       id: An ID to be used for getting the resource from the
 *           resource file.
 */
-HWND dw_container_new(ULONG id)
+HWND API dw_container_new(ULONG id)
 {
 	WindowData *blah = calloc(1, sizeof(WindowData));
 	HWND tmp = WinCreateWindow(HWND_OBJECT,
 							   WC_CONTAINER,
 							   NULL,
 * Create a tree object to be packed.
 * Parameters:
 *       id: An ID to be used for getting the resource from the
 *           resource file.
 */
-HWND dw_tree_new(ULONG id)
+HWND API dw_tree_new(ULONG id)
 {
 	CNRINFO cnrinfo;
 	WindowData *blah = calloc(1, sizeof(WindowData));
 	HWND tmp = WinCreateWindow(HWND_OBJECT,
 							   WC_CONTAINER,
 * Create a new static text window (widget) to be packed.
 * Parameters:
 *       text: The text to be display by the static text widget.
 *       id: An ID to be used with WinWindowFromID() or 0L.
 */
-HWND dw_text_new(char *text, ULONG id)
+HWND API dw_text_new(char *text, ULONG id)
 {
 	HWND tmp = WinCreateWindow(HWND_OBJECT,
 							   WC_STATIC,
 							   text,
 							   WS_VISIBLE | SS_TEXT,
 * Create a new status text window (widget) to be packed.
 * Parameters:
 *       text: The text to be display by the static text widget.
 *       id: An ID to be used with WinWindowFromID() or 0L.
 */
-HWND dw_status_text_new(char *text, ULONG id)
+HWND API dw_status_text_new(char *text, ULONG id)
 {
 	WindowData *blah = calloc(sizeof(WindowData), 1);
 	HWND tmp = WinCreateWindow(HWND_OBJECT,
 							   WC_STATIC,
 							   text,
 /*
 * Create a new Multiline Editbox window (widget) to be packed.
 * Parameters:
 *       id: An ID to be used with WinWindowFromID() or 0L.
 */
-HWND dw_mle_new(ULONG id)
+HWND API dw_mle_new(ULONG id)
 {
 	WindowData *blah = calloc(1, sizeof(WindowData));
 	HWND tmp = WinCreateWindow(HWND_OBJECT,
 							   WC_MLE,
 							   "",
 * Create a new Entryfield window (widget) to be packed.
 * Parameters:
 *       text: The default text to be in the entryfield widget.
 *       id: An ID to be used with WinWindowFromID() or 0L.
 */
-HWND dw_entryfield_new(char *text, ULONG id)
+HWND API dw_entryfield_new(char *text, ULONG id)
 {
 	WindowData *blah = calloc(1, sizeof(WindowData));
 	HWND tmp = WinCreateWindow(HWND_OBJECT,
 							   WC_ENTRYFIELD,
 * Create a new Entryfield (password) window (widget) to be packed.
 * Parameters:
 *       text: The default text to be in the entryfield widget.
 *       id: An ID to be used with WinWindowFromID() or 0L.
 */
-HWND dw_entryfield_password_new(char *text, ULONG id)
+HWND API dw_entryfield_password_new(char *text, ULONG id)
 {
 	WindowData *blah = calloc(1, sizeof(WindowData));
 	HWND tmp = WinCreateWindow(HWND_OBJECT,
 							   WC_ENTRYFIELD,
 							   text,
 * Create a new Combobox window (widget) to be packed.
 * Parameters:
 *       text: The default text to be in the combpbox widget.
 *       id: An ID to be used with WinWindowFromID() or 0L.
 */
-HWND dw_combobox_new(char *text, ULONG id)
+HWND API dw_combobox_new(char *text, ULONG id)
 {
 	WindowData *blah = calloc(1, sizeof(WindowData));
 	HWND tmp = WinCreateWindow(HWND_OBJECT,
 							   WC_COMBOBOX,
 							   text,
 * Create a new button window (widget) to be packed.
 * Parameters:
 *       text: The text to be display by the static text widget.
 *       id: An ID to be used with WinWindowFromID() or 0L.
 */
-HWND dw_button_new(char *text, ULONG id)
+HWND API dw_button_new(char *text, ULONG id)
 {
 	BubbleButton *bubble = calloc(sizeof(BubbleButton), 1);
 	HWND tmp = WinCreateWindow(HWND_OBJECT,
 							   WC_BUTTON,
 * Create a new bitmap button window (widget) to be packed.
 * Parameters:
 *       text: Bubble help text to be displayed.
 *       id: An ID of a bitmap in the resource file.
 */
-HWND dw_bitmapbutton_new(char *text, ULONG id)
+HWND API dw_bitmapbutton_new(char *text, ULONG id)
 {
 	char idbuf[256];
 	HWND tmp;
 	BubbleButton *bubble = calloc(sizeof(BubbleButton), 1);
 * Create a new spinbutton window (widget) to be packed.
 * Parameters:
 *       text: The text to be display by the static text widget.
 *       id: An ID to be used with WinWindowFromID() or 0L.
 */
-HWND dw_spinbutton_new(char *text, ULONG id)
+HWND API dw_spinbutton_new(char *text, ULONG id)
 {
 	WindowData *blah = calloc(sizeof(WindowData), 1);
 	HWND tmp = WinCreateWindow(HWND_OBJECT,
 							   WC_SPINBUTTON,
 							   text,
 * Create a new radiobutton window (widget) to be packed.
 * Parameters:
 *       text: The text to be display by the static text widget.
 *       id: An ID to be used with WinWindowFromID() or 0L.
 */
-HWND dw_radiobutton_new(char *text, ULONG id)
+HWND API dw_radiobutton_new(char *text, ULONG id)
 {
 	WindowData *blah = calloc(sizeof(WindowData), 1);
 	HWND tmp = WinCreateWindow(HWND_OBJECT,
 							   WC_BUTTON,
 							   text,
 * Parameters:
 *       vertical: TRUE or FALSE if slider is vertical.
 *       increments: Number of increments available.
 *       id: An ID to be used with WinWindowFromID() or 0L.
 */
-HWND dw_slider_new(int vertical, int increments, ULONG id)
+HWND API dw_slider_new(int vertical, int increments, ULONG id)
 {
 	WindowData *blah = calloc(1, sizeof(WindowData));
 	SLDCDATA sldcData = { 0, 0, 0, 0, 0 };
 	HWND tmp = WinCreateWindow(HWND_OBJECT,
 							   WC_SLIDER,
 /*
 * Create a new percent bar window (widget) to be packed.
 * Parameters:
 *       id: An ID to be used with WinWindowFromID() or 0L.
 */
-HWND dw_percent_new(ULONG id)
+HWND API dw_percent_new(ULONG id)
 {
 	WindowData *blah = calloc(1, sizeof(WindowData));
 	HWND tmp = WinCreateWindow(HWND_OBJECT,
 							   WC_SLIDER,
 							   "",
 * Create a new checkbox window (widget) to be packed.
 * Parameters:
 *       text: The text to be display by the static text widget.
 *       id: An ID to be used with WinWindowFromID() or 0L.
 */
-HWND dw_checkbox_new(char *text, ULONG id)
+HWND API dw_checkbox_new(char *text, ULONG id)
 {
 	BubbleButton *bubble = calloc(sizeof(BubbleButton), 1);
 	HWND tmp = WinCreateWindow(HWND_OBJECT,
 							   WC_BUTTON,
 							   text,
 * Create a new listbox window (widget) to be packed.
 * Parameters:
 *       id: An ID to be used with WinWindowFromID() or 0L.
 *       multi: Multiple select TRUE or FALSE.
 */
-HWND dw_listbox_new(ULONG id, int multi)
+HWND API dw_listbox_new(ULONG id, int multi)
 {
 	WindowData *blah = calloc(sizeof(WindowData), 1);
 	HWND tmp = WinCreateWindow(HWND_OBJECT,
 							   WC_LISTBOX,
 							   NULL,
 * Sets the icon used for a given window.
 * Parameters:
 *       handle: Handle to the window.
 *       id: An ID to be used to specify the icon.
 */
-void dw_window_set_icon(HWND handle, ULONG id)
+void API dw_window_set_icon(HWND handle, ULONG id)
 {
 	HPOINTER icon;
 	icon = WinLoadPointer(HWND_DESKTOP,NULLHANDLE,id);
 	WinSendMsg(handle, WM_SETICON, (MPARAM)icon, 0);
 * Sets the bitmap used for a given static window.
 * Parameters:
 *       handle: Handle to the window.
 *       id: An ID to be used to specify the icon.
 */
-void dw_window_set_bitmap(HWND handle, ULONG id)
+void API dw_window_set_bitmap(HWND handle, ULONG id)
 {
 	HBITMAP hbm;
 	HPS     hps = WinGetPS(handle);
 	hbm = GpiLoadBitmap(hps, NULLHANDLE, id, 0, 0);
 * Sets the text used for a given window.
 * Parameters:
 *       handle: Handle to the window.
 *       text: The text associsated with a given window.
 */
-void dw_window_set_text(HWND handle, char *text)
+void API dw_window_set_text(HWND handle, char *text)
 {
 	WinSetWindowText(handle, text);
 }
 /*
 * Parameters:
 *       handle: Handle to the window.
 * Returns:
 *       text: The text associsated with a given window.
 */
-char *dw_window_get_text(HWND handle)
+char * API dw_window_get_text(HWND handle)
 {
 	int len = WinQueryWindowTextLength(handle);
 	char *tempbuf = calloc(1, len + 2);
 	WinQueryWindowText(handle, len + 1, tempbuf);
 /*
 * Disables given window (widget).
 * Parameters:
 *       handle: Handle to the window.
 */
-void dw_window_disable(HWND handle)
+void API dw_window_disable(HWND handle)
 {
 	char tmpbuf[100];
 	if(dw_window_get_data(handle, "_dw_disabled"))
 		return;
 /*
 * Enables given window (widget).
 * Parameters:
 *       handle: Handle to the window.
 */
-void dw_window_enable(HWND handle)
+void API dw_window_enable(HWND handle)
 {
 	ULONG fore = (ULONG)dw_window_get_data(handle, "_dw_fore");
 	ULONG back = (ULONG)dw_window_get_data(handle, "_dw_back");
 	HWND hwnd = _find_entryfield(handle);
 * Gets the child window handle with specified ID.
 * Parameters:
 *       handle: Handle to the parent window.
 *       id: Integer ID of the child.
 */
-HWND dw_window_from_id(HWND handle, int id)
+HWND API dw_window_from_id(HWND handle, int id)
 {
 	HENUM henum;
 	HWND child;
 	char tmpbuf[100];
 *       height: Height in pixels of the item or -1 to be self determined.
 *       hsize: TRUE if the window (widget) should expand horizontally to fill space given.
 *       vsize: TRUE if the window (widget) should expand vertically to fill space given.
 *       pad: Number of pixels of padding around the item.
 */
-void dw_box_pack_end(HWND box, HWND item, int width, int height, int hsize, int vsize, int pad)
+void API dw_box_pack_end(HWND box, HWND item, int width, int height, int hsize, int vsize, int pad)
 {
 	Box *thisbox;
 	if(WinWindowFromID(box, FID_CLIENT))
 	{
 * Parameters:
 *          handle: Window (widget) handle.
 *          width: New width in pixels.
 *          height: New height in pixels.
 */
-void dw_window_set_usize(HWND handle, ULONG width, ULONG height)
+void API dw_window_set_usize(HWND handle, ULONG width, ULONG height)
 {
 	WinSetWindowPos(handle, NULLHANDLE, 0, 0, width, height, SWP_SHOW | SWP_SIZE);
 }
 /*
 * Returns the width of the screen.
 */
-int dw_screen_width(void)
+int API dw_screen_width(void)
 {
 	return WinQuerySysValue(HWND_DESKTOP,SV_CXSCREEN);
 }
 /*
 * Returns the height of the screen.
 */
-int dw_screen_height(void)
+int API dw_screen_height(void)
 {
 	return WinQuerySysValue(HWND_DESKTOP,SV_CYSCREEN);
 }
 /* This should return the current color depth */
-unsigned long dw_color_depth(void)
+unsigned long API dw_color_depth(void)
 {
 	HDC hdc = WinOpenWindowDC(HWND_DESKTOP);
 	long colors;
 	DevQueryCaps(hdc, CAPS_COLOR_BITCOUNT, 1, &colors);
 * Parameters:
 *          handle: Window (widget) handle.
 *          x: X location from the bottom left.
 *          y: Y location from the bottom left.
 */
-void dw_window_set_pos(HWND handle, ULONG x, ULONG y)
+void API dw_window_set_pos(HWND handle, ULONG x, ULONG y)
 {
 	int myy = _get_frame_height(handle) - (y + _get_height(handle));
 	WinSetWindowPos(handle, NULLHANDLE, x, myy, 0, 0, SWP_MOVE);
 }
 *          x: X location from the bottom left.
 *          y: Y location from the bottom left.
 *          width: Width of the widget.
 *          height: Height of the widget.
 */
-void dw_window_set_pos_size(HWND handle, ULONG x, ULONG y, ULONG width, ULONG height)
+void API dw_window_set_pos_size(HWND handle, ULONG x, ULONG y, ULONG width, ULONG height)
 {
 	int myy = _get_frame_height(handle) - (y + height);
 	WinSetWindowPos(handle, NULLHANDLE, x, myy, width, height, SWP_MOVE | SWP_SIZE | SWP_SHOW);
 }
 *          x: X location from the bottom left.
 *          y: Y location from the bottom left.
 *          width: Width of the widget.
 *          height: Height of the widget.
 */
-void dw_window_get_pos_size(HWND handle, ULONG *x, ULONG *y, ULONG *width, ULONG *height)
+void API dw_window_get_pos_size(HWND handle, ULONG *x, ULONG *y, ULONG *width, ULONG *height)
 {
 	SWP swp;
 	WinQueryWindowPos(handle, &swp);
 	if(x)
 		*x = swp.x;
 * Parameters:
 *          handle: Window (widget) handle.
 *          width: New width in pixels.
 *          height: New height in pixels.
 */
-void dw_window_set_style(HWND handle, ULONG style, ULONG mask)
+void API dw_window_set_style(HWND handle, ULONG style, ULONG mask)
 {
 	WinSetWindowBits(handle, QWL_STYLE, style, mask);
 }
 /*
 * Parameters:
 *          handle: Window (widget) handle.
 *          flags: Any additional page creation flags.
 *          front: If TRUE page is added at the beginning.
 */
-ULONG dw_notebook_page_new(HWND handle, ULONG flags, int front)
+unsigned long API dw_notebook_page_new(HWND handle, ULONG flags, int front)
 {
 	if(front)
 		return (ULONG)WinSendMsg(handle, BKM_INSERTPAGE, 0L,
 						  MPFROM2SHORT((BKA_STATUSTEXTON | BKA_AUTOPAGESIZE | BKA_MAJOR | flags), BKA_FIRST));
 	return (ULONG)WinSendMsg(handle, BKM_INSERTPAGE, 0L,
 * Remove a page from a notebook.
 * Parameters:
 *          handle: Handle to the notebook widget.
 *          pageid: ID of the page to be destroyed.
 */
-void dw_notebook_page_destroy(HWND handle, unsigned int pageid)
+void API dw_notebook_page_destroy(HWND handle, unsigned int pageid)
 {
 	WinSendMsg(handle, BKM_DELETEPAGE,
 			   MPFROMLONG(pageid),	(MPARAM)BKA_SINGLE);
 }
 /*
 * Queries the currently visible page ID.
 * Parameters:
 *          handle: Handle to the notebook widget.
 */
-unsigned int dw_notebook_page_query(HWND handle)
+unsigned int API dw_notebook_page_query(HWND handle)
 {
 	return (int)WinSendMsg(handle, BKM_QUERYPAGEID,0L, MPFROM2SHORT(BKA_TOP, BKA_MAJOR));
 }
 /*
 * Sets the currently visibale page ID.
 * Parameters:
 *          handle: Handle to the notebook widget.
 *          pageid: ID of the page to be made visible.
 */
-void dw_notebook_page_set(HWND handle, unsigned int pageid)
+void API dw_notebook_page_set(HWND handle, unsigned int pageid)
 {
 	WinSendMsg(handle, BKM_TURNTOPAGE, MPFROMLONG(pageid), 0L);
 }
 /*
 * Parameters:
 *          handle: Notebook handle.
 *          pageid: Page ID of the tab to set.
 *          text: Pointer to the text to set.
 */
-void dw_notebook_page_set_text(HWND handle, ULONG pageid, char *text)
+void API dw_notebook_page_set_text(HWND handle, ULONG pageid, char *text)
 {
 	WinSendMsg(handle, BKM_SETTABTEXT,
 			   MPFROMLONG(pageid),	MPFROMP(text));
 }
 * Parameters:
 *          handle: Notebook handle.
 *          pageid: Page ID of the tab to set.
 *          text: Pointer to the text to set.
 */
-void dw_notebook_page_set_status_text(HWND handle, ULONG pageid, char *text)
+void API dw_notebook_page_set_status_text(HWND handle, ULONG pageid, char *text)
 {
 	WinSendMsg(handle, BKM_SETSTATUSLINETEXT,
 			   MPFROMLONG(pageid),	MPFROMP(text));
 }
 * Parameters:
 *          handle: Handle to the notebook to be packed.
 *          pageid: Page ID in the notebook which is being packed.
 *          page: Box handle to be packed.
 */
-void dw_notebook_pack(HWND handle, ULONG pageid, HWND page)
+void API dw_notebook_pack(HWND handle, ULONG pageid, HWND page)
 {
 	HWND tmpbox = dw_box_new(BOXVERT, 0);
 	dw_box_pack_start(tmpbox, page, 0, 0, TRUE, TRUE, 0);
 	WinSubclassWindow(tmpbox, _wndproc);
 * Appends the specified text to the listbox's (or combobox) entry list.
 * Parameters:
 *          handle: Handle to the listbox to be appended to.
 *          text: Text to append into listbox.
 */
-void dw_listbox_append(HWND handle, char *text)
+void API dw_listbox_append(HWND handle, char *text)
 {
 	WinSendMsg(handle,
 			   LM_INSERTITEM,
 			   MPFROMSHORT(LIT_END),
 			   MPFROMP(text));
 /*
 * Clears the listbox's (or combobox) list of all entries.
 * Parameters:
 *          handle: Handle to the listbox to be cleared.
 */
-void dw_listbox_clear(HWND handle)
+void API dw_listbox_clear(HWND handle)
 {
 	WinSendMsg(handle,
 			   LM_DELETEALL, 0L, 0L);
 }
 /*
 * Returns the listbox's item count.
 * Parameters:
 *          handle: Handle to the listbox to be cleared.
 */
-int dw_listbox_count(HWND handle)
+int API dw_listbox_count(HWND handle)
 {
 	return (int)WinSendMsg(handle,
 						   LM_QUERYITEMCOUNT,0L, 0L);
 }
 * Sets the topmost item in the viewport.
 * Parameters:
 *          handle: Handle to the listbox to be cleared.
 *          top: Index to the top item.
 */
-void dw_listbox_set_top(HWND handle, int top)
+void API dw_listbox_set_top(HWND handle, int top)
 {
 	WinSendMsg(handle,
 			   LM_SETTOPINDEX,
 			   MPFROMSHORT(top),
 			   0L);
 *          handle: Handle to the listbox to be queried.
 *          index: Index into the list to be queried.
 *          buffer: Buffer where text will be copied.
 *          length: Length of the buffer (including NULL).
 */
-void dw_listbox_query_text(HWND handle, unsigned int index, char *buffer, unsigned int length)
+void API dw_listbox_query_text(HWND handle, unsigned int index, char *buffer, unsigned int length)
 {
 	WinSendMsg(handle, LM_QUERYITEMTEXT, MPFROM2SHORT(index, length), (MPARAM)buffer);
 }
 /*
 * Parameters:
 *          handle: Handle to the listbox to be queried.
 *          index: Index into the list to be queried.
 *          buffer: Buffer where text will be copied.
 */
-void dw_listbox_set_text(HWND handle, unsigned int index, char *buffer)
+void API dw_listbox_set_text(HWND handle, unsigned int index, char *buffer)
 {
 	WinSendMsg(handle, LM_SETITEMTEXT, MPFROMSHORT(index), (MPARAM)buffer);
 }
 /*
 * Returns the index to the item in the list currently selected.
 * Parameters:
 *          handle: Handle to the listbox to be queried.
 */
-unsigned int dw_listbox_selected(HWND handle)
+unsigned int API dw_listbox_selected(HWND handle)
 {
 		return (unsigned int)WinSendMsg(handle,
 										LM_QUERYSELECTION,
 										MPFROMSHORT(LIT_CURSOR),
 										0);
 * Returns the index to the current selected item or -1 when done.
 * Parameters:
 *          handle: Handle to the listbox to be queried.
 *          where: Either the previous return or -1 to restart.
 */
-int dw_listbox_selected_multi(HWND handle, int where)
+int API dw_listbox_selected_multi(HWND handle, int where)
 {
 	int place = where;
 	if(where == -1)
 		place = LIT_FIRST;
 * Parameters:
 *          handle: Handle to the listbox to be set.
 *          index: Item index.
 *          state: TRUE if selected FALSE if unselected.
 */
-void dw_listbox_select(HWND handle, int index, int state)
+void API dw_listbox_select(HWND handle, int index, int state)
 {
 	char tmpbuf[100];
 	WinSendMsg(handle, LM_SELECTITEM, MPFROMSHORT(index), (MPARAM)state);
 * Deletes the item with given index from the list.
 * Parameters:
 *          handle: Handle to the listbox to be set.
 *          index: Item index.
 */
-void dw_listbox_delete(HWND handle, int index)
+void API dw_listbox_delete(HWND handle, int index)
 {
 	WinSendMsg(handle, LM_DELETEITEM, MPFROMSHORT(index), 0);
 }
 /*
 * Parameters:
 *          handle: Handle to the MLE to be queried.
 *          buffer: Text buffer to be imported.
 *          startpoint: Point to start entering text.
 */
-unsigned int dw_mle_import(HWND handle, char *buffer, int startpoint)
+unsigned int API dw_mle_import(HWND handle, char *buffer, int startpoint)
 {
 	unsigned long point = startpoint;
 	PBYTE mlebuf;
 	/* Work around 64K limit */
 *          handle: Handle to the MLE to be queried.
 *          buffer: Text buffer to be exported.
 *          startpoint: Point to start grabbing text.
 *          length: Amount of text to be grabbed.
 */
-void dw_mle_export(HWND handle, char *buffer, int startpoint, int length)
+void API dw_mle_export(HWND handle, char *buffer, int startpoint, int length)
 {
 	PBYTE mlebuf;
 	/* Work around 64K limit */
 	if(!DosAllocMem((PPVOID) &mlebuf, 65535, PAG_COMMIT | PAG_READ | PAG_WRITE | OBJ_TILE))
 * Parameters:
 *          handle: Handle to the MLE to be queried.
 *          bytes: A pointer to a variable to return the total bytes.
 *          lines: A pointer to a variable to return the number of lines.
 */
-void dw_mle_query(HWND handle, unsigned long *bytes, unsigned long *lines)
+void API dw_mle_query(HWND handle, unsigned long *bytes, unsigned long *lines)
 {
 	if(bytes)
 		*bytes = (unsigned long)WinSendMsg(handle, MLM_QUERYTEXTLENGTH, 0, 0);
 	if(lines)
 		*lines = (unsigned long)WinSendMsg(handle, MLM_QUERYLINECOUNT, 0, 0);
 * Parameters:
 *          handle: Handle to the MLE to be deleted from.
 *          startpoint: Point to start deleting text.
 *          length: Amount of text to be deleted.
 */
-void dw_mle_delete(HWND handle, int startpoint, int length)
+void API dw_mle_delete(HWND handle, int startpoint, int length)
 {
 	char *buf = malloc(length+1);
 	int z, dellen = length;
 	dw_mle_export(handle, buf, startpoint, length);
 /*
 * Clears all text from an MLE box.
 * Parameters:
 *          handle: Handle to the MLE to be cleared.
 */
-void dw_mle_clear(HWND handle)
+void API dw_mle_clear(HWND handle)
 {
 	unsigned long bytes;
 	dw_mle_query(handle, &bytes, NULL);
 * Sets the visible line of an MLE box.
 * Parameters:
 *          handle: Handle to the MLE to be positioned.
 *          line: Line to be visible.
 */
-void dw_mle_set_visible(HWND handle, int line)
+void API dw_mle_set_visible(HWND handle, int line)
 {
 	int tmppnt = (int)WinSendMsg(handle, MLM_CHARFROMLINE, MPFROMLONG(line), 0);
 	WinSendMsg(handle, MLM_SETSEL, MPFROMLONG(tmppnt), MPFROMLONG(tmppnt));
 }
 * Sets the editablity of an MLE box.
 * Parameters:
 *          handle: Handle to the MLE.
 *          state: TRUE if it can be edited, FALSE for readonly.
 */
-void dw_mle_set_editable(HWND handle, int state)
+void API dw_mle_set_editable(HWND handle, int state)
 {
 	WinSendMsg(handle, MLM_SETREADONLY, MPFROMLONG(state ? FALSE : TRUE), 0);
 }
 /*
 * Sets the word wrap state of an MLE box.
 * Parameters:
 *          handle: Handle to the MLE.
 *          state: TRUE if it wraps, FALSE if it doesn't.
 */
-void dw_mle_set_word_wrap(HWND handle, int state)
+void API dw_mle_set_word_wrap(HWND handle, int state)
 {
 	WinSendMsg(handle, MLM_SETWRAP, MPFROMLONG(state), 0);
 }
 /*
 * Sets the current cursor position of an MLE box.
 * Parameters:
 *          handle: Handle to the MLE to be positioned.
 *          point: Point to position cursor.
 */
-void dw_mle_set(HWND handle, int point)
+void API dw_mle_set(HWND handle, int point)
 {
 	WinSendMsg(handle, MLM_SETSEL, MPFROMLONG(point), MPFROMLONG(point));
 }
 /*
 *          handle: Handle to the MLE to be cleared.
 *          text: Text to search for.
 *          point: Start point of search.
 *          flags: Search specific flags.
 */
-int dw_mle_search(HWND handle, char *text, int point, unsigned long flags)
+int API dw_mle_search(HWND handle, char *text, int point, unsigned long flags)
 {
 	MLE_SEARCHDATA msd;
 	/* This code breaks with structure packing set to 1 (/Sp1 in VAC)
 	 * if this is needed we need to add a pragma here.
 /*
 * Stops redrawing of an MLE box.
 * Parameters:
 *          handle: Handle to the MLE to freeze.
 */
-void dw_mle_freeze(HWND handle)
+void API dw_mle_freeze(HWND handle)
 {
 	WinSendMsg(handle, MLM_DISABLEREFRESH, 0, 0);
 }
 /*
 * Resumes redrawing of an MLE box.
 * Parameters:
 *          handle: Handle to the MLE to thaw.
 */
-void dw_mle_thaw(HWND handle)
+void API dw_mle_thaw(HWND handle)
 {
 	WinSendMsg(handle, MLM_ENABLEREFRESH, 0, 0);
 }
 /*
 * Returns the range of the percent bar.
 * Parameters:
 *          handle: Handle to the percent bar to be queried.
 */
-unsigned int dw_percent_query_range(HWND handle)
+unsigned int API dw_percent_query_range(HWND handle)
 {
 	return SHORT2FROMMP(WinSendMsg(handle, SLM_QUERYSLIDERINFO, MPFROM2SHORT(SMA_SLIDERARMPOSITION,SMA_RANGEVALUE), 0));
 }
 /*
 * Sets the percent bar position.
 * Parameters:
 *          handle: Handle to the percent bar to be set.
 *          position: Position of the percent bar withing the range.
 */
-void dw_percent_set_pos(HWND handle, unsigned int position)
+void API dw_percent_set_pos(HWND handle, unsigned int position)
 {
 	_dw_int_set(handle, position);
 	WinSendMsg(handle, SLM_SETSLIDERINFO, MPFROM2SHORT(SMA_SLIDERARMPOSITION,SMA_RANGEVALUE), (MPARAM)position);
 }
 /*
 * Returns the position of the slider.
 * Parameters:
 *          handle: Handle to the slider to be queried.
 */
-unsigned int dw_slider_query_pos(HWND handle)
+unsigned int API dw_slider_query_pos(HWND handle)
 {
 	return (unsigned int)WinSendMsg(handle, SLM_QUERYSLIDERINFO, MPFROM2SHORT(SMA_SLIDERARMPOSITION, SMA_INCREMENTVALUE), 0);
 }
 /*
 * Sets the slider position.
 * Parameters:
 *          handle: Handle to the slider to be set.
 *          position: Position of the slider withing the range.
 */
-void dw_slider_set_pos(HWND handle, unsigned int position)
+void API dw_slider_set_pos(HWND handle, unsigned int position)
 {
 	dw_window_set_data(handle, "_dw_slider_value", (void *)position);
 	WinSendMsg(handle, SLM_SETSLIDERINFO, MPFROM2SHORT(SMA_SLIDERARMPOSITION, SMA_INCREMENTVALUE), (MPARAM)position);
 }
 * Sets the spinbutton value.
 * Parameters:
 *          handle: Handle to the spinbutton to be set.
 *          position: Current value of the spinbutton.
 */
-void dw_spinbutton_set_pos(HWND handle, long position)
+void API dw_spinbutton_set_pos(HWND handle, long position)
 {
 	WinSendMsg(handle, SPBM_SETCURRENTVALUE, MPFROMLONG((long)position), 0L);
 }
 /*
 * Parameters:
 *          handle: Handle to the spinbutton to be set.
 *          upper: Upper limit.
 *          lower: Lower limit.
 */
-void dw_spinbutton_set_limits(HWND handle, long upper, long lower)
+void API dw_spinbutton_set_limits(HWND handle, long upper, long lower)
 {
 	WinSendMsg(handle, SPBM_SETLIMITS, MPFROMLONG(upper), MPFROMLONG(lower));
 }
 /*
 * Sets the entryfield character limit.
 * Parameters:
 *          handle: Handle to the spinbutton to be set.
 *          limit: Number of characters the entryfield will take.
 */
-void dw_entryfield_set_limit(HWND handle, ULONG limit)
+void API dw_entryfield_set_limit(HWND handle, ULONG limit)
 {
 	WinSendMsg(handle, EM_SETTEXTLIMIT, (MPARAM)limit, (MPARAM)0);
 }
 /*
 * Returns the current value of the spinbutton.
 * Parameters:
 *          handle: Handle to the spinbutton to be queried.
 */
-long dw_spinbutton_query(HWND handle)
+long API dw_spinbutton_query(HWND handle)
 {
 	long tmpval = 0L;
 	WinSendMsg(handle, SPBM_QUERYVALUE, (MPARAM)&tmpval,0L);
 return tmpval;
 /*
 * Returns the state of the checkbox.
 * Parameters:
 *          handle: Handle to the checkbox to be queried.
 */
-int dw_checkbox_query(HWND handle)
+int API dw_checkbox_query(HWND handle)
 {
 	return (int)WinSendMsg(handle,BM_QUERYCHECK,0,0);
 }
 /*
 * Sets the state of the checkbox.
 * Parameters:
 *          handle: Handle to the checkbox to be queried.
 *          value: TRUE for checked, FALSE for unchecked.
 */
-void dw_checkbox_set(HWND handle, int value)
+void API dw_checkbox_set(HWND handle, int value)
 {
 	WinSendMsg(handle,BM_SETCHECK,MPFROMSHORT(value),0);
 }
 /*
 *          title: The text title of the entry.
 *          icon: Handle to coresponding icon.
 *          parent: Parent handle or 0 if root.
 *          itemdata: Item specific data.
 */
-HWND dw_tree_insert_after(HWND handle, HWND item, char *title, unsigned long icon, HWND parent, void *itemdata)
+HWND API dw_tree_insert_after(HWND handle, HWND item, char *title, unsigned long icon, HWND parent, void *itemdata)
 {
 	ULONG        cbExtra;
 	PCNRITEM     pci;
 	RECORDINSERT ri;
 *          title: The text title of the entry.
 *          icon: Handle to coresponding icon.
 *          parent: Parent handle or 0 if root.
 *          itemdata: Item specific data.
 */
-HWND dw_tree_insert(HWND handle, char *title, unsigned long icon, HWND parent, void *itemdata)
+HWND API dw_tree_insert(HWND handle, char *title, unsigned long icon, HWND parent, void *itemdata)
 {
 	return dw_tree_insert_after(handle, (HWND)CMA_END, title, icon, parent, itemdata);
 }
 /*
 *          handle: Handle to the tree containing the item.
 *          item: Handle of the item to be modified.
 *          title: The text title of the entry.
 *          icon: Handle to coresponding icon.
 */
-void dw_tree_set(HWND handle, HWND item, char *title, unsigned long icon)
+void API dw_tree_set(HWND handle, HWND item, char *title, unsigned long icon)
 {
 	PCNRITEM pci = (PCNRITEM)item;
 	if(!pci)
 		return;
 * Parameters:
 *          handle: Handle to the tree containing the item.
 *          item: Handle of the item to be modified.
 *          itemdata: User defined data to be associated with item.
 */
-void dw_tree_set_data(HWND handle, HWND item, void *itemdata)
+void API dw_tree_set_data(HWND handle, HWND item, void *itemdata)
 {
 	PCNRITEM pci = (PCNRITEM)item;
 	if(!pci)
 		return;
 * Sets this item as the active selection.
 * Parameters:
 *       handle: Handle to the tree window (widget) to be selected.
 *       item: Handle to the item to be selected.
 */
-void dw_tree_item_select(HWND handle, HWND item)
+void API dw_tree_item_select(HWND handle, HWND item)
 {
 	PRECORDCORE pCore = WinSendMsg(handle, CM_QUERYRECORD, (MPARAM)0L, MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
 	while(pCore)
 	{
 /*
 * Removes all nodes from a tree.
 * Parameters:
 *       handle: Handle to the window (widget) to be cleared.
 */
-void dw_tree_clear(HWND handle)
+void API dw_tree_clear(HWND handle)
 {
 	WinSendMsg(handle, CM_REMOVERECORD, (MPARAM)0L, MPFROM2SHORT(0, CMA_INVALIDATE | CMA_FREE));
 }
 /*
 * Expands a node on a tree.
 * Parameters:
 *       handle: Handle to the tree window (widget).
 *       item: Handle to node to be expanded.
 */
-void dw_tree_expand(HWND handle, HWND item)
+void API dw_tree_expand(HWND handle, HWND item)
 {
 	WinSendMsg(handle, CM_EXPANDTREE, MPFROMP(item), 0);
 }
 /*
 * Collapses a node on a tree.
 * Parameters:
 *       handle: Handle to the tree window (widget).
 *       item: Handle to node to be collapsed.
 */
-void dw_tree_collapse(HWND handle, HWND item)
+void API dw_tree_collapse(HWND handle, HWND item)
 {
 	WinSendMsg(handle, CM_COLLAPSETREE, MPFROMP(item), 0);
 }
 /*
 * Removes a node from a tree.
 * Parameters:
 *       handle: Handle to the window (widget) to be cleared.
 *       item: Handle to node to be deleted.
 */
-void dw_tree_delete(HWND handle, HWND item)
+void API dw_tree_delete(HWND handle, HWND item)
 {
 	PCNRITEM     pci = (PCNRITEM)item;
 	if(!item)
 		return;
 *          titles: An array of strings with column text titles.
 *          count: The number of columns (this should match the arrays).
 *          separator: The column number that contains the main separator.
 *                     (this item may only be used in OS/2)
 */
-int dw_container_setup(HWND handle, unsigned long *flags, char **titles, int count, int separator)
+int API dw_container_setup(HWND handle, unsigned long *flags, char **titles, int count, int separator)
 {
 	PFIELDINFO details, first, left = NULL;
 	FIELDINFOINSERT detin;
 	CNRINFO cnri;
 	int z;
 *          handle: Handle to the container to be configured.
 *          flags: An array of unsigned longs with column flags.
 *          titles: An array of strings with column text titles.
 *          count: The number of columns (this should match the arrays).
 */
-int dw_filesystem_setup(HWND handle, unsigned long *flags, char **titles, int count)
+int API dw_filesystem_setup(HWND handle, unsigned long *flags, char **titles, int count)
 {
 	char **newtitles = malloc(sizeof(char *) * (count + 2));
 	unsigned long *newflags = malloc(sizeof(unsigned long) * (count + 2));
 	newtitles[0] = "Icon";
 *          module: Handle to module (DLL) in OS/2 and Windows.
 *          id: A unsigned long id int the resources on OS/2 and
 *              Windows, on GTK this is converted to a pointer
 *              to an embedded XPM.
 */
-unsigned long dw_icon_load(unsigned long module, unsigned long id)
+unsigned long API dw_icon_load(unsigned long module, unsigned long id)
 {
 	return WinLoadPointer(HWND_DESKTOP,module,id);
 }
 /*
 * Frees a loaded resource in OS/2 and Windows.
 * Parameters:
 *          handle: Handle to icon returned by dw_icon_load().
 */
-void dw_icon_free(unsigned long handle)
+void API dw_icon_free(unsigned long handle)
 {
 	WinDestroyPointer(handle);
 }
 /*
 * Allocates memory used to populate a container.
 * Parameters:
 *          handle: Handle to the container window (widget).
 *          rowcount: The number of items to be populated.
 */
-void *dw_container_alloc(HWND handle, int rowcount)
+void * API dw_container_alloc(HWND handle, int rowcount)
 {
 	WindowData *wd = (WindowData *)WinQueryWindowPtr(handle, QWP_USER);
 	ULONG *flags = wd ? wd->data : 0;
 	int z, size = 0, totalsize, count = 0;
 	PRECORDCORE temp;
 *          pointer: Pointer to the allocated memory in dw_container_alloc().
 *          column: Zero based column of data being set.
 *          row: Zero based row of data being set.
 *          data: Pointer to the data to be added.
 */
-void dw_container_set_item(HWND handle, void *pointer, int column, int row, void *data)
+void API dw_container_set_item(HWND handle, void *pointer, int column, int row, void *data)
 {
 	ContainerInfo *ci = (ContainerInfo *)pointer;
 	if(!ci)
 		return;
 *          handle: Handle to the container window (widget).
 *          column: Zero based column of data being set.
 *          row: Zero based row of data being set.
 *          data: Pointer to the data to be added.
 */
-void dw_container_change_item(HWND handle, int column, int row, void *data)
+void API dw_container_change_item(HWND handle, int column, int row, void *data)
 {
 	PRECORDCORE pCore = WinSendMsg(handle, CM_QUERYRECORD, (MPARAM)0L, MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
 	int count = 0;
 	while(pCore)
 *          pointer: Pointer to the allocated memory in dw_container_alloc().
 *          column: Zero based column of data being set.
 *          row: Zero based row of data being set.
 *          data: Pointer to the data to be added.
 */
-void dw_filesystem_set_file(HWND handle, void *pointer, int row, char *filename, unsigned long icon)
+void API dw_filesystem_set_file(HWND handle, void *pointer, int row, char *filename, unsigned long icon)
 {
 	dw_container_set_item(handle, pointer, 0, row, (void *)&icon);
 	dw_container_set_item(handle, pointer, 1, row, (void *)&filename);
 }
 *          pointer: Pointer to the allocated memory in dw_container_alloc().
 *          column: Zero based column of data being set.
 *          row: Zero based row of data being set.
 *          data: Pointer to the data to be added.
 */
-void dw_filesystem_set_item(HWND handle, void *pointer, int column, int row, void *data)
+void API dw_filesystem_set_item(HWND handle, void *pointer, int column, int row, void *data)
 {
 	dw_container_set_item(handle, pointer, column + 2, row, data);
 }
 /*
 * Parameters:
 *          handle: Handle to window (widget) of container.
 *          column: Zero based column of width being set.
 *          width: Width of column in pixels.
 */
-void dw_container_set_column_width(HWND handle, int column, int width)
+void API dw_container_set_column_width(HWND handle, int column, int width)
 {
 }
 /*
 * Sets the title of a row in the container.
 * Parameters:
 *          pointer: Pointer to the allocated memory in dw_container_alloc().
 *          row: Zero based row of data being set.
 *          title: String title of the item.
 */
-void dw_container_set_row_title(void *pointer, int row, char *title)
+void API dw_container_set_row_title(void *pointer, int row, char *title)
 {
 	ContainerInfo *ci = (ContainerInfo *)pointer;
 	PRECORDCORE temp;
 	int z, currentcount;
 	CNRINFO cnr;
 * Parameters:
 *          handle: Handle to the container window (widget).
 *          pointer: Pointer to the allocated memory in dw_container_alloc().
 *          rowcount: The number of rows to be inserted.
 */
-void dw_container_insert(HWND handle, void *pointer, int rowcount)
+void API dw_container_insert(HWND handle, void *pointer, int rowcount)
 {
 	RECORDINSERT recin;
 	ContainerInfo *ci = (ContainerInfo *)pointer;
 	int z;
 * Removes all rows from a container.
 * Parameters:
 *       handle: Handle to the window (widget) to be cleared.
 *       redraw: TRUE to cause the container to redraw immediately.
 */
-void dw_container_clear(HWND handle, int redraw)
+void API dw_container_clear(HWND handle, int redraw)
 {
 	int z = 0;
 	while((int)WinSendMsg(handle, CM_REMOVERECORD, (MPARAM)0L, MPFROM2SHORT(0, (redraw ? CMA_INVALIDATE : 0) | CMA_FREE)) == -1)
 	{
 * Removes the first x rows from a container.
 * Parameters:
 *       handle: Handle to the window (widget) to be deleted from.
 *       rowcount: The number of rows to be deleted.
 */
-void dw_container_delete(HWND handle, int rowcount)
+void API dw_container_delete(HWND handle, int rowcount)
 {
 	RECORDCORE *last, **prc = malloc(sizeof(RECORDCORE *) * rowcount);
 	int current = 1, z;
 	prc[0] = last = (RECORDCORE *)WinSendMsg(handle, CM_QUERYRECORD, (MPARAM)0L, MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
 *       handle: Handle to the window (widget) to be scrolled.
 *       direction: DW_SCROLL_UP, DW_SCROLL_DOWN, DW_SCROLL_TOP or
 *                  DW_SCROLL_BOTTOM. (rows is ignored for last two)
 *       rows: The number of rows to be scrolled.
 */
-void dw_container_scroll(HWND handle, int direction, long rows)
+void API dw_container_scroll(HWND handle, int direction, long rows)
 {
 	switch(direction)
 	{
 	case DW_SCROLL_TOP:
 		WinSendMsg(handle, CM_SCROLLWINDOW, MPFROMSHORT(CMA_VERTICAL), MPFROMLONG(-10000000));
 /*
 * Removes all rows from a container.
 * Parameters:
 *       handle: Handle to the window (widget) to be cleared.
 */
-void dw_container_set_view(HWND handle, unsigned long flags, int iconwidth, int iconheight)
+void API dw_container_set_view(HWND handle, unsigned long flags, int iconwidth, int iconheight)
 {
 	CNRINFO cnrinfo;
 	cnrinfo.flWindowAttr = flags;
 	cnrinfo.slBitmapOrIcon.cx = iconwidth;
 *       handle: Handle to the window (widget) to be queried.
 *       flags: If this parameter is DW_CRA_SELECTED it will only
 *              return items that are currently selected.  Otherwise
 *              it will return all records in the container.
 */
-char *dw_container_query_start(HWND handle, unsigned long flags)
+char * API dw_container_query_start(HWND handle, unsigned long flags)
 {
 	pCore = WinSendMsg(handle, CM_QUERYRECORD, (MPARAM)0L, MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
 	if(pCore)
 	{
 		if(flags)
 *       handle: Handle to the window (widget) to be queried.
 *       flags: If this parameter is DW_CRA_SELECTED it will only
 *              return items that are currently selected.  Otherwise
 *              it will return all records in the container.
 */
-char *dw_container_query_next(HWND handle, unsigned long flags)
+char * API dw_container_query_next(HWND handle, unsigned long flags)
 {
 	pCore = WinSendMsg(handle, CM_QUERYRECORD, (MPARAM)pCore, MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
 	if(pCore)
 	{
 		if(flags)
 * Cursors the item with the text speficied, and scrolls to that item.
 * Parameters:
 *       handle: Handle to the window (widget) to be queried.
 *       text:  Text usually returned by dw_container_query().
 */
-void dw_container_cursor(HWND handle, char *text)
+void API dw_container_cursor(HWND handle, char *text)
 {
 	RECTL viewport, item;
 	pCore = WinSendMsg(handle, CM_QUERYRECORD, (MPARAM)0L, MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
 	while(pCore)
 * Deletes the item with the text speficied.
 * Parameters:
 *       handle: Handle to the window (widget).
 *       text:  Text usually returned by dw_container_query().
 */
-void dw_container_delete_row(HWND handle, char *text)
+void API dw_container_delete_row(HWND handle, char *text)
 {
 	PRECORDCORE pCore = WinSendMsg(handle, CM_QUERYRECORD, (MPARAM)0L, MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
 	while(pCore)
 	{
 /*
 * Optimizes the column widths so that all data is visible.
 * Parameters:
 *       handle: Handle to the window (widget) to be optimized.
 */
-void dw_container_optimize(HWND handle)
+void API dw_container_optimize(HWND handle)
 {
 	WindowData *blah = (WindowData *)WinQueryWindowPtr(handle, QWP_USER);
 	RECTL item;
 	PRECORDCORE pCore = NULL;
 	int max = 0;
 * Parameters:
 *       id: An id to be used with dw_window_from_id.
 * Returns:
 *       A handle to the widget or NULL on failure.
 */
-HWND dw_render_new(unsigned long id)
+HWND API dw_render_new(unsigned long id)
 {
 	HWND hwndframe = WinCreateWindow(HWND_OBJECT,
 									 WC_FRAME,
 									 NULL,
 									 WS_VISIBLE |
 * Parameters:
 *       red: red value.
 *       green: green value.
 *       blue: blue value.
 */
-void dw_color_foreground_set(unsigned long value)
+void API dw_color_foreground_set(unsigned long value)
 {
 	_foreground = DW_RED_VALUE(value) << 16 | DW_GREEN_VALUE(value) << 8 | DW_BLUE_VALUE(value);
 }
 /* Sets the current background drawing color.
 * Parameters:
 *       red: red value.
 *       green: green value.
 *       blue: blue value.
 */
-void dw_color_background_set(unsigned long value)
+void API dw_color_background_set(unsigned long value)
 {
 	_background = DW_RED_VALUE(value) << 16 | DW_GREEN_VALUE(value) << 8 | DW_BLUE_VALUE(value);
 }
 HPS _set_hps(HPS hps)
 *       handle: Handle to the window.
 *       pixmap: Handle to the pixmap. (choose only one of these)
 *       x: X coordinate.
 *       y: Y coordinate.
 */
-void dw_draw_point(HWND handle, HPIXMAP pixmap, int x, int y)
+void API dw_draw_point(HWND handle, HPIXMAP pixmap, int x, int y)
 {
 	HPS hps;
 	int height;
 	POINTL ptl;
 *       x1: First X coordinate.
 *       y1: First Y coordinate.
 *       x2: Second X coordinate.
 *       y2: Second Y coordinate.
 */
-void dw_draw_line(HWND handle, HPIXMAP pixmap, int x1, int y1, int x2, int y2)
+void API dw_draw_line(HWND handle, HPIXMAP pixmap, int x1, int y1, int x2, int y2)
 {
 	HPS hps;
 	int height;
 	POINTL ptl[2];
 *       pixmap: Handle to the pixmap. (choose only one of these)
 *       x: X coordinate.
 *       y: Y coordinate.
 *       text: Text to be displayed.
 */
-void dw_draw_text(HWND handle, HPIXMAP pixmap, int x, int y, char *text)
+void API dw_draw_text(HWND handle, HPIXMAP pixmap, int x, int y, char *text)
 {
 	HPS hps;
 	int size = 9, z, height;
 	RECTL rcl;
 	char fontname[128];
 *       pixmap: Handle to the pixmap. (choose only one of these)
 *       text: Text to be queried.
 *       width: Pointer to a variable to be filled in with the width.
 *       height Pointer to a variable to be filled in with the height.
 */
-void dw_font_text_extents(HWND handle, HPIXMAP pixmap, char *text, int *width, int *height)
+void API dw_font_text_extents(HWND handle, HPIXMAP pixmap, char *text, int *width, int *height)
 {
 	HPS hps;
 	POINTL aptl[TXTBOX_COUNT];
 	if(handle)
 *       x: X coordinate.
 *       y: Y coordinate.
 *       width: Width of rectangle.
 *       height: Height of rectangle.
 */
-void dw_draw_rect(HWND handle, HPIXMAP pixmap, int fill, int x, int y, int width, int height)
+void API dw_draw_rect(HWND handle, HPIXMAP pixmap, int fill, int x, int y, int width, int height)
 {
 	HPS hps;
 	int thisheight;
 	POINTL ptl[2];
 }
 /* Call this after drawing to the screen to make sure
 * anything you have drawn is visible.
 */
-void dw_flush(void)
+void API dw_flush(void)
 {
 }
 /*
 * Creates a pixmap with given parameters.
 *       height: Height of the pixmap in pixels.
 *       depth: Color depth of the pixmap.
 * Returns:
 *       A handle to a pixmap or NULL on failure.
 */
-HPIXMAP dw_pixmap_new(HWND handle, unsigned long width, unsigned long height, int depth)
+HPIXMAP API dw_pixmap_new(HWND handle, unsigned long width, unsigned long height, int depth)
 {
 	BITMAPINFOHEADER bmih;
 	SIZEL sizl = { 0, 0 };
 	HPIXMAP pixmap;
 	HDC hdc;
 *       handle: Window handle the pixmap is associated with.
 *       id: Resource ID associated with requested pixmap.
 * Returns:
 *       A handle to a pixmap or NULL on failure.
 */
-HPIXMAP dw_pixmap_grab(HWND handle, ULONG id)
+HPIXMAP API dw_pixmap_grab(HWND handle, ULONG id)
 {
 	BITMAPINFOHEADER bmih;
 	SIZEL sizl = { 0, 0 };
 	HPIXMAP pixmap;
 	HDC hdc;
 * Destroys an allocated pixmap.
 * Parameters:
 *       pixmap: Handle to a pixmap returned by
 *               dw_pixmap_new..
 */
-void dw_pixmap_destroy(HPIXMAP pixmap)
+void API dw_pixmap_destroy(HPIXMAP pixmap)
 {
 	GpiSetBitmap(pixmap->hps, NULLHANDLE);
 	GpiDeleteBitmap(pixmap->hbm);
 	GpiAssociate(pixmap->hps, NULLHANDLE);
 	GpiDestroyPS(pixmap->hps);
 *       src: Source window handle.
 *       srcp: Source pixmap. (choose only one).
 *       xsrc: X coordinate of source.
 *       ysrc: Y coordinate of source.
 */
-void dw_pixmap_bitblt(HWND dest, HPIXMAP destp, int xdest, int ydest, int width, int height, HWND src, HPIXMAP srcp, int xsrc, int ysrc)
+void API dw_pixmap_bitblt(HWND dest, HPIXMAP destp, int xdest, int ydest, int width, int height, HWND src, HPIXMAP srcp, int xsrc, int ysrc)
 {
 	HPS hpsdest;
 	HPS hpssrc;
 	POINTL ptl[4];
 int destheight, srcheight;
 * Emits a beep.
 * Parameters:
 *       freq: Frequency.
 *       dur: Duration.
 */
-void dw_beep(int freq, int dur)
+void API dw_beep(int freq, int dur)
 {
 	DosBeep(freq, dur);
 }
 /* Open a shared library and return a handle.
 * Parameters:
 *         name: Base name of the shared library.
 *         handle: Pointer to a module handle,
 *                 will be filled in with the handle.
 */
-int dw_module_load(char *name, HMOD *handle)
+int API dw_module_load(char *name, HMOD *handle)
 {
 	char objnamebuf[300] = "";
 	return DosLoadModule(objnamebuf, sizeof(objnamebuf), name, handle);
 }
 *         handle: Module handle returned by dw_module_load()
 *         name: Name of the symbol you want the address of.
 *         func: A pointer to a function pointer, to obtain
 *               the address.
 */
-int dw_module_symbol(HMOD handle, char *name, void**func)
+int API dw_module_symbol(HMOD handle, char *name, void**func)
 {
 	return DosQueryProcAddr(handle, 0, name, (PFN*)func);
 }
 /* Frees the shared library previously opened.
 * Parameters:
 *         handle: Module handle returned by dw_module_load()
 */
-int dw_module_close(HMOD handle)
+int API dw_module_close(HMOD handle)
 {
 	DosFreeModule(handle);
 	return 0;
 }
 /*
 * Returns the handle to an unnamed mutex semaphore.
 */
-HMTX dw_mutex_new(void)
+HMTX API dw_mutex_new(void)
 {
 	HMTX mutex;
 	DosCreateMutexSem(NULL, &mutex, 0, FALSE);
 	return mutex;
 /*
 * Closes a semaphore created by dw_mutex_new().
 * Parameters:
 *       mutex: The handle to the mutex returned by dw_mutex_new().
 */
-void dw_mutex_close(HMTX mutex)
+void API dw_mutex_close(HMTX mutex)
 {
 	DosCloseMutexSem(mutex);
 }
 /*
 * If we are in a callback we must keep the message loop running
 * while blocking.
 * Parameters:
 *       mutex: The handle to the mutex returned by dw_mutex_new().
 */
-void dw_mutex_lock(HMTX mutex)
+void API dw_mutex_lock(HMTX mutex)
 {
 	if(_dwtid == dw_thread_id())
 	{
 		int rc = DosRequestMutexSem(mutex, SEM_IMMEDIATE_RETURN);
 /*
 * Reliquishes the access to the semaphore.
 * Parameters:
 *       mutex: The handle to the mutex returned by dw_mutex_new().
 */
-void dw_mutex_unlock(HMTX mutex)
+void API dw_mutex_unlock(HMTX mutex)
 {
 	DosReleaseMutexSem(mutex);
 }
 /*
 * Returns the handle to an unnamed event semaphore.
 */
-HEV dw_event_new(void)
+HEV API dw_event_new(void)
 {
 	HEV blah;
 	if(DosCreateEventSem (NULL, &blah, 0L, FALSE))
 		return 0;
 /*
 * Resets a semaphore created by dw_event_new().
 * Parameters:
 *       eve: The handle to the event returned by dw_event_new().
 */
-int dw_event_reset(HEV eve)
+int API dw_event_reset(HEV eve)
 {
 	ULONG count;
 	if(DosResetEventSem(eve, &count))
 		return FALSE;
 * Posts a semaphore created by dw_event_new(). Causing all threads
 * waiting on this event in dw_event_wait to continue.
 * Parameters:
 *       eve: The handle to the event returned by dw_event_new().
 */
-int dw_event_post(HEV eve)
+int API dw_event_post(HEV eve)
 {
 	if(DosPostEventSem(eve))
 		return FALSE;
 	return TRUE;
 }
 * Waits on a semaphore created by dw_event_new(), until the
 * event gets posted or until the timeout expires.
 * Parameters:
 *       eve: The handle to the event returned by dw_event_new().
 */
-int dw_event_wait(HEV eve, unsigned long timeout)
+int API dw_event_wait(HEV eve, unsigned long timeout)
 {
 	int rc = DosWaitEventSem(eve, timeout);
 	if(!rc)
 		return 1;
 	if(rc == ERROR_TIMEOUT)
 /*
 * Closes a semaphore created by dw_event_new().
 * Parameters:
 *       eve: The handle to the event returned by dw_event_new().
 */
-int dw_event_close(HEV *eve)
+int API dw_event_close(HEV *eve)
 {
 	if(!eve || ~DosCloseEventSem(*eve))
 		return FALSE;
 	return TRUE;
 }
 * Parameters:
 *       func: Function which will be run in the new thread.
 *       data: Parameter(s) passed to the function.
 *       stack: Stack size of new thread (OS/2 and Windows only).
 */
-DWTID dw_thread_new(void *func, void *data, int stack)
+DWTID API dw_thread_new(void *func, void *data, int stack)
 {
 	void **tmp = malloc(sizeof(void *) * 2);
 	tmp[0] = func;
 	tmp[1] = data;
 }
 /*
 * Ends execution of current thread immediately.
 */
-void dw_thread_end(void)
+void API dw_thread_end(void)
 {
 	_endthread();
 }
 /*
 * Returns the current thread's ID.
 */
-DWTID dw_thread_id(void)
+DWTID API dw_thread_id(void)
 {
 	return (DWTID)_threadid;
 }
 /*
 * Cleanly terminates a DW session, should be signal handler safe.
 * Parameters:
 *       exitcode: Exit code reported to the operating system.
 */
-void dw_exit(int exitcode)
+void API dw_exit(int exitcode)
 {
 	/* In case we are in a signal handler, don't
 	 * try to free memory that could possibly be
 	 * free()'d by the runtime already.
 	 */
 *       topleft: Handle to the window to be top or left.
 *       bottomright:  Handle to the window to be bottom or right.
 * Returns:
 *       A handle to a splitbar window or NULL on failure.
 */
-HWND dw_splitbar_new(int type, HWND topleft, HWND bottomright, unsigned long id)
+HWND API dw_splitbar_new(int type, HWND topleft, HWND bottomright, unsigned long id)
 {
 	HWND tmp = WinCreateWindow(HWND_OBJECT,
 							   SplitbarClassName,
 							   NULL,
 							   WS_VISIBLE | WS_CLIPCHILDREN,
 /*
 * Sets the position of a splitbar (pecentage).
 * Parameters:
 *       handle: The handle to the splitbar returned by dw_splitbar_new().
 */
-void dw_splitbar_set(HWND handle, float percent)
+void API dw_splitbar_set(HWND handle, float percent)
 {
 	float *mypercent = (float *)dw_window_get_data(handle, "_dw_percent");
 	int type = (int)dw_window_get_data(handle, "_dw_type");
 unsigned long width, height;
 /*
 * Gets the position of a splitbar (pecentage).
 * Parameters:
 *       handle: The handle to the splitbar returned by dw_splitbar_new().
 */
-float dw_splitbar_get(HWND handle)
+float API dw_splitbar_get(HWND handle)
 {
 	float *percent = (float *)dw_window_get_data(handle, "_dw_percent");
 	if(percent)
 		return *percent;
 *       height: Height in pixels of the item or -1 to be self determined.
 *       hsize: TRUE if the window (widget) should expand horizontally to fill space given.
 *       vsize: TRUE if the window (widget) should expand vertically to fill space given.
 *       pad: Number of pixels of padding around the item.
 */
-void dw_box_pack_start(HWND box, HWND item, int width, int height, int hsize, int vsize, int pad)
+void API dw_box_pack_start(HWND box, HWND item, int width, int height, int hsize, int vsize, int pad)
 {
 	Box *thisbox;
 	if(WinWindowFromID(box, FID_CLIENT))
 	{
 * Sets the default focus item for a window/dialog.
 * Parameters:
 *         window: Toplevel window or dialog.
 *         defaultitem: Handle to the dialog item to be default.
 */
-void dw_window_default(HWND window, HWND defaultitem)
+void API dw_window_default(HWND window, HWND defaultitem)
 {
 	Box *thisbox = NULL;
 	HWND box;
 	box = WinWindowFromID(window, FID_CLIENT);
 * Sets window to click the default dialog item when an ENTER is pressed.
 * Parameters:
 *         window: Window (widget) to look for the ENTER press.
 *         next: Window (widget) to move to next (or click)
 */
-void dw_window_click_default(HWND window, HWND next)
+void API dw_window_click_default(HWND window, HWND next)
 {
 	WindowData *blah = (WindowData *)WinQueryWindowPtr(window, QWP_USER);
 	if(blah)
 		blah->clickdefault = next;
 /*
 * Returns some information about the current operating environment.
 * Parameters:
 *       env: Pointer to a DWEnv struct.
 */
-void dw_environment_query(DWEnv *env)
+void API dw_environment_query(DWEnv *env)
 {
 	ULONG Build;
 	if(!env)
 		return;
 * Returns:
 *       NULL on error. A malloced buffer containing
 *       the file path on success.
 *
 */
-char *dw_file_browse(char *title, char *defpath, char *ext, int flags)
+char * API dw_file_browse(char *title, char *defpath, char *ext, int flags)
 {
 	FILEDLG fild;
 	HWND hwndFile;
 	int len;
 *       type: Either DW_EXEC_CON or DW_EXEC_GUI.
 *       params: An array of pointers to string arguements.
 * Returns:
 *       -1 on error.
 */
-int dw_exec(char *program, int type, char **params)
+int API dw_exec(char *program, int type, char **params)
 {
 	return spawnvp(P_NOWAIT, program, (const char **)params);
 }
 /*
 * Loads a web browser pointed at the given URL.
 * Parameters:
 *       url: Uniform resource locator.
 */
-int dw_browse(char *url)
+int API dw_browse(char *url)
 {
 	/* Is there a way to find the webbrowser in Unix? */
 	char *execargs[3], browser[1024], *olddir, *newurl = NULL;
 	int len, ret;
 /*
 * Returns a pointer to a static buffer which containes the
 * current user directory.  Or the root directory (C:\ on
 * OS/2 and Windows).
 */
-char *dw_user_dir(void)
+char * API dw_user_dir(void)
 {
 	static char _user_dir[1024] = "";
 	if(!_user_dir[0])
 	{
 * Parameters:
 *       handle: Window handle of the widget.
 *       function: Function pointer to be called.
 *       data: Pointer to the data to be passed to the function.
 */
-void dw_window_function(HWND handle, void *function, void *data)
+void API dw_window_function(HWND handle, void *function, void *data)
 {
 	WinSendMsg(handle, WM_USER, (MPARAM)function, (MPARAM)data);
 }
 /* Functions for managing the user data lists that are associated with
 * Parameters:
 *       window: Window handle of signal to be called back.
 *       dataname: A string pointer identifying which signal to be hooked.
 *       data: User data to be passed to the handler function.
 */
-void dw_window_set_data(HWND window, char *dataname, void *data)
+void API dw_window_set_data(HWND window, char *dataname, void *data)
 {
 	WindowData *blah = (WindowData *)WinQueryWindowPtr(window, QWP_USER);
 	if(!blah)
 	{
 *       window: Window handle of signal to be called back.
 *       signame: A string pointer identifying which signal to be hooked.
 *       sigfunc: The pointer to the function to be used as the callback.
 *       data: User data to be passed to the handler function.
 */
-void dw_signal_connect(HWND window, char *signame, void *sigfunc, void *data)
+void API dw_signal_connect(HWND window, char *signame, void *sigfunc, void *data)
 {
 	ULONG message = 0L;
 	if(strcmp(signame, "lose-focus") == 0)
 	{
 /*
 * Removes callbacks for a given window with given name.
 * Parameters:
 *       window: Window handle of callback to be removed.
 */
-void dw_signal_disconnect_by_name(HWND window, char *signame)
+void API dw_signal_disconnect_by_name(HWND window, char *signame)
 {
 	SignalHandler *prev = NULL, *tmp = Root;
 	ULONG message;
 	if(!window || !signame || (message = _findsigmessage(signame)) == 0)
 /*
 * Removes all callbacks for a given window.
 * Parameters:
 *       window: Window handle of callback to be removed.
 */
-void dw_signal_disconnect_by_window(HWND window)
+void API dw_signal_disconnect_by_window(HWND window)
 {
 	SignalHandler *prev = NULL, *tmp = Root;
 	while(tmp)
 	{
 * Removes all callbacks for a given window with specified data.
 * Parameters:
 *       window: Window handle of callback to be removed.
 *       data: Pointer to the data to be compared against.
 */
-void dw_signal_disconnect_by_data(HWND window, void *data)
+void API dw_signal_disconnect_by_data(HWND window, void *data)
 {
 	SignalHandler *prev = NULL, *tmp = Root;
 	while(tmp)
 	{

Mercurial > dwindows

comparison os2/dw.c @ 174:75bf3051235f