dwindows: template/dw.c comparison

comparison template/dw.c @ 2226:2de088fb5dd4

Added some missing APIs from the template, and changes so it builds dwtest. Needed to make the key codes unique values so it would compile.

author	bsmith@81767d24-ef19-dc11-ae90-00e081727c95
date	Sat, 26 Dec 2020 05:24:00 +0000
parents	1ec6300a627b
children	d9e1865fcba9

comparison

equal deleted inserted replaced

-:1ec6300a627b
+:2de088fb5dd4
 #include "dw.h"
 #include <stdlib.h>
 #include <string.h>
 /* Implement these to get and set the Box* pointer on the widget handle */
-void *_dw_get_window_pointer(HWND handle)
+void *_dw_window_pointer_get(HWND handle)
 {
 return NULL;
 }
-void _dw_set_window_pointer(HWND handle, Box *box)
+void _dw_window_pointer_set(HWND handle, Box *box)
 {
 }
 /* This function calculates how much space the widgets and boxes require
 * and does expansion as necessary.
 {
 int itempad, itemwidth, itemheight;
 if(thisbox->items[z].type == TYPEBOX)
 {
-Box *tmp = (Box *)_dw_get_window_pointer(thisbox->items[z].hwnd);
+Box *tmp = (Box *)_dw_window_pointer_get(thisbox->items[z].hwnd);
 if(tmp)
 {
 /* On the first pass calculate the box contents */
 if(pass == 1)
 void API dw_main(void)
 {
 }
 /*
+* Causes running dw_main() to return.
+*/
+void API dw_main_quit(void)
+{
+}
+/*
 * Runs a message loop for Dynamic Windows, for a period of milliseconds.
 * Parameters:
 *           milliseconds: Number of milliseconds to run the loop for.
 */
 void API dw_main_sleep(int milliseconds)
 *       None.
 * Returns:
 *       Pointer to an allocated string of text or NULL if clipboard empty or contents could not
 *       be converted to text.
 */
-char *dw_clipboard_get_text()
+char * API dw_clipboard_get_text()
 {
 return NULL;
 }
 /*
 * Sets the contents of the default clipboard to the supplied text.
 * Parameters:
 *       str: Text to put on the clipboard.
 *       len: Length of the text.
 */
-void dw_clipboard_set_text(const char *str, int len)
+void API dw_clipboard_set_text(const char *str, int len)
 {
 }
 /*
 {
 Box *thisbox;
 int z, x = 0;
 Item *tmpitem, *thisitem;
-thisbox = _dw_get_window_pointer(box);
+thisbox = _dw_window_pointer_get(box);
 thisitem = thisbox->items;
 /* Do some sanity bounds checking */
 if(index < 0)
 index = 0;
 void API dw_filesystem_set_item(HWND handle, void *pointer, int column, int row, void *data)
 {
 }
 /*
+* Sets the data 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.
+*          data: Data pointer.
+*/
+void API dw_container_set_row_data(void *pointer, int row, void *data)
+{
+}
+/*
+* Changes the data of a row already inserted in the container.
+* Parameters:
+*          handle: Handle to the container window (widget).
+*          row: Zero based row of data being set.
+*          data: Data pointer.
+*/
+void API dw_container_change_row_data(HWND handle, int row, void *data)
+{
+}
+/*
 * Gets column type for a container column.
 * Parameters:
 *          handle: Handle to the container window (widget).
 *          column: Zero based column.
 * Returns:
 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)
 {
 }
 /*
+* Copies from one surface to another allowing for stretching.
+* Parameters:
+*       dest: Destination window handle.
+*       destp: Destination pixmap. (choose only one).
+*       xdest: X coordinate of destination.
+*       ydest: Y coordinate of destination.
+*       width: Width of the target area.
+*       height: Height of the target area.
+*       src: Source window handle.
+*       srcp: Source pixmap. (choose only one).
+*       xsrc: X coordinate of source.
+*       ysrc: Y coordinate of source.
+*       srcwidth: Width of area to copy.
+*       srcheight: Height of area to copy.
+* Returns:
+*       DW_ERROR_NONE on success and DW_ERROR_GENERAL on failure.
+*/
+int API dw_pixmap_stretch_bitblt(HWND dest, HPIXMAP destp, int xdest, int ydest, int width, int height, HWND src, HPIXMAP srcp, int xsrc, int ysrc, int srcwidth, int srcheight)
+{
+return DW_ERROR_GENERAL;
+}
+/*
 * Create a new calendar window (widget) to be packed.
 * Parameters:
 *       id: An ID to be used with dw_window_from_id() or 0L.
 * Returns:
 *       Handle to the created calendar or NULL on error.
 * Sets the current date of a calendar.
 * Parameters:
 *       handle: The handle to the calendar returned by dw_calendar_new().
 *       year, month, day: To set the calendar to display.
 */
