自学教程：C++ wmalloc函数代码示例

static Atom *getTypeAtomList(WMScreen * scr, WMView * view, int *count){	WMArray *types;	Atom *typeAtoms;	int i;	types = view->dragSourceProcs->dropDataTypes(view);	if (types != NULL) {		*count = WMGetArrayItemCount(types);		if (*count > 0) {			typeAtoms = wmalloc((*count) * sizeof(Atom));			for (i = 0; i < *count; i++) {				typeAtoms[i] = XInternAtom(scr->display, WMGetFromArray(types, i), False);			}			/* WMFreeArray(types); */			return typeAtoms;		}		/* WMFreeArray(types); */	}	*count = 1;	typeAtoms = wmalloc(sizeof(Atom));	*typeAtoms = None;	return typeAtoms;}

/* * Function:    _wilddog_url_getKey * Description: Get the Key of the path. * Input:       p_path: The path. * Output:      N/A * Return:      Pointer to the Key.*/Wilddog_Str_T * WD_SYSTEM _wilddog_url_getKey(Wilddog_Str_T * p_path){    int i, len, pos = 0;    Wilddog_Str_T* p_str = NULL;    if(NULL == p_path)        return NULL;        len = strlen((const char*)p_path);    if(len == 1 && p_path[0] == '/')    {        p_str = (Wilddog_Str_T*)wmalloc(len + 1);        if(NULL == p_str)            return NULL;        p_str[0] = '/';        return p_str;    }    for(i = len - 1; i >=0; i--)    {        if(p_path[len - 1] == '/')            continue;        if(p_path[i] == '/')        {            pos = i;            break;        }    }    p_str = (Wilddog_Str_T*)wmalloc(len - pos);    if(NULL == p_str)        return NULL;    memcpy((char*)p_str, (char*)(p_path + pos + 1), len - pos);    return p_str;}

/***  Perform Re-Pair on one block*/static void executeRepair_OneBlock (PROG_INFO *prog_struct, BLOCK_INFO *block_struct) {    R_UINT i;    /*  Perform scanPairs  */    scanPairs (prog_struct, block_struct);    /*  Allocate queue and initialize to NULL  */    /*  Make the priority queue bigger by one since position 0 is    **  unused.  */    block_struct -> pqueue_size = block_struct -> max_count + 1;    block_struct -> pqueue = wmalloc ((block_struct -> pqueue_size) * (sizeof (TPHRASE*)));    for (i = 0; i < block_struct -> pqueue_size; i++) {        block_struct -> pqueue[i] = NULL;    }    /*  Populate queue with tentative phrases  */    initQueue (prog_struct, block_struct);    /*  Recursively pair phrases  */    rePairPhrases (prog_struct, block_struct);    /*  Sort primitives  */    sortPrimitives (block_struct);    block_struct -> sort_phrases = wmalloc (((block_struct -> num_prims) + (block_struct -> num_phrases)) * (sizeof (PHRASE)));    /*  Sort phrases  */    sortPhrases (prog_struct, block_struct);    return;}

static struct apiState *eventInit(int nevent){    struct kevent *events = NULL;    int ep;    struct apiState *state = NULL;    ep = kqueue();    if (ep < 0) {        return NULL;    }    state = wmalloc(sizeof(struct apiState));    if (!state) {        close(ep);        return NULL;    }    events = wmalloc(nevent*sizeof(struct kevent));    if (events == NULL) {        close(ep);        wfree(state);        return NULL;    }    state->kqfd = ep;    state->events = events;    return state;}

