void WMFreeMaskedEvents(WMMaskedEvents* maskev) { W_MaskedEvents* mask = (W_MaskedEvents*)maskev; WMFreeArray(mask->procs); WMFreeArray(mask->data); wfree(mask); return; }
Bool W_CheckIdleHandlers(void) { IdleHandler *handler; WMArray *handlerCopy; WMArrayIterator iter; if (!idleHandler || WMGetArrayItemCount(idleHandler)==0) { W_FlushIdleNotificationQueue(); /* make sure an observer in queue didn't added an idle handler */ return (idleHandler!=NULL && WMGetArrayItemCount(idleHandler)>0); } handlerCopy = WMDuplicateArray(idleHandler); WM_ITERATE_ARRAY(handlerCopy, handler, iter) { /* check if the handler still exist or was removed by a callback */ if (WMGetFirstInArray(idleHandler, handler) == WANotFound) continue; (*handler->callback)(handler->clientData); WMDeleteIdleHandler(handler); } WMFreeArray(handlerCopy); W_FlushIdleNotificationQueue(); /* this is not necesarrily False, because one handler can re-add itself */ return (WMGetArrayItemCount(idleHandler)>0); }
static void makeShortcutCommand(WMenu * menu, WMenuEntry * entry) { WWindow *wwin = (WWindow *) entry->clientdata; WScreen *scr = wwin->screen_ptr; int index = entry->order - wlengthof(menu_options_entries); /* Parameter not used, but tell the compiler that it is ok */ (void) menu; if (scr->shortcutWindows[index]) { WMFreeArray(scr->shortcutWindows[index]); scr->shortcutWindows[index] = NULL; } if (wwin->flags.selected && scr->selected_windows) { scr->shortcutWindows[index] = WMDuplicateArray(scr->selected_windows); /*WMRemoveFromArray(scr->shortcutWindows[index], wwin); WMInsertInArray(scr->shortcutWindows[index], 0, wwin); */ } else { scr->shortcutWindows[index] = WMCreateArray(4); WMAddToArray(scr->shortcutWindows[index], wwin); } wSelectWindow(wwin, !wwin->flags.selected); XFlush(dpy); wusleep(3000); wSelectWindow(wwin, !wwin->flags.selected); XFlush(dpy); }
/* * WMArray *array; * WDMCheckPLArray(pl, spec, &array); */ Bool WDMCheckPLArray(WMPropList * pl, void *def, void *target) { WMArray **array_target = (WMArray **) target; WDMArraySpec *spec = (WDMArraySpec *) def; void *entry = NULL; int i, count; WDMDebug("WDMCheckPLArray(%p, %p, %p)\n", (void *)pl, def, target); if (!pl || !WMIsPLArray(pl)) return False; count = WMGetPropListItemCount(pl); *array_target = WMCreateArrayWithDestructor(count, spec->destructor); for (i = 0; i < count; ++i) { if (!(*spec->checker) (WMGetFromPLArray(pl, i), spec->data, &entry)) { WMFreeArray(*array_target); *array_target = NULL; return False; } if (spec->addnull == True || entry != NULL) { WMAddToArray(*array_target, entry); } } return True; }
static void destroySplitView(WMSplitView * sPtr) { WMFreeArray(sPtr->subviews); WMRemoveNotificationObserver(sPtr); wfree(sPtr); }
static void destroyNode(void *data) { WMTreeNode *aNode = (WMTreeNode *) data; if (aNode->destructor) { (*aNode->destructor) (aNode->data); } if (aNode->leaves) { WMFreeArray(aNode->leaves); } wfree(aNode); }
static void releasePropListByCount(WMPropList * plist, int count) { WMPropList *key, *value; WMHashEnumerator e; int i; plist->retainCount -= count; switch (plist->type) { case WPLString: if (plist->retainCount < 1) { wfree(plist->d.string); wfree(plist); } break; case WPLData: if (plist->retainCount < 1) { WMReleaseData(plist->d.data); wfree(plist); } break; case WPLArray: for (i = 0; i < WMGetArrayItemCount(plist->d.array); i++) { releasePropListByCount(WMGetFromArray(plist->d.array, i), count); } if (plist->retainCount < 1) { WMFreeArray(plist->d.array); wfree(plist); } break; case WPLDictionary: e = WMEnumerateHashTable(plist->d.dict); while (WMNextHashEnumeratorItemAndKey(&e, (void **)&value, (void **)&key)) { releasePropListByCount(key, count); releasePropListByCount(value, count); } if (plist->retainCount < 1) { WMFreeHashTable(plist->d.dict); wfree(plist); } break; default: wwarning(_("Used proplist functions on non-WMPropLists objects")); wassertr(False); break; } }
/* * This functions will handle input events on all registered file descriptors. * Input: * - waitForInput - True if we want the function to wait until an event * appears on a file descriptor we watch, False if we * want the function to immediately return if there is * no data available on the file descriptors we watch. * - inputfd - Extra input file descriptor to watch for input. * This is only used when called from wevent.c to watch * on ConnectionNumber(dpy) to avoid blocking of X events * if we wait for input from other file handlers. * Output: * if waitForInput is False, the function will return False if there are no * input handlers registered, or if there is no data * available on the registered ones, and will return True * if there is at least one input handler that has data * available. * if waitForInput is True, the function will return False if there are no * input handlers registered, else it will block until an * event appears on one of the file descriptors it watches * and then it will return True. * * If the retured value is True, the input handlers for the corresponding file * descriptors are also called. * * Parametersshould be passed like this: * - from wevent.c: * waitForInput - apropriate value passed by the function who called us * inputfd = ConnectionNumber(dpy) * - from wutil.c: * waitForInput - apropriate value passed by the function who called us * inputfd = -1 * */ Bool W_HandleInputEvents(Bool waitForInput, int inputfd) { #if defined(HAVE_POLL) && defined(HAVE_POLL_H) && !defined(HAVE_SELECT) struct poll fd *fds; InputHandler *handler; int count, timeout, nfds, i, extrafd; extrafd = (inputfd < 0) ? 0 : 1; if (inputHandler) nfds = WMGetArrayItemCount(inputHandler); else nfds = 0; if (!extrafd && nfds==0) { W_FlushASAPNotificationQueue(); return False; } fds = wmalloc((nfds+extrafd) * sizeof(struct pollfd)); if (extrafd) { /* put this to the end of array to avoid using ranges from 1 to nfds+1 */ fds[nfds].fd = inputfd; fds[nfds].events = POLLIN; } /* use WM_ITERATE_ARRAY() here */ for (i = 0; i<nfds; i++) { handler = WMGetFromArray(inputHandler, i); fds[i].fd = handler->fd; fds[i].events = 0; if (handler->mask & WIReadMask) fds[i].events |= POLLIN; if (handler->mask & WIWriteMask) fds[i].events |= POLLOUT; #if 0 /* FIXME */ if (handler->mask & WIExceptMask) FD_SET(handler->fd, &eset); #endif } /* * Setup the timeout to the estimated time until the * next timer expires. */ if (!waitForInput) { timeout = 0; } else if (timerPending()) { struct timeval tv; delayUntilNextTimerEvent(&tv); timeout = tv.tv_sec * 1000 + tv.tv_usec / 1000; } else { timeout = -1; } count = poll(fds, nfds+extrafd, timeout); if (count>0 && nfds>0) { WMArray *handlerCopy = WMDuplicateArray(inputHandler); int mask; /* use WM_ITERATE_ARRAY() here */ for (i=0; i<nfds; i++) { handler = WMGetFromArray(handlerCopy, i); /* check if the handler still exist or was removed by a callback */ if (WMGetFirstInArray(inputHandler, handler) == WANotFound) continue; mask = 0; if ((handler->mask & WIReadMask) && (fds[i].revents & (POLLIN|POLLRDNORM|POLLRDBAND|POLLPRI))) mask |= WIReadMask; if ((handler->mask & WIWriteMask) && (fds[i].revents & (POLLOUT | POLLWRBAND))) mask |= WIWriteMask; if ((handler->mask & WIExceptMask) && (fds[i].revents & (POLLHUP | POLLNVAL | POLLERR))) mask |= WIExceptMask; if (mask!=0 && handler->callback) { (*handler->callback)(handler->fd, mask, handler->clientData); } } WMFreeArray(handlerCopy); } wfree(fds); W_FlushASAPNotificationQueue(); return (count > 0); #else #ifdef HAVE_SELECT struct timeval timeout; struct timeval *timeoutPtr; fd_set rset, wset, eset; int maxfd, nfds, i; int count; InputHandler *handler; if (inputHandler) nfds = WMGetArrayItemCount(inputHandler); else nfds = 0; if (inputfd<0 && nfds==0) { W_FlushASAPNotificationQueue(); return False; } FD_ZERO(&rset); FD_ZERO(&wset); FD_ZERO(&eset); if (inputfd < 0) { maxfd = 0; } else { FD_SET(inputfd, &rset); maxfd = inputfd; } /* use WM_ITERATE_ARRAY() here */ for (i=0; i<nfds; i++) { handler = WMGetFromArray(inputHandler, i); if (handler->mask & WIReadMask) FD_SET(handler->fd, &rset); if (handler->mask & WIWriteMask) FD_SET(handler->fd, &wset); if (handler->mask & WIExceptMask) FD_SET(handler->fd, &eset); if (maxfd < handler->fd) maxfd = handler->fd; } /* * Setup the timeout to the estimated time until the * next timer expires. */ if (!waitForInput) { SET_ZERO(timeout); timeoutPtr = &timeout; } else if (timerPending()) { delayUntilNextTimerEvent(&timeout); timeoutPtr = &timeout; } else { timeoutPtr = (struct timeval*)0; } count = select(1 + maxfd, &rset, &wset, &eset, timeoutPtr); if (count>0 && nfds>0) { WMArray *handlerCopy = WMDuplicateArray(inputHandler); int mask; /* use WM_ITERATE_ARRAY() here */ for (i=0; i<nfds; i++) { handler = WMGetFromArray(handlerCopy, i); /* check if the handler still exist or was removed by a callback */ if (WMGetFirstInArray(inputHandler, handler) == WANotFound) continue; mask = 0; if ((handler->mask & WIReadMask) && FD_ISSET(handler->fd, &rset)) mask |= WIReadMask; if ((handler->mask & WIWriteMask) && FD_ISSET(handler->fd, &wset)) mask |= WIWriteMask; if ((handler->mask & WIExceptMask) && FD_ISSET(handler->fd, &eset)) mask |= WIExceptMask; if (mask!=0 && handler->callback) { (*handler->callback)(handler->fd, mask, handler->clientData); } } WMFreeArray(handlerCopy); } W_FlushASAPNotificationQueue(); return (count > 0); #else /* not HAVE_SELECT, not HAVE_POLL */ # error Neither select nor poll. You lose. #endif /* HAVE_SELECT */ #endif /* HAVE_POLL */ }
WMArray *WMGetBrowserPaths(WMBrowser * bPtr) { int column, i, k, size, selNo; char *path; size_t slen; WMListItem *item, *lastItem; WMArray *paths, *items; column = bPtr->usedColumnCount - 1; if (column < 0) { paths = WMCreateArrayWithDestructor(1, wfree); WMAddToArray(paths, wstrdup(bPtr->pathSeparator)); return paths; } items = WMGetListSelectedItems(bPtr->columns[column]); selNo = WMGetArrayItemCount(items); paths = WMCreateArrayWithDestructor(selNo, wfree); if (selNo <= 1) { WMAddToArray(paths, WMGetBrowserPath(bPtr)); return paths; } /* calculate size of buffer */ size = 0; for (i = 0; i < column; i++) { item = WMGetListSelectedItem(bPtr->columns[i]); if (!item) break; size += strlen(item->text); } size += (column + 1) * strlen(bPtr->pathSeparator) + 1; for (k = 0; k < selNo; k++) { /* get the path */ lastItem = WMGetFromArray(items, k); slen = size + (lastItem != NULL ? strlen(lastItem->text) : 0); path = wmalloc(slen); /* ignore first `/' */ for (i = 0; i <= column; i++) { if (wstrlcat(path, bPtr->pathSeparator, slen) >= slen) { wfree(path); WMFreeArray(paths); return NULL; } if (i == column) { item = lastItem; } else { item = WMGetListSelectedItem(bPtr->columns[i]); } if (!item) break; if (wstrlcat(path, item->text, slen) >= slen) { wfree(path); return NULL; } } WMAddToArray(paths, path); } return paths; }
static void destroyView(W_View * view) { W_View *ptr; if (view->flags.alreadyDead) return; view->flags.alreadyDead = 1; /* delete the balloon text for the view, if there's any */ WMSetBalloonTextForView(NULL, view); if (view->nextFocusChain) view->nextFocusChain->prevFocusChain = view->prevFocusChain; if (view->prevFocusChain) view->prevFocusChain->nextFocusChain = view->nextFocusChain; /* Do not leave focus in a inexisting control */ if (W_FocusedViewOfToplevel(W_TopLevelOfView(view)) == view) W_SetFocusOfTopLevel(W_TopLevelOfView(view), NULL); if (view->flags.topLevel) { W_FocusInfo *info = view->screen->focusInfo; /* remove focus information associated to this toplevel */ if (info) { if (info->toplevel == view) { view->screen->focusInfo = info->next; wfree(info); } else { while (info->next) { if (info->next->toplevel == view) break; info = info->next; } if (info->next) { W_FocusInfo *next = info->next->next; wfree(info->next); info->next = next; } /* else the toplevel did not have any focused subview */ } } } /* destroy children recursively */ while (view->childrenList != NULL) { ptr = view->childrenList; ptr->flags.parentDying = 1; W_DestroyView(ptr); if (ptr == view->childrenList) { view->childrenList = ptr->nextSister; ptr->parent = NULL; } } W_CallDestroyHandlers(view); if (view->flags.realized) { XDeleteContext(view->screen->display, view->window, ViewContext); /* if parent is being destroyed, it will die naturaly */ if (!view->flags.parentDying || view->flags.topLevel) XDestroyWindow(view->screen->display, view->window); } /* remove self from parent's children list */ unparentView(view); /* the array has a wfree() destructor that will be called automatically */ WMFreeArray(view->eventHandlers); view->eventHandlers = NULL; WMRemoveNotificationObserver(view); W_FreeViewXdndPart(view); if (view->backColor) WMReleaseColor(view->backColor); wfree(view); }
static void destroyBox(Box * bPtr) { WMFreeArray(bPtr->subviews); wfree(bPtr); }