-void dw_calendar_set_date(HWND handle, unsigned int year, unsigned int month, unsigned int day)
+void API dw_calendar_set_date(HWND handle, unsigned int year, unsigned int month, unsigned int day)
 {
 }
 /*
 * Gets the year, month and day set in the calendar widget.
 *       handle: The handle to the calendar returned by dw_calendar_new().
 *       year: Variable to store the year or NULL.
 *       month: Variable to store the month or NULL.
 *       day: Variable to store the day or NULL.
 */
-void dw_calendar_get_date(HWND handle, unsigned int *year, unsigned int *month, unsigned int *day)
+void API dw_calendar_get_date(HWND handle, unsigned int *year, unsigned int *month, unsigned int *day)
 {
 }
 /*
 * Causes the embedded HTML widget to take action.
 *       scriptdata: Data passed to the signal handler.
 * Notes: A DW_SIGNAL_HTML_RESULT event will be raised with scriptdata.
 * Returns:
 *       DW_ERROR_NONE (0) on success.
 */
-int dw_html_javascript_run(HWND handle, const char *script, void *scriptdata)
+int API dw_html_javascript_run(HWND handle, const char *script, void *scriptdata)
 {
 return DW_ERROR_UNKNOWN;
 }
 /*
 /*
 * 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)
 {
 strcpy(env->osName, "Unknown");
 strcpy(env->buildDate, __DATE__);
 strcpy(env->buildTime, __TIME__);
 * Parameters:
 *       window: Window handle to save data to.
 *       dataname: A string pointer identifying which data to be saved.
 *       data: User data to be saved to the window handle.
 */
-void dw_window_set_data(HWND window, const char *dataname, void *data)
+void API dw_window_set_data(HWND window, const char *dataname, void *data)
 {
 }
 /*
 * Gets a named user data item from a window handle.
 *       window: Window handle to get data from.
 *       dataname: A string pointer identifying which data to get.
 * Returns:
 *       Pointer to data or NULL if no data is available.
 */
-void *dw_window_get_data(HWND window, const char *dataname)
+void * API dw_window_get_data(HWND window, const char *dataname)
 {
 return NULL;
 }
 /*
 *         handle: Pointer to a module handle,
 *                 will be filled in with the handle.
 * Returns:
 *       DW_ERROR_NONE (0) on success.
 */
-int dw_module_load(const char *name, HMOD *handle)
+int API dw_module_load(const char *name, HMOD *handle)
 {
 return DW_ERROR_UNKNOWN;
 }
 /* Queries the address of a symbol within open handle.
 *         func: A pointer to a function pointer, to obtain
 *               the address.
 * Returns:
 *       DW_ERROR_NONE (0) on success.
 */
-int dw_module_symbol(HMOD handle, const char *name, void**func)
+int API dw_module_symbol(HMOD handle, const char *name, void**func)
 {
 return DW_ERROR_UNKNOWN;
 }
 /* Frees the shared library previously opened.
 * Parameters:
 *         handle: Module handle returned by dw_module_load()
 * Returns:
 *       DW_ERROR_NONE (0) on success.
 */
-int dw_module_close(HMOD handle)
+int API dw_module_close(HMOD handle)
 {
 return DW_ERROR_GENERAL;
 }
 /*
 * Returns the handle to an unnamed mutex semaphore or NULL on error.
 */
-HMTX dw_mutex_new(void)
+HMTX API dw_mutex_new(void)
 {
 return NULL;
 }
 /*
 * 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)
 {
 }
 /*
 * Tries to gain access to the semaphore, if it can't it blocks.
 * 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 0
 /* We need to handle locks from the main thread differently...
 * since we can't stop message processing... otherwise we
 * will deadlock... so try to acquire the lock and continue
 /*
 * 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)
 {
 }
 /*
 * Returns the handle to an unnamed event semaphore or NULL on error.
 */
-HEV dw_event_new(void)
+HEV API dw_event_new(void)
 {
 return NULL;
 }
 /*
 * Parameters:
 *       eve: The handle to the event returned by dw_event_new().
 * Returns:
 *       DW_ERROR_NONE (0) on success.
 */
-int dw_event_reset (HEV eve)
+int API dw_event_reset (HEV eve)
 {
 return DW_ERROR_GENERAL;
 }
 /*
 * Parameters:
 *       eve: The handle to the event returned by dw_event_new().
 * Returns:
 *       DW_ERROR_NONE (0) on success.
 */
-int dw_event_post (HEV eve)
+int API dw_event_post (HEV eve)
 {
 return DW_ERROR_GENERAL;
 }
 /*
 * Returns:
 *       DW_ERROR_NONE (0) on success.
 *       DW_ERROR_TIMEOUT (2) if the timeout has expired.
 *       Other values on other error.
 */
-int dw_event_wait(HEV eve, unsigned long timeout)
+int API dw_event_wait(HEV eve, unsigned long timeout)
 {
 return DW_ERROR_GENERAL;
 }
 /*
 * Parameters:
 *       eve: The handle to the event returned by dw_event_new().
 * Returns:
 *       DW_ERROR_NONE (0) on success.
 */