/* upon fully deducing one particular menu entry, parsers call back to this * function to have said menu entry added to the wm menu. initializes wm menu * with a root element if needed. */static void addWMMenuEntryCallback(WMMenuEntry *aEntry){	WMMenuEntry *wm;	WMTreeNode *at;	wm = (WMMenuEntry *)wmalloc(sizeof(WMMenuEntry));	/* this entry */	at = (WMTreeNode *)NULL;				/* will be a child of this entry */	if (!menu) {		WMMenuEntry *root;		root = (WMMenuEntry *)wmalloc(sizeof(WMMenuEntry));		root->Name = "Applications";		root->CmdLine = NULL;		root->SubMenu = NULL;		root->Flags = 0;		menu = WMCreateTreeNode(root);	}	if (aEntry->SubMenu)		at = findPositionInMenu(aEntry->SubMenu);	if (!at)		at = menu;	wm->Flags = aEntry->Flags;	wm->Name = wstrdup(aEntry->Name);	wm->CmdLine = wstrdup(aEntry->CmdLine);	wm->SubMenu = NULL;	WMAddItemToTree(at, wm);}

WMTextField *WMCreateTextField(WMWidget * parent){	TextField *tPtr;	tPtr = wmalloc(sizeof(TextField));	tPtr->widgetClass = WC_TextField;	tPtr->view = W_CreateView(W_VIEW(parent));	if (!tPtr->view) {		wfree(tPtr);		return NULL;	}	tPtr->view->self = tPtr;	tPtr->view->delegate = &_TextFieldViewDelegate;	tPtr->view->attribFlags |= CWCursor;	tPtr->view->attribs.cursor = tPtr->view->screen->textCursor;	W_SetViewBackgroundColor(tPtr->view, tPtr->view->screen->white);	tPtr->text = wmalloc(MIN_TEXT_BUFFER);	tPtr->textLen = 0;	tPtr->bufferSize = MIN_TEXT_BUFFER;	tPtr->flags.enabled = 1;	WMCreateEventHandler(tPtr->view, ExposureMask | StructureNotifyMask | FocusChangeMask, handleEvents, tPtr);	tPtr->font = WMRetainFont(tPtr->view->screen->normalFont);	tPtr->flags.bordered = DEFAULT_BORDERED;	tPtr->flags.beveled = True;	tPtr->flags.alignment = DEFAULT_ALIGNMENT;	tPtr->offsetWidth = WMAX((tPtr->view->size.height - WMFontHeight(tPtr->font)) / 2, 1);	W_ResizeView(tPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);	WMCreateEventHandler(tPtr->view, EnterWindowMask | LeaveWindowMask			     | ButtonReleaseMask | ButtonPressMask | KeyPressMask | Button1MotionMask,			     handleTextFieldActionEvents, tPtr);	WMAddNotificationObserver(selectionNotification, tPtr->view,				  WMSelectionOwnerDidChangeNotification, (void *)XA_PRIMARY);	WMAddNotificationObserver(realizeObserver, tPtr, WMViewRealizedNotification, tPtr->view);	tPtr->flags.cursorOn = 1;	return tPtr;}

WMHashTable *WMCreateHashTable(WMHashTableCallbacks callbacks){	HashTable *table;	table = wmalloc(sizeof(HashTable));	table->callbacks = callbacks;	table->size = INITIAL_CAPACITY;	table->table = wmalloc(sizeof(HashItem *) * table->size);	return table;}

