dwindows: android/dw.cpp comparison

comparison android/dw.cpp @ 2529:060fdb2d807d

Android: Initial pixmap implmentation using Android Bitmap. Clean up some clang-tidy warnings reported by Android Studio.

author	bsmith@81767d24-ef19-dc11-ae90-00e081727c95
date	Mon, 10 May 2021 20:06:50 +0000
parents	03f6870bcfcc
children	b9923432cb1f

comparison

equal deleted inserted replaced

-:03f6870bcfcc
+:060fdb2d807d
 dw_event_post(startup);
 return;
 }
 else
 {
-char *argv[2] = {arg, NULL};
+char *argv[2] = {arg, nullptr};
 /* Wait for a short while to see if we get called again...
 * if we get called again we will be posted, if not...
 * just wait for the timer to expire.
 */
 *      path: The path to the Android app.
 */
 JNIEXPORT void JNICALL
 Java_org_dbsoft_dwindows_DWindows_dwindowsInit(JNIEnv* env, jobject obj, jstring path, jstring appID)
 {
-char *arg = strdup(env->GetStringUTFChars((jstring)path, NULL));
+char *arg = strdup(env->GetStringUTFChars((jstring)path, nullptr));
-const char *appid = env->GetStringUTFChars((jstring)appID, NULL);
+const char *appid = env->GetStringUTFChars((jstring)appID, nullptr);
 if(!_dw_main_event)
 {
 /* Save our class object pointer for later */
 _dw_obj = env->NewGlobalRef(obj);
 /* Save the JNIEnv for the main thread */
-pthread_key_create(&_dw_env_key, NULL);
+pthread_key_create(&_dw_env_key, nullptr);
 pthread_setspecific(_dw_env_key, env);
 /* Create the dwmain event */
 _dw_main_event = dw_event_new();
 }
 void *discfunction;
 void *data;
 } SignalHandler;
-static SignalHandler *DWRoot = NULL;
+static SignalHandler *DWRoot = nullptr;
 SignalHandler *_dw_get_handler(HWND window, int messageid)
 {
 SignalHandler *tmp = DWRoot;
 JNIEnv *env;
 return tmp;
 }
 tmp = tmp->next;
 }
 }
-return NULL;
+return nullptr;
 }
 typedef struct
 {
 ULONG message;
 */
 JNIEXPORT jint JNICALL
 Java_org_dbsoft_dwindows_DWindows_eventHandler(JNIEnv* env, jobject obj, jobject obj1, jobject obj2,
 jint message, jstring str1, jstring str2,
 jint inta, jint intb, jint intc, jint intd) {
-const char *utf81 = str1 ? env->GetStringUTFChars(str1, NULL) : NULL;
+const char *utf81 = str1 ? env->GetStringUTFChars(str1, nullptr) : nullptr;
-const char *utf82 = str2 ? env->GetStringUTFChars(str2, NULL) : NULL;
+const char *utf82 = str2 ? env->GetStringUTFChars(str2, nullptr) : nullptr;
 void *params[8] = { (void *)obj2, (void *)utf81, (void *)utf82,
 DW_INT_TO_POINTER(inta), DW_INT_TO_POINTER(intb),
-DW_INT_TO_POINTER(intc), DW_INT_TO_POINTER(intd), NULL };
+DW_INT_TO_POINTER(intc), DW_INT_TO_POINTER(intd), nullptr };
 return _dw_event_handler(obj1, params, message);
 }
 /* A more simple method for quicker calls */
 JNIEXPORT void JNICALL
 Java_org_dbsoft_dwindows_DWindows_eventHandlerSimple(JNIEnv* env, jobject obj, jobject obj1, jint message) {
-void *params[8] = { NULL };
+void *params[8] = { nullptr };
 _dw_event_handler(obj1, params, message);
 }
 /* Handler for notebook page changes */
 JNIEXPORT void JNICALL
 Java_org_dbsoft_dwindows_DWindows_eventHandlerNotebook(JNIEnv* env, jobject obj, jobject obj1, jint message, jlong pageID) {
-void *params[8] = { NULL };
+void *params[8] = { nullptr };
 params[3] = DW_INT_TO_POINTER(pageID);
 _dw_event_handler(obj1, params, message);
 }
 /* Handlers for HTML events */
 JNIEXPORT void JNICALL
 Java_org_dbsoft_dwindows_DWindows_eventHandlerHTMLResult(JNIEnv* env, jobject obj, jobject obj1,
 jint message, jstring htmlResult, jlong data) {
-const char *result = env->GetStringUTFChars(htmlResult, NULL);
+const char *result = env->GetStringUTFChars(htmlResult, nullptr);
-void *params[8] = { NULL, DW_POINTER(result), NULL, 0, 0, 0, 0, DW_INT_TO_POINTER(data) };
+void *params[8] = { nullptr, DW_POINTER(result), nullptr, 0, 0, 0, 0, DW_INT_TO_POINTER(data) };
 _dw_event_handler(obj1, params, message);
 }
 JNIEXPORT void JNICALL
 Java_org_dbsoft_dwindows_DWWebViewClient_eventHandlerHTMLChanged(JNIEnv* env, jobject obj, jobject obj1,
 jint message, jstring URI, jint status) {
-const char *uri = env->GetStringUTFChars(URI, NULL);
+const char *uri = env->GetStringUTFChars(URI, nullptr);
-void *params[8] = { NULL, DW_POINTER(uri), NULL, DW_INT_TO_POINTER(status), 0, 0, 0, 0 };
+void *params[8] = { nullptr, DW_POINTER(uri), nullptr, DW_INT_TO_POINTER(status), 0, 0, 0, 0 };
 _dw_event_handler(obj1, params, message);
 }
 JNIEXPORT void JNICALL
 Java_org_dbsoft_dwindows_DWindows_eventHandlerInt(JNIEnv* env, jobject obj, jobject obj1, jint message,
 jint inta, jint intb, jint intc, jint intd) {
-void *params[8] = { NULL, NULL, NULL,
+void *params[8] = { nullptr, nullptr, nullptr,
 DW_INT_TO_POINTER(inta), DW_INT_TO_POINTER(intb),
-DW_INT_TO_POINTER(intc), DW_INT_TO_POINTER(intd), NULL };
+DW_INT_TO_POINTER(intc), DW_INT_TO_POINTER(intd), nullptr };
 _dw_event_handler(obj1, params, message);
 }
 JNIEXPORT void JNICALL
 Java_org_dbsoft_dwindows_DWComboBox_eventHandlerInt(JNIEnv* env, jobject obj, jint message,
 jint inta, jint intb, jint intc, jint intd) {
-void *params[8] = { NULL, NULL, NULL,
+void *params[8] = { nullptr, nullptr, nullptr,
 DW_INT_TO_POINTER(inta), DW_INT_TO_POINTER(intb),
-DW_INT_TO_POINTER(intc), DW_INT_TO_POINTER(intd), NULL };
+DW_INT_TO_POINTER(intc), DW_INT_TO_POINTER(intd), nullptr };
 _dw_event_handler(obj, params, message);
 }
 JNIEXPORT void JNICALL
 Java_org_dbsoft_dwindows_DWSpinButton_eventHandlerInt(JNIEnv* env, jobject obj, jint message,
 jint inta, jint intb, jint intc, jint intd) {
-void *params[8] = { NULL, NULL, NULL,
+void *params[8] = { nullptr, nullptr, nullptr,
 DW_INT_TO_POINTER(inta), DW_INT_TO_POINTER(intb),
-DW_INT_TO_POINTER(intc), DW_INT_TO_POINTER(intd), NULL };
+DW_INT_TO_POINTER(intc), DW_INT_TO_POINTER(intd), nullptr };
 _dw_event_handler(obj, params, message);
 }
 JNIEXPORT void JNICALL
 Java_org_dbsoft_dwindows_DWListBox_eventHandlerInt(JNIEnv* env, jobject obj, jint message,
 jint inta, jint intb, jint intc, jint intd) {
-void *params[8] = { NULL, NULL, NULL,
+void *params[8] = { nullptr, nullptr, nullptr,
 DW_INT_TO_POINTER(inta), DW_INT_TO_POINTER(intb),
-DW_INT_TO_POINTER(intc), DW_INT_TO_POINTER(intd), NULL };
+DW_INT_TO_POINTER(intc), DW_INT_TO_POINTER(intd), nullptr };
 _dw_event_handler(obj, params, message);
 }
 /* Handler for Timer events */
 newsig->window = window;
 newsig->id = msgid;
 newsig->signalfunction = signalfunction;
 newsig->discfunction = discfunc;
 newsig->data = data;
