dwindows: ios/dw.m comparison

comparison ios/dw.m @ 2991:81f9399b11c8

Mac/iOS: Fix exported API function definitions reported by Xcode. Added missing APIs on functions, not necessary on Mac and iOS technically but for consistence they should be there and for future use.

author	bsmith@81767d24-ef19-dc11-ae90-00e081727c95
date	Tue, 04 Apr 2023 12:05:14 +0000
parents	ae4d6856b983
children	8311be624877

comparison

equal deleted inserted replaced

-:9220cbf90ed3
+:81f9399b11c8
 /*
 * 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[PATH_MAX+1] = { 0 };
 if(!_user_dir[0])
 {
 *       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(void)
 {
 UIPasteboard *pasteboard = [UIPasteboard generalPasteboard];
 NSString *str = [pasteboard string];
 if(str != nil)
 return strdup([str UTF8String]);
 /*
 * Sets the contents of the default clipboard to the supplied text.
 * Parameters:
 *       Text.
 */
-void dw_clipboard_set_text(const char *str, int len)
+void API dw_clipboard_set_text(const char *str, int len)
 {
 UIPasteboard *pasteboard = [UIPasteboard generalPasteboard];
 [pasteboard setString:[NSString stringWithUTF8String:str]];
 }
 /*
 * 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)
 {
 /* TODO: Not sure if we need to implement this on iOS */
 }
 /*
 *         or NULL if it fails or notifications are not supported by the system.
 * Remarks:
 *          This will create a system notification that will show in the notifaction panel
 *          on supported systems, which may be clicked to perform another task.
 */