static void removeColumn(WMBrowser * bPtr, int column){	int i, clearEnd, destroyEnd;	WMList **clist;	char **tlist;	assert(bPtr != NULL);	column = (column < 0) ? 0 : column;	if (column >= bPtr->columnCount) {		return;	}	if (column < bPtr->maxVisibleColumns) {		clearEnd = bPtr->maxVisibleColumns;		destroyEnd = bPtr->columnCount;		bPtr->columnCount = bPtr->maxVisibleColumns;	} else {		clearEnd = column;		destroyEnd = bPtr->columnCount;		bPtr->columnCount = column;	}	if (column < bPtr->usedColumnCount) {		bPtr->usedColumnCount = column;	}	for (i = column; i < clearEnd; i++) {		if (bPtr->titles[i]) {			wfree(bPtr->titles[i]);			bPtr->titles[i] = NULL;		}		WMClearList(bPtr->columns[i]);	}	for (; i < destroyEnd; i++) {		if (bPtr->titles[i]) {			wfree(bPtr->titles[i]);			bPtr->titles[i] = NULL;		}		WMRemoveNotificationObserverWithName(bPtr, WMListSelectionDidChangeNotification, bPtr->columns[i]);		WMDestroyWidget(bPtr->columns[i]);		bPtr->columns[i] = NULL;	}	clist = wmalloc(sizeof(WMList *) * (bPtr->columnCount));	tlist = wmalloc(sizeof(char *) * (bPtr->columnCount));	memcpy(clist, bPtr->columns, sizeof(WMList *) * (bPtr->columnCount));	memcpy(tlist, bPtr->titles, sizeof(char *) * (bPtr->columnCount));	wfree(bPtr->titles);	wfree(bPtr->columns);	bPtr->titles = tlist;	bPtr->columns = clist;}

int wWorkspaceNew(WScreen *scr){	WWorkspace *wspace, **list;	int i;	if (w_global.workspace.count < MAX_WORKSPACES) {		w_global.workspace.count++;		wspace = wmalloc(sizeof(WWorkspace));		wspace->name = NULL;		wspace->clip = NULL;		if (!wspace->name) {			static const char *new_name = NULL;			static size_t name_length;			if (new_name == NULL) {				new_name = _("Workspace %i");				name_length = strlen(new_name) + 8;			}			wspace->name = wmalloc(name_length);			snprintf(wspace->name, name_length, new_name, w_global.workspace.count);		}		if (!wPreferences.flags.noclip)			wspace->clip = wDockCreate(scr, WM_CLIP, NULL);		list = wmalloc(sizeof(WWorkspace *) * w_global.workspace.count);		for (i = 0; i < w_global.workspace.count - 1; i++)			list[i] = w_global.workspace.array[i];		list[i] = wspace;		if (w_global.workspace.array)			wfree(w_global.workspace.array);		w_global.workspace.array = list;		wWorkspaceMenuUpdate(w_global.workspace.menu);		wWorkspaceMenuUpdate(w_global.clip.ws_menu);		wNETWMUpdateDesktop(scr);		WMPostNotificationName(WMNWorkspaceCreated, scr, (void *)(uintptr_t) (w_global.workspace.count - 1));		XFlush(dpy);		return w_global.workspace.count - 1;	}	return -1;}

/* * Function:    _wilddog_url_getParentStr * Description: Get the Parent path of the source path. * Input:       p_src_path: The source path. * Output:      N/A * Return:      Pointer to the parent's path.*/STATIC Wilddog_Str_T * WD_SYSTEM _wilddog_url_getParentStr    (    Wilddog_Str_T* p_src_path    ){    int i;    int size = 0;    int pos = 0;    Wilddog_Str_T* p_path = NULL;    if(!p_src_path)        return NULL;        size = strlen((const char*)p_src_path);    if(size == 1 && p_src_path[0] == '/')    {        return NULL;    }    for(i = size - 1; i >= 0; i--)    {        if(p_src_path[size - 1] == '/')            continue;        if(p_src_path[i] == '/')        {            pos = i;            break;        }    }    /* path do not have '/', invalid */    if((!pos) && (p_src_path[pos] != '/'))        return p_path;    if(pos == 0)    {        p_path = (Wilddog_Str_T *)wmalloc(2);        if(NULL == p_path)            return NULL;        p_path[0] = '/';        return p_path;    }        p_path = (Wilddog_Str_T *)wmalloc(pos + 1);    if(NULL == p_path)        return NULL;        strncpy((char*)p_path, (char*)p_src_path, pos);    return p_path;}