-newsig->next = NULL;
+newsig->next = nullptr;
 if (!DWRoot)
 DWRoot = newsig;
 else
 {
-SignalHandler *prev = NULL, *tmp = DWRoot;
+SignalHandler *prev = nullptr, *tmp = DWRoot;
 while(tmp)
 {
 if(tmp->message == message &&
 tmp->window == window &&
 tmp->id == msgid &&
 /*
 * Sets the application ID used by this Dynamic Windows application instance.
 * Parameters:
 *         appid: A string typically in the form: com.company.division.application
-*         appname: The application name used on Windows or NULL.
+*         appname: The application name used on Windows or nullptr.
 * Returns:
 *         DW_ERROR_NONE after successfully setting the application ID.
 *         DW_ERROR_UNKNOWN if unsupported on this system.
 *         DW_ERROR_GENERAL if the application ID is not allowed.
 * Remarks:
 *          This must be called before dw_init().  If dw_init() is called first
 *          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 used on Windows and Android.  If NULL is passed the
+*          The appname is used on Windows and Android.  If nullptr is passed the
 *          detected name will be used, but a prettier name may be desired.
 */
 int API dw_app_id_set(const char *appid, const char *appname)
 {
 if(appid)
 *       title: Title bar text for dialog.
 *       defpath: The default path of the open dialog.
 *       ext: Default file extention.
 *       flags: DW_FILE_OPEN or DW_FILE_SAVE.
 * Returns:
-*       NULL on error. A malloced buffer containing
+*       nullptr on error. A malloced buffer containing
 *       the file path on success.
 *
 */
 char * API dw_file_browse(const char *title, const char *defpath, const char *ext, int flags)
 {
 if((env = (JNIEnv *)pthread_getspecific(_dw_env_key)))
 {
 // Use a long parameter
 jstring jstr = env->NewStringUTF(title);
-jstring path = NULL;
+jstring path = nullptr;
-jstring jext = NULL;
+jstring jext = nullptr;
 if(defpath)
 path = env->NewStringUTF(defpath);
 if(ext)
 jext = env->NewStringUTF(defpath);
 // First get the class that contains the method you need to call
 // Call the method on the object
 jstring jresult = (jstring)env->CallObjectMethod(_dw_obj, fileBrowse, jstr, path, jext, flags);
 if(jresult)
 return strdup(env->GetStringUTFChars(jresult, 0));
 }
-return NULL;
+return nullptr;
 }
 /*
 * Gets the contents of the default clipboard as text.
 * Parameters:
 *       None.
 * Returns:
-*       Pointer to an allocated string of text or NULL if clipboard empty or contents could not
+*       Pointer to an allocated string of text or nullptr if clipboard empty or contents could not
 *       be converted to text.
 */
 char * API dw_clipboard_get_text()
 {
 JNIEnv *env;
 if((env = (JNIEnv *)pthread_getspecific(_dw_env_key)))
 {
-const char *utf8 = NULL;
+const char *utf8 = nullptr;
 // First get the class that contains the method you need to call
 jclass clazz = _dw_find_class(env, DW_CLASS_NAME);
 // Get the method that you want to call
 jmethodID clipboardGetText = env->GetMethodID(clazz, "clipboardGetText",
 // Call the method on the object
 jstring result = (jstring)env->CallObjectMethod(_dw_obj, clipboardGetText);
 // Get the UTF8 string result
 if(result)
 utf8 = env->GetStringUTFChars(result, 0);
-return utf8 ? strdup(utf8) : NULL;
+return utf8 ? strdup(utf8) : nullptr;
 }
-return NULL;
+return nullptr;
 }
 /*
 * Sets the contents of the default clipboard to the supplied text.
 * Parameters:
 /*
 * Allocates and initializes a dialog struct.
 * Parameters:
 *           data: User defined data to be passed to functions.
 * Returns:
-*       A handle to a dialog or NULL on failure.
+*       A handle to a dialog or nullptr on failure.
 */
 DWDialog * API dw_dialog_new(void *data)
 {
 DWDialog *tmp = (DWDialog *)malloc(sizeof(DWDialog));
 {
 tmp->eve = dw_event_new();
 dw_event_reset(tmp->eve);
 tmp->data = data;
 tmp->done = FALSE;
-tmp->result = NULL;
+tmp->result = nullptr;
 }
 return tmp;
 }
 /*
 * Returns:
 *       The data passed to dw_dialog_dismiss().
 */
 void * API dw_dialog_wait(DWDialog *dialog)
 {
-void *tmp = NULL;
+void *tmp = nullptr;
 while(!dialog->done)
 {
 dw_main_iteration();
 }
 * Create a new Box to be packed.
 * Parameters:
 *       type: Either DW_VERT (vertical) or DW_HORZ (horizontal).
 *       pad: Number of pixels to pad around the box.
 * Returns:
-*       A handle to a box or NULL on failure.
+*       A handle to a box or nullptr on failure.
 */
 HWND API dw_box_new(int type, int pad)
 {
 JNIEnv *env;
 * Parameters:
 *       type: Either DW_VERT (vertical) or DW_HORZ (horizontal).
 *       pad: Number of pixels to pad around the box.
 *       title: Text to be displayined in the group outline.
 * Returns:
-*       A handle to a groupbox window or NULL on failure.
+*       A handle to a groupbox window or nullptr on failure.
 */
 HWND API dw_groupbox_new(int type, int pad, const char *title)
 {
 /* TODO: Just create a normal box for now */
 return dw_box_new(type, pad);
 * Create a new scrollable Box to be packed.
 * Parameters:
 *       type: Either DW_VERT (vertical) or DW_HORZ (horizontal).
 *       pad: Number of pixels to pad around the box.
 * Returns:
-*       A handle to a scrollbox or NULL on failure.
+*       A handle to a scrollbox or nullptr on failure.
 */
 HWND API dw_scrollbox_new(int type, int pad)
 {
 JNIEnv *env;
 * 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 dw_window_from_id() or 0L.
 * Returns:
-*       A handle to a button window or NULL on failure.
+*       A handle to a button window or nullptr on failure.
 */
 HWND API dw_button_new(const char *text, ULONG cid)
 {
 JNIEnv *env;
 * 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 dw_window_from_id() or 0L.
 * Returns:
-*       A handle to an entryfield window or NULL on failure.
+*       A handle to an entryfield window or nullptr on failure.
 */
 HWND API dw_entryfield_new(const char *text, ULONG cid)
 {
 return _dw_entryfield_new(text, cid, FALSE);
 }
 * 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 dw_window_from_id() or 0L.
 * Returns:
-*       A handle to an entryfield password window or NULL on failure.
+*       A handle to an entryfield password window or nullptr on failure.
 */
 HWND API dw_entryfield_password_new(const char *text, ULONG cid)
 {
 return _dw_entryfield_new(text, cid, TRUE);
 }
 * 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.
 * Returns:
-*       A handle to a bitmap button window or NULL on failure.
+*       A handle to a bitmap button window or nullptr on failure.
 */
 HWND API dw_bitmapbutton_new(const char *text, ULONG resid)
 {
 JNIEnv *env;
 *       id: An ID to be used with dw_window_from_id() or 0L.
 *       filename: Name of the file, omit extention to have
 *                 DW pick the appropriate file extension.
 *                 (BMP on OS/2 or Windows, XPM on Unix)
 * Returns:
-*       A handle to a bitmap button window or NULL on failure.
+*       A handle to a bitmap button window or nullptr on failure.
 */
 HWND API dw_bitmapbutton_new_from_file(const char *text, unsigned long cid, const char *filename)
 {
 JNIEnv *env;
 *       id: An ID to be used with dw_window_from_id() or 0L.
 *       data: The contents of the image
 *            (BMP or ICO on OS/2 or Windows, XPM on Unix)
 *       len: length of str
 * Returns:
-*       A handle to a bitmap button window or NULL on failure.
+*       A handle to a bitmap button window or nullptr on failure.
 */
 HWND API dw_bitmapbutton_new_from_data(const char *text, unsigned long cid, const char *data, int len)
 {
 JNIEnv *env;
 * 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 dw_window_from_id() or 0L.
 * Returns:
-*       A handle to a spinbutton window or NULL on failure.
+*       A handle to a spinbutton window or nullptr on failure.
 */
 HWND API dw_spinbutton_new(const char *text, ULONG cid)
 {
 JNIEnv *env;
 * 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 dw_window_from_id() or 0L.
 * Returns:
-*       A handle to a radio button window or NULL on failure.
+*       A handle to a radio button window or nullptr on failure.
 */
 HWND API dw_radiobutton_new(const char *text, ULONG cid)
 {
 JNIEnv *env;
 * Parameters:
 *       vertical: TRUE or FALSE if slider is vertical.
 *       increments: Number of increments available.
 *       id: An ID to be used with dw_window_from_id() or 0L.
 * Returns:
-*       A handle to a slider window or NULL on failure.
+*       A handle to a slider window or nullptr on failure.
 */
 HWND API dw_slider_new(int vertical, int increments, ULONG cid)
 {
 JNIEnv *env;
 * Create a new scrollbar window (widget) to be packed.
 * Parameters:
 *       vertical: TRUE or FALSE if scrollbar is vertical.
 *       id: An ID to be used with dw_window_from_id() or 0L.
 * Returns:
-*       A handle to a scrollbar window or NULL on failure.
+*       A handle to a scrollbar window or nullptr on failure.
 */
 HWND API dw_scrollbar_new(int vertical, ULONG cid)
 {
 return dw_slider_new(vertical, 100, cid);
 }
 /*
 * Create a new percent bar window (widget) to be packed.
 * Parameters:
 *       id: An ID to be used with dw_window_from_id() or 0L.
 * Returns:
-*       A handle to a percent bar window or NULL on failure.
+*       A handle to a percent bar window or nullptr on failure.
 */
 HWND API dw_percent_new(ULONG cid)
 {
 JNIEnv *env;
 * 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 dw_window_from_id() or 0L.
 * Returns:
-*       A handle to a checkbox window or NULL on failure.
+*       A handle to a checkbox window or nullptr on failure.
 */
 HWND API dw_checkbox_new(const char *text, ULONG cid)
 {
 JNIEnv *env;
 * Create a new listbox window (widget) to be packed.
 * Parameters:
 *       id: An ID to be used with dw_window_from_id() or 0L.
 *       multi: Multiple select TRUE or FALSE.
 * Returns:
-*       A handle to a listbox window or NULL on failure.
+*       A handle to a listbox window or nullptr on failure.
 */
 HWND API dw_listbox_new(ULONG cid, int multi)
 {
 JNIEnv *env;
 * Copies the given index item's text into 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.
-*          length: Length of the buffer (including NULL).
+*          length: Length of the buffer (including nullptr).
 */
 void API dw_listbox_get_text(HWND handle, unsigned int index, char *buffer, unsigned int length)
 {
 JNIEnv *env;
 * 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 dw_window_from_id() or 0L.
 * Returns:
-*       A handle to a combobox window or NULL on failure.
+*       A handle to a combobox window or nullptr on failure.
 */
 HWND API dw_combobox_new(const char *text, ULONG cid)
 {
 JNIEnv *env;
 /*
 * Create a new Multiline Editbox window (widget) to be packed.
 * Parameters:
 *       id: An ID to be used with dw_window_from_id() or 0L.
 * Returns:
-*       A handle to a MLE window or NULL on failure.
+*       A handle to a MLE window or nullptr on failure.
 */
 HWND API dw_mle_new(ULONG cid)
 {
 JNIEnv *env;
 * 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 dw_window_from_id() or 0L.
 * Returns:
-*       A handle to a status text window or NULL on failure.
+*       A handle to a status text window or nullptr on failure.
 */
 HWND API dw_status_text_new(const char *text, ULONG cid)
 {
 return _dw_text_new(text, cid, TRUE);
 }
 * 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 dw_window_from_id() or 0L.
 * Returns:
-*       A handle to a text window or NULL on failure.
+*       A handle to a text window or nullptr on failure.
 */
 HWND API dw_text_new(const char *text, ULONG cid)
 {
 return _dw_text_new(text, cid, FALSE);
 }
 /*
 * Creates a rendering context widget (window) to be packed.
 * Parameters:
 *       id: An id to be used with dw_window_from_id.
 * Returns:
-*       A handle to the widget or NULL on failure.
+*       A handle to the widget or nullptr on failure.
 */
 HWND API dw_render_new(unsigned long cid)
 {
 return 0;
 }
 * Create a tree object to be packed.
 * Parameters:
 *       id: An ID to be used for getting the resource from the
 *           resource file.
 * Returns:
-*       A handle to a tree window or NULL on failure.
+*       A handle to a tree window or nullptr on failure.
 */
 HWND API dw_tree_new(ULONG cid)
 {
 return 0;
 }
 *          title: The text title of the entry.
 *          icon: Handle to coresponding icon.
 *          parent: Parent handle or 0 if root.
 *          itemdata: Item specific data.
 * Returns:
-*       A handle to a tree item or NULL on failure.
+*       A handle to a tree item or nullptr on failure.
 */
 HTREEITEM API dw_tree_insert_after(HWND handle, HTREEITEM item, const char *title, HICN icon, HTREEITEM parent, void *itemdata)
 {
 return 0;
 }
 *          title: The text title of the entry.
 *          icon: Handle to coresponding icon.
 *          parent: Parent handle or 0 if root.
 *          itemdata: Item specific data.
 * Returns:
-*       A handle to a tree item or NULL on failure.
+*       A handle to a tree item or nullptr on failure.
 */
 HTREEITEM API dw_tree_insert(HWND handle, const char *title, HICN icon, HTREEITEM parent, void *itemdata)
 {
 return 0;
 }
 * Gets the text an item in a tree window (widget).
 * Parameters:
 *          handle: Handle to the tree containing the item.
 *          item: Handle of the item to be modified.
 * Returns:
-*       A malloc()ed buffer of item text to be dw_free()ed or NULL on error.
+*       A malloc()ed buffer of item text to be dw_free()ed or nullptr on error.
 */
 char * API dw_tree_get_title(HWND handle, HTREEITEM item)
 {
-return NULL;
+return nullptr;
 }
 /*
 * Gets the text an item in a tree window (widget).
 * Parameters:
 *          handle: Handle to the tree containing the item.
 *          item: Handle of the item to be modified.
 * Returns:
-*       A handle to a tree item or NULL on failure.
+*       A handle to a tree item or nullptr on failure.
 */
 HTREEITEM API dw_tree_get_parent(HWND handle, HTREEITEM item)
 {
 return 0;
 }
 * Gets the item data of a tree item.
 * Parameters:
 *          handle: Handle to the tree containing the item.
 *          item: Handle of the item to be modified.
 * Returns:
-*       A pointer to tree item data or NULL on failure.
+*       A pointer to tree item data or nullptr on failure.
 */
 void * API dw_tree_item_get_data(HWND handle, HTREEITEM item)
 {
-return NULL;
+return nullptr;
 }
 /*
 * Sets this item as the active selection.
 * Parameters:
 * Create a container object to be packed.
 * Parameters:
 *       id: An ID to be used for getting the resource from the
 *           resource file.
 * Returns:
-*       A handle to a container window or NULL on failure.
+*       A handle to a container window or nullptr on failure.
 */
 HWND API dw_container_new(ULONG cid, int multi)
 {
 return 0;
 }
 * Allocates memory used to populate a container.
 * Parameters:
 *          handle: Handle to the container window (widget).
 *          rowcount: The number of items to be populated.
 * Returns:
-*       Handle to container items allocated or NULL on error.
+*       Handle to container items allocated or nullptr on error.
 */
 void * API dw_container_alloc(HWND handle, int rowcount)
 {
-return NULL;
+return nullptr;
 }
 /*
 * Sets an item in specified row and column to the given data.
 * Parameters:
 *       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.
 * Returns:
-*       Pointer to data associated with first entry or NULL on error.
+*       Pointer to data associated with first entry or nullptr on error.
 */
 char * API dw_container_query_start(HWND handle, unsigned long flags)
 {
-return NULL;
+return nullptr;
 }
 /*
 * Continues an existing query of a container.
 * Parameters:
 *       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.
 * Returns:
-*       Pointer to data associated with next entry or NULL on error or completion.
+*       Pointer to data associated with next entry or nullptr on error or completion.
 */
 char * API dw_container_query_next(HWND handle, unsigned long flags)
 {
-return NULL;
+return nullptr;
 }
 /*
 * Cursors the item with the text speficied, and scrolls to that item.
 * Parameters:
 *          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.
 * Returns:
-*       Handle to the created icon or NULL on error.
+*       Handle to the created icon or nullptr on error.
 */
 HICN API dw_icon_load(unsigned long module, unsigned long resid)
 {
 return 0;
 }
 * Parameters:
 *       filename: Name of the file, omit extention to have
 *                 DW pick the appropriate file extension.
 *                 (ICO on OS/2 or Windows, XPM on Unix)
 * Returns:
-*       Handle to the created icon or NULL on error.
+*       Handle to the created icon or nullptr on error.
 */
 HICN API dw_icon_load_from_file(const char *filename)
 {
 return 0;
 }
 * Obtains an icon from data.
 * Parameters:
 *       data: Data for the icon (ICO on OS/2 or Windows, XPM on Unix, PNG on Mac)
 *       len: Length of the passed in data.
 * Returns:
-*       Handle to the created icon or NULL on error.
+*       Handle to the created icon or nullptr on error.
 */
 HICN API dw_icon_load_from_data(const char *data, int len)
 {
 return 0;
 }
 /*
 * Create a new MDI Frame to be packed.
 * Parameters:
 *       id: An ID to be used with dw_window_from_id or 0L.
 * Returns:
-*       Handle to the created MDI widget or NULL on error.
+*       Handle to the created MDI widget or nullptr on error.
 */
 HWND API dw_mdi_new(unsigned long cid)
 {
-return 0;
+return nullptr;
 }
 /*
 * Creates a splitbar window (widget) with given parameters.
 * Parameters:
 *       type: Value can be DW_VERT or DW_HORZ.
 *       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.
+*       A handle to a splitbar window or nullptr on failure.
 */
 HWND API dw_splitbar_new(int type, HWND topleft, HWND bottomright, unsigned long cid)
 {
-return 0;
+return nullptr;
 }
 /*
 * Sets the position of a splitbar (pecentage).
 * Parameters:
 /*
 * Create a bitmap object to be packed.
 * Parameters:
 *       id: An ID to be used with dw_window_from_id() or 0L.
 * Returns:
-*       Handle to the created bitmap widget or NULL on error.
+*       Handle to the created bitmap widget or nullptr on error.
 */
 HWND API dw_bitmap_new(ULONG cid)
 {
 JNIEnv *env;
 "(I)Landroid/widget/ImageView;");
 // Call the method on the object
 jobject result = env->NewWeakGlobalRef(env->CallObjectMethod(_dw_obj, mleNew, (int)cid));
 return result;
 }
-return 0;
+return nullptr;
+}
+/* Unified internal function to create an Android internal Bitmap */
+jobject _dw_jbitmap_new(unsigned long width, unsigned long height, const char *filename, const char *data, int len, int resid)
+{
+JNIEnv *env;
+if((env = (JNIEnv *)pthread_getspecific(_dw_env_key)))
+{
+// Construct a string
+jstring file = nullptr;
+if(filename)
+file = env->NewStringUTF(filename);
+// Construct a byte array
+jbyteArray bytearray = nullptr;
+if(data && len > 0)
+{
+bytearray = env->NewByteArray(len);
+env->SetByteArrayRegion(bytearray, 0, len, reinterpret_cast<const jbyte *>(data));
+}
+// First get the class that contains the method you need to call
+jclass clazz = _dw_find_class(env, DW_CLASS_NAME);
+// Get the method that you want to call
+jmethodID pixmapNew = env->GetMethodID(clazz, "pixmapNew",
+"(IILjava/lang/String;[BII)Landroid/graphics/Bitmap;");
+// Call the method on the object
+jobject result = env->NewGlobalRef(env->CallObjectMethod(_dw_obj, pixmapNew,
+(jint)width, (jint)height,
+file, bytearray, len, resid));
+// Clean up after the array now that we are finished
+//if(bytearray)
+//env->ReleaseByteArrayElements(bytearray, (jbyte *) data, 0);
+return result;
+}
+return nullptr;
+}
+void _dw_pixmap_get_dimensions(HPIXMAP pixmap)
+{
+JNIEnv *env;
+if(pixmap && (env = (JNIEnv *)pthread_getspecific(_dw_env_key)))
+{
+// First get the class that contains the method you need to call
+jclass clazz = _dw_find_class(env, DW_CLASS_NAME);
+// Get the method that you want to call
+jmethodID pixmapGetDimensions = env->GetMethodID(clazz, "pixmapGetDimensions",
+"(Landroid/graphics/Bitmap;)J");
+// Call the method on the object
+jlong dimensions = env->CallLongMethod(_dw_obj, pixmapGetDimensions, pixmap->bitmap);
+pixmap->width = dimensions & 0xFFFF;
+pixmap->height = dimensions >> 32;
+}
 }
 /*
 * Creates a pixmap with given parameters.
 * Parameters:
 *       handle: Window handle the pixmap is associated with.
 *       width: Width of the pixmap in pixels.
 *       height: Height of the pixmap in pixels.
 *       depth: Color depth of the pixmap.
 * Returns:
-*       A handle to a pixmap or NULL on failure.
+*       A handle to a pixmap or nullptr on failure.
 */
 HPIXMAP API dw_pixmap_new(HWND handle, unsigned long width, unsigned long height, int depth)
 {
-return 0;
+jobject jbitmap = _dw_jbitmap_new(width, height, nullptr, nullptr, 0, 0);
+if(jbitmap)
+{
+HPIXMAP pixmap = (HPIXMAP)calloc(1, sizeof(HPIXMAP));
+if(pixmap)
+{
+pixmap->width = width;
+pixmap->height = height;
+pixmap->bitmap = jbitmap;
+pixmap->handle = handle;
+return pixmap;
+}
+}
+return nullptr;
 }
 /*
 * Creates a pixmap from a file.
 * Parameters:
 *       handle: Window handle the pixmap is associated with.
 *       filename: Name of the file, omit extention to have
 *                 DW pick the appropriate file extension.
 *                 (BMP on OS/2 or Windows, XPM on Unix)
 * Returns:
-*       A handle to a pixmap or NULL on failure.
+*       A handle to a pixmap or nullptr on failure.
 */
 HPIXMAP API dw_pixmap_new_from_file(HWND handle, const char *filename)
 {
-return 0;
+jobject jbitmap = _dw_jbitmap_new(0, 0, filename, nullptr, 0, 0);
+if(jbitmap)
+{
+HPIXMAP pixmap = (HPIXMAP)calloc(1, sizeof(HPIXMAP));
+if(pixmap)
+{
+pixmap->bitmap = jbitmap;
+pixmap->handle = handle;
+_dw_pixmap_get_dimensions(pixmap);
+return pixmap;
+}
+}
+return nullptr;
 }
 /*
 * Creates a pixmap from data in memory.
 * Parameters:
 *       handle: Window handle the pixmap is associated with.
 *       data: Source of the image data
 *                 (BMP on OS/2 or Windows, XPM on Unix)
 *       len: Length of data
 * Returns:
-*       A handle to a pixmap or NULL on failure.
+*       A handle to a pixmap or nullptr on failure.
 */
 HPIXMAP API dw_pixmap_new_from_data(HWND handle, const char *data, int len)
 {
-return 0;
+jobject jbitmap = _dw_jbitmap_new(0, 0, nullptr, data, len, 0);
+if(jbitmap)
+{
+HPIXMAP pixmap = (HPIXMAP)calloc(1, sizeof(HPIXMAP));
+if(pixmap)
+{
+pixmap->bitmap = jbitmap;
+pixmap->handle = handle;
+_dw_pixmap_get_dimensions(pixmap);
+return pixmap;
+}
+}
+return nullptr;
 }
 /*
 * Sets the transparent color for a pixmap.
 * Parameters:
 * Creates a pixmap from internal resource graphic specified by id.
 * Parameters:
 *       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.
+*       A handle to a pixmap or nullptr on failure.
 */
 HPIXMAP API dw_pixmap_grab(HWND handle, ULONG resid)
 {
-return 0;
+jobject jbitmap = _dw_jbitmap_new(0, 0, nullptr, nullptr, 0, (int)resid);
+if(jbitmap)
+{
+HPIXMAP pixmap = (HPIXMAP)calloc(1, sizeof(HPIXMAP));
+if(pixmap)
+{
+pixmap->bitmap = jbitmap;
+pixmap->handle = handle;
+_dw_pixmap_get_dimensions(pixmap);
+return pixmap;
+}
+}
+return nullptr;
 }
 /*
 * Sets the font used by a specified pixmap.
 * Normally the pixmap font is obtained from the associated window handle.
 *       pixmap: Handle to a pixmap returned by
 *               dw_pixmap_new..
 */
 void API dw_pixmap_destroy(HPIXMAP pixmap)
 {
+if(pixmap)
+{
+JNIEnv *env;
+if(pixmap && (env = (JNIEnv *)pthread_getspecific(_dw_env_key)))
+{
+env->DeleteGlobalRef(pixmap->bitmap);
+free(pixmap);
+}
+}
 }
 /*
 * Copies from one item to another.
 * Parameters:
 /*
 * 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.
+*       Handle to the created calendar or nullptr on error.
 */
 HWND API dw_calendar_new(ULONG cid)
 {
 JNIEnv *env;
 /*
 * Gets the year, month and day set in the calendar widget.
 * Parameters:
 *       handle: The handle to the calendar returned by dw_calendar_new().
-*       year: Variable to store the year or NULL.
+*       year: Variable to store the year or nullptr.
-*       month: Variable to store the month or NULL.
+*       month: Variable to store the month or nullptr.
-*       day: Variable to store the day or NULL.
+*       day: Variable to store the day or nullptr.
 */
 void API dw_calendar_get_date(HWND handle, unsigned int *year, unsigned int *month, unsigned int *day)
 {
 JNIEnv *env;
 /*
 * Create a new HTML window (widget) to be packed.
 * Parameters:
 *       id: An ID to be used with dw_window_from_id() or 0L.
 * Returns:
-*       Handle to the created html widget or NULL on error.
+*       Handle to the created html widget or nullptr on error.
 */
 HWND API dw_html_new(unsigned long cid)
 {
 JNIEnv *env;
 }
 /*
 * Returns the current X and Y coordinates of the mouse pointer.
 * Parameters:
-*       x: Pointer to variable to store X coordinate or NULL.
+*       x: Pointer to variable to store X coordinate or nullptr.
-*       y: Pointer to variable to store Y coordinate or NULL.
+*       y: Pointer to variable to store Y coordinate or nullptr.
 */
 void API dw_pointer_query_pos(long *x, long *y)
 {
 }
 /*
 * Create a menu object to be popped up.
 * Parameters:
 *       id: An ID to be used associated with this menu.
 * Returns:
-*       Handle to the created menu or NULL on error.
+*       Handle to the created menu or nullptr on error.
 */
 HMENUI API dw_menu_new(ULONG cid)
 {
 return 0;
 }
 /*
 * Create a menubar on a window.
 * Parameters:
 *       location: Handle of a window frame to be attached to.
 * Returns:
-*       Handle to the created menu bar or NULL on error.
+*       Handle to the created menu bar or nullptr on error.
 */
 HMENUI API dw_menubar_new(HWND location)
 {
 return 0;
 }
 *       title: The title text on the menu item to be added.
 *       id: An ID to be used for message passing.
 *       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.
+*       submenu: Handle to an existing menu to be a submenu or nullptr.
 * Returns:
-*       Handle to the created menu item or NULL on error.
+*       Handle to the created menu item or nullptr on error.
 */
 HWND API dw_menu_append_item(HMENUI menux, const char *title, ULONG itemid, ULONG flags, int end, int check, HMENUI submenux)
 {
 return 0;
 }
 * Create a notebook object to be packed.
 * Parameters:
 *       id: An ID to be used for getting the resource from the
 *           resource file.
 * Returns:
-*       Handle to the created notebook or NULL on error.
+*       Handle to the created notebook or nullptr on error.
 */
 HWND API dw_notebook_new(ULONG cid, int top)
 {
 JNIEnv *env;
 * Parameters:
 *       owner: The Owner's window handle or HWND_DESKTOP.
 *       title: The Window title.
 *       flStyle: Style flags.
 * Returns:
-*       Handle to the created window or NULL on error.
+*       Handle to the created window or nullptr on error.
 */
 HWND API dw_window_new(HWND hwndOwner, const char *title, ULONG flStyle)
 {
 JNIEnv *env;
 /*
 * Returns the current font for the specified window.
 * Parameters:
 *           handle: The window handle from which to obtain the font.
 * Returns:
-*       A malloc()ed font name string to be dw_free()ed or NULL on error.
+*       A malloc()ed font name string to be dw_free()ed or nullptr on error.
 */
 char * API dw_window_get_font(HWND handle)
 {
-return NULL;
+return nullptr;
 }
 /* Allows the user to choose a font using the system's font chooser dialog.
 * Parameters:
 *       currfont: current font
 * Returns:
-*       A malloced buffer with the selected font or NULL on error.
+*       A malloced buffer with the selected font or nullptr on error.
 */
 char * API dw_font_choose(const char *currfont)
 {
-return NULL;
+return nullptr;
 }
 /*
 * Sets the default font used on text based widgets.
 * Parameters:
 /*
 * Gets the text used for a given window.
 * Parameters:
 *       handle: Handle to the window.
 * Returns:
-*       The text associsated with a given window or NULL on error.
+*       The text associsated with a given window or nullptr on error.
 */
 char * API dw_window_get_text(HWND handle)
 {
 JNIEnv *env;
 if((env = (JNIEnv *)pthread_getspecific(_dw_env_key)))
 {
-const char *utf8 = NULL;
+const char *utf8 = nullptr;
 // First get the class that contains the method you need to call
 jclass clazz = _dw_find_class(env, DW_CLASS_NAME);
 // Get the method that you want to call
 jmethodID windowGetText = env->GetMethodID(clazz, "windowGetText",
 // Call the method on the object
 jstring result = (jstring)env->CallObjectMethod(_dw_obj, windowGetText, handle);
 // Get the UTF8 string result
 if(result)
 utf8 = env->GetStringUTFChars(result, 0);
-return utf8 ? strdup(utf8) : NULL;
+return utf8 ? strdup(utf8) : nullptr;
 }
-return NULL;
+return nullptr;
 }
 /*
 * Sets the text used for a given window.
 * Parameters:
 *       handle: Handle to the window.
 *       id: An ID to be used to specify the icon,
 *           (pass 0 if you use the filename param)
 *       data: memory buffer containing image (Bitmap on OS/2 or
 *                 Windows and a pixmap on Unix, pass
-*                 NULL if you use the id param)
+*                 nullptr if you use the id param)
 *       len: Length of data passed
 */
 void API dw_window_set_bitmap_from_data(HWND handle, unsigned long cid, const char *data, int len)
 {
 JNIEnv *env;
 if(handle && (env = (JNIEnv *)pthread_getspecific(_dw_env_key)))
 {
 // Construct a byte array
-jbyteArray bytearray = NULL;
+jbyteArray bytearray = nullptr;
-if(data && len > 0) {
+if(data && len > 0)
+{
 bytearray = env->NewByteArray(len);
 env->SetByteArrayRegion(bytearray, 0, len, reinterpret_cast<const jbyte *>(data));
 }
 // First get the class that contains the method you need to call
 jclass clazz = _dw_find_class(env, DW_CLASS_NAME);
 jmethodID windowSetBitmapFromData = env->GetMethodID(clazz, "windowSetBitmapFromData",
 "(Landroid/view/View;I[BI)V");
 // Call the method on the object
 env->CallVoidMethod(_dw_obj, windowSetBitmapFromData, handle, (int)cid, bytearray, len);
 // Clean up after the array now that we are finished
-//env->ReleaseByteArrayElements(bytearray, (jbyte *) data, 0);
+//if(bytearray)
+//env->ReleaseByteArrayElements(bytearray, (jbyte *) data, 0);
 }
 }
 /*
 * Sets the bitmap used for a given static window.
 *       handle: Handle to the window.
 *       id: An ID to be used to specify the icon,
 *           (pass 0 if you use the filename param)
 *       filename: a path to a file (Bitmap on OS/2 or
 *                 Windows and a pixmap on Unix, pass
-*                 NULL if you use the id param)
+*                 nullptr if you use the id param)
 */
 void API dw_window_set_bitmap(HWND handle, unsigned long resid, const char *filename)
 {
 JNIEnv *env;
 if(handle && (env = (JNIEnv *)pthread_getspecific(_dw_env_key)))
 {
 // Construct a string
-jstring jstr = NULL;
+jstring jstr = nullptr;
 if(filename) {
 jstr = env->NewStringUTF(filename);
 }
 // First get the class that contains the method you need to call
 jclass clazz = _dw_find_class(env, DW_CLASS_NAME);
 * Gets the child window handle with specified ID.
 * Parameters:
 *       handle: Handle to the parent window.
 *       id: Integer ID of the child.
 * Returns:
-*       HWND of window with ID or NULL on error.
+*       HWND of window with ID or nullptr on error.
 */
 HWND API dw_window_from_id(HWND handle, int id)
 {
 JNIEnv *env;
 HWND retval = 0;
 /*
 * Gets the size the system thinks the widget should be.
 * Parameters:
 *       handle: Window (widget) handle of the item to query.
-*       width: Width in pixels of the item or NULL if not needed.
+*       width: Width in pixels of the item or nullptr if not needed.
-*       height: Height in pixels of the item or NULL if not needed.
+*       height: Height in pixels of the item or nullptr if not needed.
 */
 void API dw_window_get_preferred_size(HWND handle, int *width, int *height)
 {
 }
 /*
 * Gets the position and size of a given window (widget).
 * Parameters:
 *          handle: Window (widget) handle.
-*          x: X location from the bottom left or NULL.
+*          x: X location from the bottom left or nullptr.
-*          y: Y location from the bottom left or NULL.
+*          y: Y location from the bottom left or nullptr.
-*          width: Width of the widget or NULL.
+*          width: Width of the widget or nullptr.
-*          height: Height of the widget or NULL.
+*          height: Height of the widget or nullptr.
 */
 void API dw_window_get_pos_size(HWND handle, LONG *x, LONG *y, ULONG *width, ULONG *height)
 {
 }
 * Gets a named user data item from a window handle.
 * Parameters:
 *       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.
+*       Pointer to data or nullptr if no data is available.
 */
 void * API dw_window_get_data(HWND window, const char *dataname)
 {
 JNIEnv *env;
-void *retval = NULL;
+void *retval = nullptr;
 if((env = (JNIEnv *)pthread_getspecific(_dw_env_key)))
 {
 // Construct a String
 jstring jstr = env->NewStringUTF(dataname);
 *       sigfunc: The pointer to the function to be used as the callback.
 *       data: User data to be passed to the handler function.
 */
 void API dw_signal_connect(HWND window, const char *signame, void *sigfunc, void *data)
 {
-dw_signal_connect_data(window, signame, sigfunc, NULL, data);
+dw_signal_connect_data(window, signame, sigfunc, nullptr, data);
 }
 /*
 * Add a callback to a window event with a closure callback.
 * Parameters:
 * Parameters:
 *       window: Window handle of callback to be removed.
 */
 void API dw_signal_disconnect_by_name(HWND window, const char *signame)
 {
-SignalHandler *prev = NULL, *tmp = DWRoot;
+SignalHandler *prev = nullptr, *tmp = DWRoot;
 ULONG message;
 if(!window || !signame || (message = _dw_findsigmessage(signame)) == 0)
 return;
 * Parameters:
 *       window: Window handle of callback to be removed.
 */
 void API dw_signal_disconnect_by_window(HWND window)
 {
-SignalHandler *prev = NULL, *tmp = DWRoot;
+SignalHandler *prev = nullptr, *tmp = DWRoot;
 while(tmp)
 {
 if(tmp->window == window)
 {
 *       window: Window handle of callback to be removed.
 *       data: Pointer to the data to be compared against.
 */
 void API dw_signal_disconnect_by_data(HWND window, void *data)
 {
-SignalHandler *prev = NULL, *tmp = DWRoot;
+SignalHandler *prev = nullptr, *tmp = DWRoot;
 while(tmp)
 {
 if(tmp->window == window && tmp->data == data)
 {
 return -1;
 if((len = strlen(name)) == 0)
 return   -1;
-/* Lenth + "lib" + ".so" + NULL */
+/* Lenth + "lib" + ".so" + nullptr */
 newname = (char *)malloc(len + 7);
 if(!newname)
 return -1;
 sprintf(newname, "lib%s.so", name);
 _dw_strlwr(newname);
 *handle = dlopen(newname, RTLD_NOW);
-if(*handle == NULL)
+if(*handle == nullptr)
 {
 strncpy(errorbuf, dlerror(), 1024);
 printf("%s\n", errorbuf);
 sprintf(newname, "lib%s.so", name);
 *handle = dlopen(newname, RTLD_NOW);
 }
 free(newname);
-return (NULL == *handle) ? -1 : 0;
+return (nullptr == *handle) ? -1 : 0;
 }
 /* Queries the address of a symbol within open handle.
 * Parameters:
 *         handle: Module handle returned by dw_module_load()
 if(strlen(name) == 0)
 return   -1;
 *func = (void*)dlsym(handle, name);
-return   (NULL == *func);
+return   (nullptr == *func);
 }
 /* Frees the shared library previously opened.
 * Parameters:
 *         handle: Module handle returned by dw_module_load()
 */
 HMTX API dw_mutex_new(void)
 {
 HMTX mutex = (HMTX)malloc(sizeof(pthread_mutex_t));
-pthread_mutex_init(mutex, NULL);
+pthread_mutex_init(mutex, nullptr);
 return mutex;
 }
 /*
 * Closes a semaphore created by dw_mutex_new().
 if(_dw_thread == pthread_self())
 {
 while(pthread_mutex_trylock(mutex) != 0)
 {
 /* Process any pending events */
-if(g_main_context_pending(NULL))
+if(g_main_context_pending(nullptr))
 {
 do
 {
-g_main_context_iteration(NULL, FALSE);
+g_main_context_iteration(nullptr, FALSE);
 }
-while(g_main_context_pending(NULL));
+while(g_main_context_pending(nullptr));
 }
 else
 sched_yield();
 }
 }
 HEV API dw_event_new(void)
 {
 HEV eve = (HEV)malloc(sizeof(struct _dw_unix_event));
 if(!eve)
-return NULL;
+return nullptr;
 /* We need to be careful here, mutexes on Linux are
 * FAST by default but are error checking on other
 * systems such as FreeBSD and OS/2, perhaps others.
 */
-pthread_mutex_init (&(eve->mutex), NULL);
+pthread_mutex_init (&(eve->mutex), nullptr);
 pthread_mutex_lock (&(eve->mutex));
-pthread_cond_init (&(eve->event), NULL);
+pthread_cond_init (&(eve->event), nullptr);
 pthread_mutex_unlock (&(eve->mutex));
 eve->alive = 1;
 eve->posted = 0;
 if(!eve)
 return DW_ERROR_NON_INIT;
 pthread_mutex_lock (&(eve->mutex));
 pthread_cond_broadcast (&(eve->event));
-pthread_cond_init (&(eve->event), NULL);
+pthread_cond_init (&(eve->event), nullptr);
 eve->posted = 0;
 pthread_mutex_unlock (&(eve->mutex));
 return DW_ERROR_NONE;
 }
 pthread_mutex_lock (&((*eve)->mutex));
 pthread_cond_destroy (&((*eve)->event));
 pthread_mutex_unlock (&((*eve)->mutex));
 pthread_mutex_destroy (&((*eve)->mutex));
 free(*eve);
-*eve = NULL;
+*eve = nullptr;
 return DW_ERROR_NONE;
 }
 struct _dw_seminfo {
 int bytesread, connectcount = 1, maxfd, z, posted = 0;
 char command;
 sigset_t mask;
 sigfillset(&mask); /* Mask all allowed signals */
-pthread_sigmask(SIG_BLOCK, &mask, NULL);
+pthread_sigmask(SIG_BLOCK, &mask, nullptr);
 /* problems */
 if(tmpsock[1] == -1)
 {
 free(array);
 maxfd = array[z].fd;
 FD_SET(array[z].fd, &rd);
 }
-if(select(maxfd+1, &rd, NULL, NULL, NULL) == -1)
+if(select(maxfd+1, &rd, nullptr, nullptr, nullptr) == -1)
 {
 free(array);
 return;
 }
 struct sockaddr_un un;
 int ev, *tmpsock = (int *)malloc(sizeof(int)*2);
 DWTID dwthread;
 if(!tmpsock)
-return NULL;
+return nullptr;
 tmpsock[0] = socket(AF_UNIX, SOCK_STREAM, 0);
 ev = socket(AF_UNIX, SOCK_STREAM, 0);
 memset(&un, 0, sizeof(un));
 un.sun_family=AF_UNIX;
 if(tmpsock[1] > -1)
 close(tmpsock[1]);
 if(ev > -1)
 close(ev);
 free(tmpsock);
-return NULL;
+return nullptr;
 }
 /* Create a thread to handle this event semaphore */
-pthread_create(&dwthread, NULL, (void *(*)(void *))_dw_handle_sem, (void *)tmpsock);
+pthread_create(&dwthread, nullptr, (void *(*)(void *))_dw_handle_sem, (void *)tmpsock);
 return (HEV)DW_INT_TO_POINTER(ev);
 }
 /* Open an already existing named event semaphore.
 * Parameters:
 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;
+return nullptr;
 un.sun_family=AF_UNIX;
 mkdir("/tmp/.dw", S_IWGRP|S_IWOTH);
 strcpy(un.sun_path, "/tmp/.dw/");
 strcat(un.sun_path, name);
 *                  or -1 if indefinite.
 */
 int API dw_named_event_wait(HEV eve, unsigned long timeout)
 {
 fd_set rd;
-struct timeval tv, *useme = NULL;
+struct timeval tv, *useme = nullptr;
 int retval = 0;
 char tmp;
 if(DW_POINTER_TO_INT(eve) < 0)
 return DW_ERROR_NON_INIT;
 /* Signal wait */
 tmp = (char)2;
 retval = write(DW_POINTER_TO_INT(eve), &tmp, 1);
 if(retval == 1)
-retval = select(DW_POINTER_TO_INT(eve)+1, &rd, NULL, NULL, useme);
+retval = select(DW_POINTER_TO_INT(eve)+1, &rd, nullptr, nullptr, useme);
 /* Signal done waiting. */
 tmp = (char)3;
 if(retval == 1)
 retval = write(DW_POINTER_TO_INT(eve), &tmp, 1);
 */
 void API _dw_init_thread(void)
 {
 JNIEnv *env;
-_dw_jvm->AttachCurrentThread(&env, NULL);
+_dw_jvm->AttachCurrentThread(&env, nullptr);
 pthread_setspecific(_dw_env_key, env);
 }
 /*
 * Generally an internal function called from a terminating
 /*
 * Setup thread independent color sets.
 */
 void _dwthreadstart(void *data)
 {
-void (*threadfunc)(void *) = NULL;
+void (*threadfunc)(void *) = nullptr;
 void **tmp = (void **)data;
 threadfunc = (void (*)(void *))tmp[0];
 /* Initialize colors */
 snprintf(namebuf, 1024, "/tmp/.dw/%s", name);
 if((handle->fd = open(namebuf, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR)) < 0)
 {
 free(handle);
-return NULL;
+return nullptr;
 }
 if(ftruncate(handle->fd, size))
 {
 close(handle->fd);
 free(handle);
-return NULL;
+return nullptr;
 }
 /* attach the shared memory segment to our process's address space. */
-*dest = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, handle->fd, 0);
+*dest = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, handle->fd, 0);
 if(*dest == MAP_FAILED)
 {
 close(handle->fd);
-*dest = NULL;
+*dest = nullptr;
 free(handle);
-return NULL;
+return nullptr;
 }
 handle->size = size;
 handle->sid = getsid(0);
 handle->path = strdup(namebuf);
 snprintf(namebuf, 1024, "/tmp/.dw/%s", name);
 if((handle->fd = open(namebuf, O_RDWR)) < 0)
 {
 free(handle);
-return NULL;
+return nullptr;
 }
 /* attach the shared memory segment to our process's address space. */
-*dest = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, handle->fd, 0);
+*dest = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, handle->fd, 0);
 if(*dest == MAP_FAILED)
 {
 close(handle->fd);
-*dest = NULL;
+*dest = nullptr;
 free(handle);
-return NULL;
+return nullptr;
 }
 handle->size = size;
 handle->sid = -1;
-handle->path = NULL;
+handle->path = nullptr;
 return handle;
 }
 /*
 int rc;
 tmp[0] = func;
 tmp[1] = data;
-rc = pthread_create(&dwthread, NULL, (void *(*)(void *))_dwthreadstart, (void *)tmp);
+rc = pthread_create(&dwthread, nullptr, (void *(*)(void *))_dwthreadstart, (void *)tmp);
 if(rc == 0)
 return dwthread;
 return (DWTID)DW_ERROR_UNKNOWN;
 }
 /*
 * Ends execution of current thread immediately.
 */
 void API dw_thread_end(void)
 {
-pthread_exit(NULL);
+pthread_exit(nullptr);
 }
 /*
 * Returns the current thread's ID.
 */
 *       flags: Flags to initially configure the print object.
 *       pages: Number of pages to print.
 *       drawfunc: The pointer to the function to be used as the callback.
 *       drawdata: User data to be passed to the handler function.
 * Returns:
-*       A handle to the print object or NULL on failure.
+*       A handle to the print object or nullptr on failure.
 */
 HPRINT API dw_print_new(const char *jobname, unsigned long flags, unsigned int pages, void *drawfunc, void *drawdata)
 {
-return NULL;
+return nullptr;
 }
 /*
 * Runs the print job, causing the draw page callbacks to fire.
 * Parameters:
 /*
 * Creates a new system notification if possible.
 * Parameters:
 *         title: The short title of the notification.
-*         imagepath: Path to an image to display or NULL if none.
+*         imagepath: Path to an image to display or nullptr if none.
 *         description: A longer description of the notification,
-*                      or NULL if none is necessary.
+*                      or nullptr if none is necessary.
 * Returns:
 *         A handle to the notification which can be used to attach a "clicked" event if desired,
-*         or NULL if it fails or notifications are not supported by the system.
+*         or nullptr 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 API dw_notification_new(const char *title, const char *imagepath, const char *description, ...)
 if((env = (JNIEnv *)pthread_getspecific(_dw_env_key)))
 {
 // Construct a String
 jstring appid = env->NewStringUTF(_dw_app_id);
 jstring ntitle = env->NewStringUTF(title);
-jstring ndesc = NULL;
+jstring ndesc = nullptr;
-jstring image = NULL;
+jstring image = nullptr;
 if(description)
 {
 va_list args;
 char outbuf[1025] = {0};
 * Converts a UTF-8 encoded string into a wide string.
 * Parameters:
 *       utf8string: UTF-8 encoded source string.
 * Returns:
 *       Wide string that needs to be freed with dw_free()
-*       or NULL on failure.
+*       or nullptr on failure.
 */
 wchar_t * API dw_utf8_to_wchar(const char *utf8string)
 {
 size_t buflen = strlen(utf8string) + 1;
 wchar_t *temp = (wchar_t *)malloc(buflen * sizeof(wchar_t));
 * Converts a wide string into a UTF-8 encoded string.
 * Parameters:
 *       wstring: Wide source string.
 * Returns:
 *       UTF-8 encoded string that needs to be freed with dw_free()
-*       or NULL on failure.
+*       or nullptr on failure.
 */
 char * API dw_wchar_to_utf8(const wchar_t *wstring)
 {
 size_t bufflen = 8 * wcslen(wstring) + 1;
 char *temp = (char *)malloc(bufflen);

Mercurial > dwindows

comparison android/dw.cpp @ 2529:060fdb2d807d