-int dw_event_close(HEV *eve)
+int API dw_event_close(HEV *eve)
 {
 return DW_ERROR_GENERAL;
 }
 /* Create a named event semaphore which can be
 *         name: Name given to semaphore which can be opened
 *               by other processes.
 * Returns:
 *       Handle to event semaphore or NULL on error.
 */
-HEV dw_named_event_new(const char *name)
+HEV API dw_named_event_new(const char *name)
 {
 return NULL;
 }
 /* Open an already existing named event semaphore.
 *         name: Name given to semaphore which can be opened
 *               by other processes.
 * Returns:
 *       Handle to event semaphore or NULL on error.
 */
-HEV dw_named_event_get(const char *name)
+HEV API dw_named_event_get(const char *name)
 {
 return NULL;
 }
 /* Resets the event semaphore so threads who call wait
 *         eve: Handle to the semaphore obtained by
 *              an get or new call.
 * Returns:
 *       DW_ERROR_NONE (0) on success.
 */
-int dw_named_event_reset(HEV eve)
+int API dw_named_event_reset(HEV eve)
 {
 return DW_ERROR_GENERAL;
 }
 /* Sets the posted state of an event semaphore, any threads
 *         eve: Handle to the semaphore obtained by
 *              an get or new call.
 * Returns:
 *       DW_ERROR_NONE (0) on success.
 */
-int dw_named_event_post(HEV eve)
+int API dw_named_event_post(HEV eve)
 {
 return DW_ERROR_GENERAL;
 }
 /* Waits on the specified semaphore until it becomes
 *         timeout: Number of milliseconds before timing out
 *                  or -1 if indefinite.
 * Returns:
 *       DW_ERROR_NONE (0) on success.
 */
-int dw_named_event_wait(HEV eve, unsigned long timeout)
+int API dw_named_event_wait(HEV eve, unsigned long timeout)
 {
 return DW_ERROR_UNKNOWN;
 }
 /* Release this semaphore, if there are no more open
 *         eve: Handle to the semaphore obtained by
 *              an get or new call.
 * Returns:
 *       DW_ERROR_NONE (0) on success.
 */
-int dw_named_event_close(HEV eve)
+int API dw_named_event_close(HEV eve)
 {
 return DW_ERROR_UNKNOWN;
 }
 /*
 *         size: Size in bytes of the shared memory region to allocate.
 *         name: A string pointer to a unique memory name.
 * Returns:
 *       Handle to shared memory or NULL on error.
 */
-HSHM dw_named_memory_new(void **dest, int size, const char *name)
+HSHM API dw_named_memory_new(void **dest, int size, const char *name)
 {
 return NULL;
 }
 /*
 *       size: Size in bytes of the shared memory region to requested.
 *       name: A string pointer to a unique memory name.
 * Returns:
 *       Handle to shared memory or NULL on error.
 */
-HSHM dw_named_memory_get(void **dest, int size, const char *name)
+HSHM API dw_named_memory_get(void **dest, int size, const char *name)
 {
 return NULL;
 }
 /*
 *       handle: Handle obtained from dw_named_memory_new().
 *       ptr: The memory address aquired with dw_named_memory_new().
 * Returns:
 *       DW_ERROR_NONE (0) on success or DW_ERROR_UNKNOWN (-1) on error.
 */
-int dw_named_memory_free(HSHM handle, void *ptr)
+int API dw_named_memory_free(HSHM handle, void *ptr)
 {
 int rc = DW_ERROR_UNKNOWN;
 return rc;
 }
 *       data: Parameter(s) passed to the function.
 *       stack: Stack size of new thread (OS/2 and Windows only).
 * Returns:
 *       Thread ID on success or DW_ERROR_UNKNOWN (-1) on error.
 */
-DWTID dw_thread_new(void *func, void *data, int stack)
+DWTID API dw_thread_new(void *func, void *data, int stack)
 {
 return (DWTID)DW_ERROR_UNKNOWN;
 }
 /*
 * Ends execution of current thread immediately.
 */
-void dw_thread_end(void)
+void API dw_thread_end(void)
 {
 }
 /*
 * Returns the current thread's ID.
 */
-DWTID dw_thread_id(void)
+DWTID API dw_thread_id(void)
 {
 return (DWTID)0;
 }
 /*
 *       type: Either DW_EXEC_CON or DW_EXEC_GUI.
 *       params: An array of pointers to string arguements.
 * Returns:
 *       Process ID on success or DW_ERROR_UNKNOWN (-1) on error.
 */
-int dw_exec(const char *program, int type, char **params)
+int API dw_exec(const char *program, int type, char **params)
 {
 int ret = DW_ERROR_UNKNOWN;
 return ret;
 }
 * Parameters:
 *       url: Uniform resource locator.
 * Returns:
 *       DW_ERROR_UNKNOWN (-1) on error; DW_ERROR_NONE (0) or a positive Process ID on success.
 */
-int dw_browse(const char *url)
+int API dw_browse(const char *url)
 {
 return DW_ERROR_UNKNOWN;
 }
 /*

Mercurial > dwindows

comparison template/dw.c @ 2226:2de088fb5dd4