-HWND dw_notification_new(const char *title, const char *imagepath, const char *description, ...)
+HWND API dw_notification_new(const char *title, const char *imagepath, const char *description, ...)
 {
 char outbuf[1025] = {0};
 HWND retval = NULL;
 if(description)
 * Parameters:
 *         notification: The handle to the notification returned by dw_notification_new().
 * Returns:
 *         DW_ERROR_NONE on success, DW_ERROR_UNKNOWN on error or not supported.
 */
-int dw_notification_send(HWND notification)
+int API dw_notification_send(HWND notification)
 {
 if(notification)
 {
 NSString *notid = [NSString stringWithFormat:@"dw-notification-%llu", DW_POINTER_TO_ULONGLONG(notification)];
 /*
 * 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)
 {
 memset(env, '\0', sizeof(DWEnv));
 strcpy(env->osName, "iOS");
 strncpy(env->buildDate, __DATE__, sizeof(env->buildDate)-1);
 * 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(const char *name, HMOD *handle)
+int API dw_module_load(const char *name, HMOD *handle)
 {
 int len;
 char *newname;
 char errorbuf[1025];
 *         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, const char *name, void**func)
+int API dw_module_symbol(HMOD handle, const char *name, void**func)
 {
 if(!func || !name)
 return   -1;
 if(strlen(name) == 0)
 /* 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)
 {
 if(handle)
 return dlclose(handle);
 return 0;
 }
 /*
 * Returns the handle to an unnamed mutex semaphore.
 */
-HMTX dw_mutex_new(void)
+HMTX API dw_mutex_new(void)
 {
 HMTX mutex = malloc(sizeof(pthread_mutex_t));
 pthread_mutex_init(mutex, NULL);
 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)
 {
 if(mutex)
 {
 pthread_mutex_destroy(mutex);
 free(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)
 {
 /* 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
 * processing messages in between tries.
 /*
 * 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)
 {
 pthread_mutex_unlock(mutex);
 }
 /*
 * Returns the handle to an unnamed event semaphore.
 */
-HEV dw_event_new(void)
+HEV API dw_event_new(void)
 {
 HEV eve = (HEV)malloc(sizeof(struct _dw_unix_event));
 if(!eve)
 return NULL;
 /*
 * 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)
 {
 if(!eve)
 return DW_ERROR_NON_INIT;
 pthread_mutex_lock (&(eve->mutex));
 * 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(!eve)
 return FALSE;
 pthread_mutex_lock (&(eve->mutex));
 * 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;
 if(!eve)
 return DW_ERROR_NON_INIT;
 /*
 * 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 || !(*eve))
 return DW_ERROR_NON_INIT;
 pthread_mutex_lock (&((*eve)->mutex));
 * Parameters:
 *         eve: Pointer to an event handle to receive handle.
 *         name: Name given to semaphore which can be opened
 *               by other processes.
 */
-HEV dw_named_event_new(const char *name)
+HEV API dw_named_event_new(const char *name)
 {
 struct sockaddr_un un;
 int ev, *tmpsock = (int *)malloc(sizeof(int)*2);
 HEV eve;
 DWTID dwthread;
 * Parameters:
 *         eve: Pointer to an event handle to receive handle.
 *         name: Name given to semaphore which can be opened
 *               by other processes.
 */
-HEV dw_named_event_get(const char *name)
+HEV API dw_named_event_get(const char *name)
 {
 struct sockaddr_un un;
 HEV eve;
 int ev = socket(AF_UNIX, SOCK_STREAM, 0);
 if(ev < 0)
 * on this semaphore will block.
 * Parameters:
 *         eve: Handle to the semaphore obtained by
 *              an open or create call.
 */
-int dw_named_event_reset(HEV eve)
+int API dw_named_event_reset(HEV eve)
 {
 /* signal reset */
 char tmp = (char)0;
 if(!eve || eve->alive < 0)
 * waiting on the semaphore will no longer block.
 * Parameters:
 *         eve: Handle to the semaphore obtained by
 *              an open or create call.
 */
-int dw_named_event_post(HEV eve)
+int API dw_named_event_post(HEV eve)
 {
 /* signal post */
 char tmp = (char)1;
 *         eve: Handle to the semaphore obtained by
 *              an open or create call.
 *         timeout: Number of milliseconds before timing out
 *                  or -1 if indefinite.
 */
-int dw_named_event_wait(HEV eve, unsigned long timeout)
+int API dw_named_event_wait(HEV eve, unsigned long timeout)
 {
 fd_set rd;
 struct timeval tv, *useme = NULL;
 int retval = 0;
 char tmp;
 * handles on this semaphore the semaphore will be destroyed.
 * Parameters:
 *         eve: Handle to the semaphore obtained by
 *              an open or create call.
 */
-int dw_named_event_close(HEV eve)
+int API dw_named_event_close(HEV eve)
 {
 /* Finally close the domain socket,
 * cleanup will continue in _dw_handle_sem.
 */
 if(eve)
 *         handle: A pointer to receive a SHM identifier.
 *         dest: A pointer to a pointer to receive the memory address.
 *         size: Size in bytes of the shared memory region to allocate.
 *         name: A string pointer to a unique memory name.
 */
-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)
 {
 char namebuf[1025] = {0};
 struct _dw_unix_shm *handle = malloc(sizeof(struct _dw_unix_shm));
 mkdir("/tmp/.dw", S_IWGRP|S_IWOTH);
 * Parameters:
 *         dest: A pointer to a pointer to receive the memory address.
 *         size: Size in bytes of the shared memory region to requested.
 *         name: A string pointer to a unique memory name.
 */
-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)
 {
 char namebuf[1025];
 struct _dw_unix_shm *handle = malloc(sizeof(struct _dw_unix_shm));
 mkdir("/tmp/.dw", S_IWGRP|S_IWOTH);
 * Frees a shared memory region previously allocated.
 * Parameters:
 *         handle: Handle obtained from DB_named_memory_allocate.
 *         ptr: The memory address aquired with DB_named_memory_allocate.
 */
-int dw_named_memory_free(HSHM handle, void *ptr)
+int API dw_named_memory_free(HSHM handle, void *ptr)
 {
 struct _dw_unix_shm *h = handle;
 int rc = munmap(ptr, h->size);
 close(h->fd);
 * 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)
 {
 DWTID thread;
 void **tmp = malloc(sizeof(void *) * 2);
 int rc;
 }
 /*
 * Ends execution of current thread immediately.
 */
-void dw_thread_end(void)
+void API dw_thread_end(void)
 {
 pthread_exit(NULL);
 }
 /*
 * Returns the current thread's ID.
 */
-DWTID dw_thread_id(void)
+DWTID API dw_thread_id(void)
 {
 return (DWTID)pthread_self();
 }
 /*
 /*
 * Loads a web browser pointed at the given URL.
 * Parameters:
 *       url: Uniform resource locator.
 */
-int dw_browse(const char *url)
+int API dw_browse(const char *url)
 {
 NSURL *myurl = [NSURL URLWithString:[NSString stringWithUTF8String:url]];
 [DWApp openURL:myurl options:@{}
 completionHandler:^(BOOL success) {}];
 return DW_ERROR_NONE;

Mercurial > dwindows

comparison ios/dw.m @ 2991:81f9399b11c8