static void registerDescriptionList(WMScreen * scr, WMView * view, WMArray * operationArray){	char *text, *textListItem, *textList;	int count = WMGetArrayItemCount(operationArray);	int i;	int size = 0;	/* size of XA_STRING info */	for (i = 0; i < count; i++) {		size += strlen(WMGetDragOperationItemText(WMGetFromArray(operationArray, i))) + 1 /* NULL */;	}	/* create text list */	textList = wmalloc(size);	textListItem = textList;	for (i = 0; i < count; i++) {		text = WMGetDragOperationItemText(WMGetFromArray(operationArray, i));		wstrlcpy(textListItem, text, size);		/* to next text offset */		textListItem = &(textListItem[strlen(textListItem) + 1]);	}	XChangeProperty(scr->display,			WMViewXID(view),			scr->xdndActionDescriptionAtom,			XA_STRING,			XDND_ACTION_DESCRIPTION_FORMAT, PropModeReplace, (unsigned char *)textList, size);}

*/Wilddog_Conn_T * WD_SYSTEM _wilddog_conn_init(Wilddog_Repo_T* p_repo){    Wilddog_CM_InitArg_T cm_initArg;    Wilddog_Conn_T* p_repo_conn = NULL;        if(!p_repo)        return NULL;    p_repo_conn = (Wilddog_Conn_T*)wmalloc(sizeof(Wilddog_Conn_T));    if( NULL ==p_repo_conn)        return NULL;        p_repo_conn->p_conn_repo = p_repo;    p_repo->p_rp_conn = p_repo_conn;    p_repo_conn->f_conn_ioctl = (Wilddog_Func_T)_wilddog_conn_ioctl;    cm_initArg.p_repo= p_repo;    cm_initArg.f_conn_cb = (Wilddog_Func_T)_wilddog_conn_cb_ioctl;     p_repo_conn->p_cm_l = (void*)_wilddog_cm_ioctl( CM_CMD_INIT,&cm_initArg,0);    if( p_repo_conn->p_cm_l == NULL )    {        wfree(p_repo_conn);        p_repo_conn = NULL;    }        return p_repo_conn;

WTexPixmap *wTextureMakePixmap(WScreen *scr, int style, const char *pixmap_file, XColor *color){	WTexPixmap *texture;	XGCValues gcv;	RImage *image;	image = get_texture_image(scr, pixmap_file);	if (!image)		return NULL;	texture = wmalloc(sizeof(WTexture));	texture->type = WTEX_PIXMAP;	texture->subtype = style;	texture->normal = *color;	XAllocColor(dpy, scr->w_colormap, &texture->normal);	gcv.background = gcv.foreground = texture->normal.pixel;	gcv.graphics_exposures = False;	texture->normal_gc = XCreateGC(dpy, scr->w_win, GCForeground | GCBackground | GCGraphicsExposures, &gcv);	texture->pixmap = image;	return texture;}

WMMaskedEvents* WMMaskEvents(WMView* view) {  W_MaskedEvents *mask;  unsigned int i;  Bool changed = False;  mask = wmalloc(sizeof(W_MaskedEvents));  mask->view = view;  mask->procs = WMCreateArray(0);  mask->data = WMCreateArray(0);  for (i = 0; i < WMGetArrayItemCount(W_GetViewEventHandlers(view)); i++) {    W_EventHandler *h = (W_EventHandler*) WMGetFromArray(W_GetViewEventHandlers(view), i);    if (h->eventMask == (ButtonPressMask|ButtonReleaseMask|                        EnterWindowMask|LeaveWindowMask|ButtonMotionMask)) {      WMAddToArray(mask->procs, h->proc);      WMAddToArray(mask->data, h->clientData);      /* we change only the first handler to our one, because they seem         to be processed upside-down and we want the dnd-handler to be processed         first. */      if (changed == False) {        h->proc = W_MaskedEventHandler;        h->clientData = (void*) mask;        changed = True;      } else {        WMDeleteEventHandler(view, h->eventMask, h->proc, h->clientData);      }    }  }  return mask;}

Panel *InitMouseSettings(WMWidget *parent){	_Panel *panel;	modifierNames[0] = wstrdup(_("Shift"));	modifierNames[1] = wstrdup(_("Lock"));	modifierNames[2] = wstrdup(_("Control"));	modifierNames[3] = wstrdup(_("Mod1"));	modifierNames[4] = wstrdup(_("Mod2"));	modifierNames[5] = wstrdup(_("Mod3"));	modifierNames[6] = wstrdup(_("Mod4"));	modifierNames[7] = wstrdup(_("Mod5"));	panel = wmalloc(sizeof(_Panel));	panel->sectionName = _("Mouse Preferences");	panel->description = _("Mouse speed/acceleration, double click delay,/n" "mouse button bindings etc.");	panel->parent = parent;	panel->callbacks.createWidgets = createPanel;	panel->callbacks.updateDomain = storeData;	AddSection(panel, ICON_FILE);	return panel;}

WMSplitView *WMCreateSplitView(WMWidget * parent){	WMSplitView *sPtr;	sPtr = wmalloc(sizeof(WMSplitView));	sPtr->widgetClass = WC_SplitView;	sPtr->view = W_CreateView(W_VIEW(parent));	if (!sPtr->view) {		wfree(sPtr);		return NULL;	}	sPtr->view->self = sPtr;	WMSetViewNotifySizeChanges(sPtr->view, True);	WMCreateEventHandler(sPtr->view, ExposureMask | StructureNotifyMask			     | ClientMessageMask, handleEvents, sPtr);	WMCreateEventHandler(sPtr->view, ButtonPressMask | ButtonReleaseMask			     | EnterWindowMask | LeaveWindowMask, handleActionEvents, sPtr);	WMAddNotificationObserver(handleViewResized, sPtr, WMViewSizeDidChangeNotification, sPtr->view);	sPtr->subviews = WMCreateArrayWithDestructor(8, wfree);	return sPtr;}

WMLabel *WMCreateLabel(WMWidget * parent){	Label *lPtr;	lPtr = wmalloc(sizeof(Label));	lPtr->widgetClass = WC_Label;	lPtr->view = W_CreateView(W_VIEW(parent));	if (!lPtr->view) {		wfree(lPtr);		return NULL;	}	lPtr->view->self = lPtr;	lPtr->textColor = WMRetainColor(lPtr->view->screen->black);	WMCreateEventHandler(lPtr->view, ExposureMask | StructureNotifyMask, handleEvents, lPtr);	W_ResizeView(lPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);	lPtr->flags.alignment = DEFAULT_ALIGNMENT;	lPtr->flags.relief = DEFAULT_RELIEF;	lPtr->flags.imagePosition = DEFAULT_IMAGE_POSITION;	lPtr->flags.noWrap = 1;	return lPtr;}

boolwsheet_add_obj(struct wsheet* wsh,               uint16_t type, void* data,               int32_t l, int32_t t, int32_t r, int32_t b) {    int32_t     i, j;    struct obj* o = wmalloc(sizeof(*o));    wassert(o);    rect_set(&o->extent, l, t, r, b);    o->ty = type;    o->ref = 0;    o->priv = data;    for (i = 0; i < wsh->rowN; i++) {        for (j = 0; j < wsh->colN; j++) {            if (rect_is_overlap2(&o->extent,                                 &wsh->divs[i][j].boundary))                div_add_obj(&wsh->divs[i][j], o);        }    }    /* if obj is not added anywhere, destroy it! */    if (!o->ref) {        wfree(o);        return false;    } else        return true;}

Wilddog_Str_T * getHostFromUrl(Wilddog_Str_T *url){	int length = 0;	int m = 0, n = 0;	int i = 0;	Wilddog_Str_T *host = NULL;	length = strlen(url);	for(i = 0; i < length; i++)	{		if(*(url+i) == '/' && *(url+i+1) == '/')			break;	}	m = i+2;	for(i = m; i < length; i++)	{		if(*(url+i) == '/')			break;	}	n = i-1;	host = wmalloc(n-m+2);	if(NULL == host)	{			}	strncpy(host, url+m, n-m+1);	return host;}

/*---------------------------------------------------------------------- * wCoreCreate-- * 	Creates a brand new child window. * 	The window will have a border width of 0 and color is black. * * Returns: * 	A initialized core window structure. * * Side effects: * 	A window context for the created window is saved. * * Notes: * 	The event mask is initialized to a default value. *--------------------------------------------------------------------- */WCoreWindow *wCoreCreate(WCoreWindow *parent, int x, int y, int width, int height){	WCoreWindow *core;	int vmask;	XSetWindowAttributes attribs;	core = wmalloc(sizeof(WCoreWindow));	vmask = CWBorderPixel | CWCursor | CWEventMask | CWColormap;	attribs.cursor = wCursor[WCUR_DEFAULT];	attribs.background_pixmap = None;	attribs.background_pixel = parent->screen_ptr->black_pixel;	attribs.event_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask |			     ButtonReleaseMask | ButtonMotionMask |			     ExposureMask | EnterWindowMask | LeaveWindowMask;	attribs.colormap = parent->screen_ptr->w_colormap;	core->window = XCreateWindow(dpy, parent->window, x, y, width, height, 0,			  parent->screen_ptr->w_depth, CopyFromParent,			  parent->screen_ptr->w_visual, vmask, &attribs);	core->width = width;	core->height = height;	core->screen_ptr = parent->screen_ptr;	core->descriptor.self = core;	XSaveContext(dpy, core->window, wWinContext, (XPointer) & core->descriptor);	return core;}

static char *dataDescription(WMPropList * plist){	const unsigned char *data;	char *retVal;	int i, j, length;	data = WMDataBytes(plist->d.data);	length = WMGetDataLength(plist->d.data);	retVal = (char *)wmalloc(2 * length + length / 4 + 3);	retVal[0] = '<';	for (i = 0, j = 1; i < length; i++) {		retVal[j++] = num2char((data[i] >> 4) & 0x0f);		retVal[j++] = num2char(data[i] & 0x0f);		if ((i & 0x03) == 3 && i != length - 1) {			/* if we've just finished a 32-bit int, add a space */			retVal[j++] = ' ';		}	}	retVal[j++] = '>';	retVal[j] = '/0';	return retVal;}

void WMResetHashTable(WMHashTable * table){	HashItem *item, *tmp;	int i;	for (i = 0; i < table->size; i++) {		item = table->table[i];		while (item) {			tmp = item->next;			RELKEY(table, item->key);			wfree(item);			item = tmp;		}	}	table->itemCount = 0;	if (table->size > INITIAL_CAPACITY) {		wfree(table->table);		table->size = INITIAL_CAPACITY;		table->table = wmalloc(sizeof(HashItem *) * table->size);	} else {		memset(table->table, 0, sizeof(HashItem *) * table->size);	}}

static void rebuildTable(WMHashTable * table){	HashItem *next;	HashItem **oldArray;	int i;	int oldSize;	int newSize;	oldArray = table->table;	oldSize = table->size;	newSize = table->size * 2;	table->table = wmalloc(sizeof(char *) * newSize);	table->size = newSize;	for (i = 0; i < oldSize; i++) {		while (oldArray[i] != NULL) {			next = oldArray[i]->next;			rellocateItem(table, oldArray[i]);			oldArray[i] = next;		}	}	wfree(oldArray);}

void WMSetViewDragSourceProcs(WMView * view, WMDragSourceProcs * procs){	if (view->dragSourceProcs)		wfree(view->dragSourceProcs);	view->dragSourceProcs = wmalloc(sizeof(WMDragSourceProcs));	*view->dragSourceProcs = *procs;	if (procs->dropDataTypes == NULL)		view->dragSourceProcs->dropDataTypes = defDropDataTypes;	if (procs->wantedDropOperation == NULL)		view->dragSourceProcs->wantedDropOperation = defWantedDropOperation;	/*	   Note: askedOperations can be NULL, if wantedDropOperation never returns	   WDOperationAsk.	 */	if (procs->acceptDropOperation == NULL)		view->dragSourceProcs->acceptDropOperation = defAcceptDropOperation;	if (procs->beganDrag == NULL)		view->dragSourceProcs->beganDrag = defBeganDrag;	if (procs->endedDrag == NULL)		view->dragSourceProcs->endedDrag = defEndedDrag;	if (procs->fetchDragData == NULL)		view->dragSourceProcs->fetchDragData = defFetchDragData;}

WMTabView *WMCreateTabView(WMWidget * parent){	TabView *tPtr;	WMScreen *scr = WMWidgetScreen(parent);	tPtr = wmalloc(sizeof(TabView));	tPtr->widgetClass = WC_TabView;	tPtr->view = W_CreateView(W_VIEW(parent));	if (!tPtr->view) {		wfree(tPtr);		return NULL;	}	tPtr->view->self = tPtr;	tPtr->view->delegate = &delegate;	tPtr->lightGray = WMCreateRGBColor(scr, 0xd9d9, 0xd9d9, 0xd9d9, False);	tPtr->tabColor = WMCreateRGBColor(scr, 0x8420, 0x8420, 0x8420, False);	tPtr->font = WMRetainFont(scr->normalFont);	tPtr->flags.type = WTTopTabsBevelBorder;	tPtr->flags.bordered = 1;	tPtr->flags.uniformTabs = 0;	tPtr->flags.enabled = 1;	WMCreateEventHandler(tPtr->view, ExposureMask | StructureNotifyMask | ButtonPressMask, handleEvents, tPtr);	WMResizeWidget(tPtr, DEFAULT_WIDTH, DEFAULT_HEIGHT);	tPtr->tabHeight = WMFontHeight(tPtr->font) + 3;	return tPtr;}

static void initMotionProcess(WMView * view, WMDraggingInfo * info, XEvent * event, WMPoint * startLocation){	WMScreen *scr = W_VIEW_SCREEN(view);	/* take ownership of XdndSelection */	XDND_SELECTION_PROCS(info) = (WMSelectionProcs *) wmalloc(sizeof(WMSelectionProcs));	XDND_SELECTION_PROCS(info)->convertSelection = convertSelection;	XDND_SELECTION_PROCS(info)->selectionLost = selectionLost;	XDND_SELECTION_PROCS(info)->selectionDone = selectionDone;	XDND_TIMESTAMP(info) = event->xmotion.time;	if (!WMCreateSelectionHandler(view, scr->xdndSelectionAtom, CurrentTime, XDND_SELECTION_PROCS(info), NULL)) {		wwarning("could not get ownership or DND selection");		return;	}	registerDropTypes(scr, view, info);	if (XDND_SOURCE_ACTION(info) == W_VIEW_SCREEN(view)->xdndActionAsk)		registerSupportedOperations(view);	if (view->dragSourceProcs->beganDrag != NULL) {		view->dragSourceProcs->beganDrag(view, startLocation);	}}

struct W_Balloon *W_CreateBalloon(WMScreen * scr){	Balloon *bPtr;	bPtr = wmalloc(sizeof(Balloon));	bPtr->view = W_CreateUnmanagedTopView(scr);	if (!bPtr->view) {		wfree(bPtr);		return NULL;	}	bPtr->view->self = bPtr;	bPtr->textColor = WMRetainColor(bPtr->view->screen->black);	WMCreateEventHandler(bPtr->view, StructureNotifyMask, handleEvents, bPtr);	W_ResizeView(bPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);	bPtr->flags.alignment = DEFAULT_ALIGNMENT;	bPtr->table = WMCreateHashTable(WMIntHashCallbacks);	bPtr->delay = DEFAULT_DELAY;	bPtr->flags.enabled = 1;	return bPtr;}