dwindows: gtk4/dw.c comparison

comparison gtk4/dw.c @ 2323:4b04943319c5

GTK4: Move a few more functions into thread safety. Add API to functions that were missing it. API is used for speficying calling convention, that isn't usually required on Unix, but should be there for future use. The thread safety macros will automatically add API, so just required to add it to ones not in the thread safety system.

author	bsmith@81767d24-ef19-dc11-ae90-00e081727c95
date	Wed, 17 Feb 2021 06:21:27 +0000
parents	ebcaedfa7ff4
children	610c66b17fbc

comparison

equal deleted inserted replaced

-:ebcaedfa7ff4
+:4b04943319c5
 * 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[])
 {
 /* Setup the private data directory */
 if(argc > 0 && argv[0])
 {
 char *pathcopy = strdup(argv[0]);
 * 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 = calloc(sizeof(DWDialog), 1);
 if(tmp)
 {
 * 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;
 if(dialog->method)
 g_main_loop_quit(dialog->mainloop);
 else
 * 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)
 {
 void *tmp;
 if(!dialog)
 return NULL;
 *           title: The title of the message box.
 *           flags: Defines buttons and icons to display
 *           format: printf style format string.
 *           ...: Additional variables for use in the format.
 */
-int dw_messagebox(const char *title, int flags, const char *format, ...)
+int API dw_messagebox(const char *title, int flags, const char *format, ...)
 {
 GtkMessageType gtkicon = GTK_MESSAGE_OTHER;
 GtkButtonsType gtkbuttons = GTK_BUTTONS_OK;
 GtkWidget *dialog;
 int response;
 * Makes the window topmost.
 * Parameters:
 *           handle: The window handle to make topmost.
 */
 #ifndef GDK_WINDOWING_X11
-int dw_window_raise(HWND handle)
+int API dw_window_raise(HWND handle)
 {
 return DW_ERROR_UNKNOWN;
 }
 #else
 DW_FUNCTION_DEFINITION(dw_window_raise, int, HWND handle)
 * Makes the window bottommost.
 * Parameters:
 *           handle: The window handle to make bottommost.
 */
 #ifndef GDK_WINDOWING_X11
-int dw_window_lower(HWND handle)
+int API dw_window_lower(HWND handle)
 {
 return DW_ERROR_UNKNOWN;
 }
 #else
 DW_FUNCTION_DEFINITION(dw_window_lower, int, HWND 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)
 {
 }
 /*
 * Changes a window's parent to newparent.
 * 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)
 {
 /* TODO */
 return 0;
 }
 * Captures the mouse input to this window.
 * Parameters:
 *       handle: Handle to receive mouse input.
 */
 #ifndef GDK_WINDOWING_X11
-void dw_window_capture(HWND handle)
+void API dw_window_capture(HWND handle)
 {
 }
 #else
 static Display *_DWXGrabbedDisplay = NULL;
 /*
 * Releases previous mouse capture.
 */
 #ifndef GDK_WINDOWING_X11
-void dw_window_release(void)
+void API dw_window_release(void)
 {
 }
 #else
 DW_FUNCTION_DEFINITION(dw_window_release, void)
 DW_FUNCTION_ADD_PARAM
 * Parameters:
 *       x: X coordinate.
 *       y: Y coordinate.
 */
 #ifndef GDK_WINDOWING_X11
-void dw_pointer_set_pos(long x, long y)
+void API dw_pointer_set_pos(long x, long y)
 {
 }
 #else
 DW_FUNCTION_DEFINITION(dw_pointer_set_pos, void, long x, long y)
 DW_FUNCTION_ADD_PARAM2(x, y)
 * Sets the word auto complete state of an MLE box.
 * Parameters:
 *          handle: Handle to the MLE.
 *          state: Bitwise combination of DW_MLE_COMPLETE_TEXT/DASH/QUOTE
 */
-void dw_mle_set_auto_complete(HWND handle, int state)
+void API dw_mle_set_auto_complete(HWND handle, int state)
 {
 }
 /*
 * Sets the current cursor position of an MLE box.
 /*
 * 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)
 {
 }
 /*
 * 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)
 {
 }
 /* Internal function to update the progress bar
 * while in an indeterminate state.
 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), TRUE);
 gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(tree), TRUE);
 gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(tree), TRUE);
 sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
 if(g_object_get_data(G_OBJECT(handle), "_dw_multi_sel"))
-{
 gtk_tree_selection_set_mode(sel, GTK_SELECTION_MULTIPLE);
-}
 else
-{
 gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
-}
 gtk_widget_show(tree);
 free(array);
 if(_DWDefaultFont)
 dw_window_set_font(handle, _DWDefaultFont);
 return DW_ERROR_NONE;
 *          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.
 */
-HICN dw_icon_load(unsigned long module, unsigned long id)
+HICN API dw_icon_load(unsigned long module, unsigned long id)
 {
 return (HICN)id;
 }
 /* Internal function to keep HICNs from getting too big */
 /*
 * Frees a loaded resource in OS/2 and Windows.
 * Parameters:
 *          handle: Handle to icon returned by dw_icon_load().
 */
-void dw_icon_free(HICN handle)
+void API dw_icon_free(HICN handle)
 {
 int iicon = GPOINTER_TO_INT(handle);
 if(iicon > 65535)
 {
 * 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)
 {
 /* Don't need to do anything here */
 }
 /*
 * Parameters:
 *       handle: Window handle that will handle taskbar icon messages.
 *       icon: Icon handle to display in the taskbar.
 *       bubbletext: Text to show when the mouse is above the icon.
 */
-void dw_taskbar_insert(HWND handle, HICN icon, const char *bubbletext)
+void API dw_taskbar_insert(HWND handle, HICN icon, const char *bubbletext)
 {
 /* TODO: Removed in GTK4.... no replacement? */
 }
 /*
 * Deletes an icon from the taskbar.
 * Parameters:
 *       handle: Window handle that was used with dw_taskbar_insert().
 *       icon: Icon handle that was used with dw_taskbar_insert().
 */
-void dw_taskbar_delete(HWND handle, HICN icon)
+void API dw_taskbar_delete(HWND handle, HICN icon)
 {
 /* TODO: Removed in GTK4.... no replacement? */
 }
 /*
 * 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)
 {
 GdkRGBA color = _dw_internal_color(value);
 GdkRGBA *foreground = pthread_getspecific(_dw_fg_color_key);
 *foreground = 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)
 {
 GdkRGBA *background = pthread_getspecific(_dw_bg_color_key);
 if(value == DW_CLR_DEFAULT)
 {
 *               dw_pixmap_new..
 *       color:  transparent color
 * Note: This does nothing on GTK+ as transparency
 *       is handled automatically
 */
-void dw_pixmap_set_transparent_color(HPIXMAP pixmap, unsigned long color)
+void API dw_pixmap_set_transparent_color(HPIXMAP pixmap, unsigned long color)
 {
 }
 /*
 * Creates a pixmap from internal resource graphic specified by id.
 }
 /* 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)
 {
 }
 /*
 * Sets the font used by a specified pixmap.
 cairo_scale(cr, xscale, yscale);
 }
 if(src)
 ;
-#ifdef GTK3
+#ifdef GTK3 /* TODO: See how to do this in GTK4 */
 gdk_cairo_set_source_window (cr, gtk_widget_get_window(src), (xdest + xsrc) / xscale, (ydest + ysrc) / yscale);
 #endif
 else if(srcp)
 cairo_set_source_surface (cr, srcp->image, (xdest + xsrc) / xscale, (ydest + ysrc) / yscale);
 * Emits a beep.
 * Parameters:
 *       freq: Frequency.
 *       dur: Duration.
 */
-void dw_beep(int freq, int dur)
+void API dw_beep(int freq, int dur)
 {
 gdk_display_beep(gdk_display_get_default());
 }
 void _dw_strlwr(char *buf)
 * 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] = {0};
 *         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)
 {
 pthread_mutex_lock(mutex);
 }
 /*
 /*
 * 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 DW_ERROR_NON_INIT;
 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);
 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;
 int ev = socket(AF_UNIX, SOCK_STREAM, 0);
 if(ev < 0)
 return NULL;
 * 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(GPOINTER_TO_INT(eve) < 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.
 */
 close(GPOINTER_TO_INT(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];
 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 gtkthread;
 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();
 }
 /*
 * Cleanly terminates a DW session, should be signal handler safe.
 */
-void dw_shutdown(void)
+void API dw_shutdown(void)
 {
 g_main_loop_unref(_DWMainLoop);
 }
 /*
 * 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)
 {
 dw_shutdown();
 exit(exitcode);
 }
 }
 DW_FUNCTION_RETURN_NOTHING;
 }
 /* Internal version to simplify the code with multiple versions of GTK */
-int _dw_screen_width(void)
+int _dw_get_screen_width(void)
 {
 GdkDisplay *display = gdk_display_get_default();
 if(display)
 {
 }
 /*
 * Returns the width of the screen.
 */
-int dw_screen_width(void)
+DW_FUNCTION_DEFINITION(dw_screen_width, int)
-{
+DW_FUNCTION_ADD_PARAM
-return _dw_screen_width();
+DW_FUNCTION_RETURN(dw_screen_width, int)
+{
+int retval = _dw_get_screen_width();
+DW_FUNCTION_RETURN_THIS(retval);
 }
 /* Internal version to simplify the code with multiple versions of GTK */
-int _dw_screen_height(void)
+int _dw_get_screen_height(void)
 {
 GdkDisplay *display = gdk_display_get_default();
 if(display)
 {
 }
 /*
 * Returns the height of the screen.
 */
-int dw_screen_height(void)
+DW_FUNCTION_DEFINITION(dw_screen_height, int)
-{
+DW_FUNCTION_ADD_PARAM
-return _dw_screen_height();
+DW_FUNCTION_RETURN(dw_screen_height, int)
+{
+int retval = _dw_get_screen_height();
+DW_FUNCTION_RETURN_THIS(retval);
 }
 /* This should return the current color depth */
-unsigned long dw_color_depth_get(void)
+unsigned long API dw_color_depth_get(void)
 {
 /* TODO: Make this work on GTK4... with no GdkVisual */
 return 32;
 }
 *          handle: Window (widget) handle.
 *          x: X location from the bottom left.
 *          y: Y location from the bottom left.
 */
 #ifndef GDK_WINDOWING_X11
-void dw_window_set_pos(HWND handle, long x, long y)
+void API dw_window_set_pos(HWND handle, long x, long y)
 {
 }
 #else
 DW_FUNCTION_DEFINITION(dw_window_set_pos, void, HWND handle, long x, long y)
 DW_FUNCTION_ADD_PARAM3(handle, x, y)
 *          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, long x, long y, unsigned long width, unsigned long height)
+void API dw_window_set_pos_size(HWND handle, long x, long y, unsigned long width, unsigned long height)
 {
 dw_window_set_size(handle, width, height);
 dw_window_set_pos(handle, x, y);
 }
 * 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, unsigned long pageid, const char *text)
+void API dw_notebook_page_set_status_text(HWND handle, unsigned long pageid, const char *text)
 {
 /* TODO (if possible) */
 }
 /*
 * 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, const char *text)
+void API dw_listbox_append(HWND handle, const char *text)
 {
 dw_listbox_insert(handle, text, -1);
 }
 /*
 *         window: Toplevel window or dialog.
 *         defaultitem: Handle to the dialog item to be default.
 * Remarks:
 *          This is for use before showing the window/dialog.
 */
-void dw_window_default(HWND window, HWND defaultitem)
+void API dw_window_default(HWND window, HWND defaultitem)
 {
 if(window)
 g_object_set_data(G_OBJECT(window),  "_dw_defaultitem", (gpointer)defaultitem);
 }
 *         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, ...)
 {
 GNotification *notification = g_notification_new(title);
 if(notification)
 {
 * 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)
 {
 char id[101] = {0};
 /*
 * 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)
 {
 struct utsname name;
 char tempbuf[_DW_ENV_STRING_SIZE] = { 0 }, *dot;
 uname(&name);
 *       type: Either DW_EXEC_CON or DW_EXEC_GUI.
 *       params: An array of pointers to string arguements.
 * Returns:
 *       -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 = -1;
 if((ret = fork()) == 0)
 {
 /*
 * 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)
 {
 /* If possible load the URL/URI using gvfs... */
 gtk_show_uri(NULL, url, GDK_CURRENT_TIME);
 return DW_ERROR_NONE;
 }
 * Causes the embedded HTML widget to take action.
 * Parameters:
 *       handle: Handle to the window.
 *       action: One of the DW_HTML_* constants.
 */
-void dw_html_action(HWND handle, int action)
+void API dw_html_action(HWND handle, int action)
 {
 #ifdef USE_WEBKIT
 WebKitWebView *web_view;
 if((web_view = _dw_html_web_view(handle)))
 *       string: String buffer containt HTML code to
 *               be rendered.
 * Returns:
 *       0 on success.
 */
-int dw_html_raw(HWND handle, const char *string)
+int API dw_html_raw(HWND handle, const char *string)
 {
 #ifdef USE_WEBKIT
 WebKitWebView *web_view;
 if((web_view = _dw_html_web_view(handle)))
 *       url: Universal Resource Locator of the web or
 *               file object to be rendered.
 * Returns:
 *       0 on success.
 */
-int dw_html_url(HWND handle, const char *url)
+int API dw_html_url(HWND handle, const char *url)
 {
 #ifdef USE_WEBKIT
 WebKitWebView *web_view;
 if((web_view = _dw_html_web_view(handle)))
 *       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)
 {
 #ifdef USE_WEBKIT
 WebKitWebView *web_view;
 if((web_view = _dw_html_web_view(handle)))
 *       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)
 {
 GdkDisplay *display = gdk_display_get_default();
 GdkClipboard *clipboard;
 char *ret = NULL;
 /*
 * 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)
 {
 GdkDisplay *display = gdk_display_get_default();
 GdkClipboard *clipboard;
 if((clipboard = gdk_display_get_clipboard(display)))
 /*
 * Returns a pointer to a static buffer which contains 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])
 {
 *          it will create a unique ID in the form: org.dbsoft.dwindows.application
 *          or if the application name cannot be detected: org.dbsoft.dwindows.pid.#
 *          The appname is only required on Windows.  If NULL is passed the detected
 *          application name will be used, but a prettier name may be desired.
 */
-int dw_app_id_set(const char *appid, const char *appname)
+int API dw_app_id_set(const char *appid, const char *appname)
 {
 if(g_application_id_is_valid(appid))
 {
 strncpy(_dw_app_id, appid, _DW_APP_ID_SIZE);
 return DW_ERROR_NONE;
 * 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)
 {
 void (* windowfunc)(void *);
 windowfunc = function;
 * 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, const char *dataname, void *data)
+void API dw_window_set_data(HWND window, const char *dataname, void *data)
 {
 HWND thiswindow = window;
 if(!window)
 return;
 * 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_get_data(HWND window, const char *dataname)
+void * API dw_window_get_data(HWND window, const char *dataname)
 {
 HWND thiswindow = window;
 void *ret = NULL;
 if(!window)
 *       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, const char *signame, void *sigfunc, void *data)
+void API dw_signal_connect(HWND window, const char *signame, void *sigfunc, void *data)
 {
 dw_signal_connect_data(window, signame, sigfunc, NULL, data);
 }
 /* Internal function to free any allocated signal data..
 *       signame: A string pointer identifying which signal to be hooked.
 *       sigfunc: The pointer to the function to be used as the callback.
 *       discfunc: The pointer to the function called when this handler is removed.
 *       data: User data to be passed to the handler function.
 */
-void dw_signal_connect_data(HWND window, const char *signame, void *sigfunc, void *discfunc, void *data)
+void API dw_signal_connect_data(HWND window, const char *signame, void *sigfunc, void *discfunc, void *data)
 {
 SignalList signal = _dw_findsignal(signame);
 if(signal.func)
 {
 /*
 * 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, const char *signame)
+void API dw_signal_disconnect_by_name(HWND window, const char *signame)
 {
 int z, count;
 SignalList signal;
 void **params = alloca(sizeof(void *) * 3);
 /*
 * 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)
 {
 HWND thiswindow;
 int z, count;
 thiswindow = _dw_find_signal_window(window, NULL);
 * 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)
 {
 int z, count;
 void **params = alloca(sizeof(void *) * 3);
 params[2] = _dw_find_signal_window(window, NULL);

Mercurial > dwindows

comparison gtk4/dw.c @ 2323:4b04943319c5