dwindows: mac/dw.m comparison

comparison mac/dw.m @ 691:578bbfd8c904

Added initial thread synchronization code to stop the main loop when doing thread unsafe things. Also fixed some memory leaks and double object releases that were causing some instability.

author	bsmith@81767d24-ef19-dc11-ae90-00e081727c95
date	Tue, 08 Mar 2011 01:30:04 +0000
parents	b93f5cdab37d
children	bd909322f40d

comparison

equal deleted inserted replaced

-:b93f5cdab37d
+:578bbfd8c904
 #include <sys/socket.h>
 #include <sys/un.h>
 #include <sys/mman.h>
 #include <sys/time.h>
 #include <sys/stat.h>
+/* Macros to protect access to thread unsafe classes */
+#define  DW_MUTEX_LOCK { \
+if(DWThread != (DWTID)-1 && pthread_self() != DWThread && pthread_self() != _dw_mutex_locked) { \
+dw_mutex_lock(DWThreadMutex); \
+_dw_mutex_locked = pthread_self(); \
+dw_mutex_lock(DWThreadMutex2); \
+/*NSLog(@"Thread %d asking the main thread to stop %x", (int)pthread_self(), (int)DWObj);*/ \
+[DWObj performSelectorOnMainThread:@selector(synchronizeThread:) withObject:nil waitUntilDone:NO]; \
+dw_mutex_lock(DWRunMutex); \
+/*NSLog(@"Thread %d proceeding", (int)pthread_self());*/ \
+_locked_by_me = TRUE; } }
+#define  DW_MUTEX_UNLOCK { \
+if(pthread_self() != DWThread && _locked_by_me == TRUE) { \
+/*NSLog(@"Thread %d releasing", (int)pthread_self());*/ \
+dw_mutex_unlock(DWRunMutex); \
+dw_mutex_unlock(DWThreadMutex2); \
+_dw_mutex_locked = (pthread_t)-1; \
+dw_mutex_unlock(DWThreadMutex); \
+_locked_by_me = FALSE; } }
 unsigned long _colors[] =
 {
 	0x00000000,   /* 0  black */
 	0x00bb0000,   /* 1  red */
 DWTimerHandler *DWHandler;
 #if !defined(GARBAGE_COLLECT)
 NSAutoreleasePool *pool;
 #endif
 HWND _DWLastDrawable;
+HMTX DWRunMutex;
+HMTX DWThreadMutex;
+HMTX DWThreadMutex2;
+DWTID DWThread = (DWTID)-1;
+DWTID _dw_mutex_locked = (DWTID)-1;
+/* Subclass for a test object type */
+@interface DWObject : NSObject {}
+-(void)uselessThread:(id)sender;
+-(void)synchronizeThread:(id)param;
+@end
+@implementation DWObject
+-(void)uselessThread:(id)sender { /* Thread only to initialize threading */ }
+-(void)synchronizeThread:(id)param
+{
+pthread_mutex_unlock(DWRunMutex);
+//NSLog(@"Main thread releasing lock");
+pthread_mutex_lock(DWThreadMutex2);
+pthread_mutex_unlock(DWThreadMutex2);
+pthread_mutex_lock(DWRunMutex);
+//NSLog(@"Main thread reacquiring lock");
+}
+@end
+DWObject *DWObj;
 /* So basically to implement our event handlers...
 * it looks like we are going to have to subclass
 * basically everything.  Was hoping to add methods
 * to the superclasses but it looks like you can
 [set release];
 return (int)[titles count];
 }
 return 0;
 }
--(int)addRow:(NSArray *)input { if(data) { lastAddPoint = (int)[titles count]; [data addObjectsFromArray:input]; [titles addPointer:NULL]; return (int)[titles count]; } return 0; }
+-(int)addRow:(NSArray *)input
+{
+if(data)
+{
+NSLog(@"addRow: titles: %x data %x", (int)titles, (int)data);
+lastAddPoint = (int)[titles count];
+[data addObjectsFromArray:input];
+[titles addPointer:NULL];
+return (int)[titles count];
+}
+return 0;
+}
 -(int)addRows:(int)number
 {
 	if(tvcols)
 	{
 		int count = (int)(number * [tvcols count]);
 else
 {
 _free_tree_recurse(children, item);
 }
 }
-if(!item || item == pnt)
-{
-[pnt release];
-}
 }
 }
 if(!item)
 {
 [node release];
 */
 @interface DWMDI : DWBox {}
 @end
 @implementation DWMDI
-@end
-/* Subclass for a test object type */
-@interface DWObject : NSObject {}
--(void)uselessThread:(id)sender;
-@end
-@implementation DWObject
--(void)uselessThread:(id)sender { /* Thread only to initialize threading */ }
 @end
 typedef struct
 {
 	ULONG message;
 	pool = [[NSAutoreleasePool alloc] init];
 #endif
 /* Create a default main menu, with just the application menu */
 	DWMainMenu = _generate_main_menu();
 	[DWApp setMainMenu:DWMainMenu];
-	DWObject *test = [[DWObject alloc] init];
+	DWObj = [[DWObject alloc] init];
+/* Create mutexes for thread safety */
+DWRunMutex = dw_mutex_new();
+DWThreadMutex = dw_mutex_new();
+DWThreadMutex2 = dw_mutex_new();
 /* Use NSThread to start a dummy thread to initialize the threading subsystem */
-	NSThread *thread = [[ NSThread alloc] initWithTarget:test selector:@selector(uselessThread:) object:nil];
+	NSThread *thread = [[ NSThread alloc] initWithTarget:DWObj selector:@selector(uselessThread:) object:nil];
 	[thread start];
+[thread release];
 	return 0;
 }
 /*
 * Runs a message loop for Dynamic Windows.
 */
 void API dw_main(void)
 {
+dw_mutex_lock(DWRunMutex);
+DWThread = dw_thread_id();
 [DWApp run];
+DWThread = (DWTID)-1;
+dw_mutex_unlock(DWRunMutex);
 }
 /*
 * Runs a message loop for Dynamic Windows, for a period of milliseconds.
 * Parameters:
 void API dw_main_sleep(int milliseconds)
 {
 	double seconds = (double)milliseconds/1000.0;
 	NSDate *time = [[NSDate alloc] initWithTimeIntervalSinceNow:seconds];
 	[DWRunLoop runUntilDate:time];
+[time release];
 }
 /*
 * Processes a single message iteration and returns.
 */
 *       type: Either DW_VERT (vertical) or DW_HORZ (horizontal).
 *       pad: Number of pixels to pad around the box.
 */
 HWND API dw_box_new(int type, int pad)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 DWBox *view = [[DWBox alloc] init];
 	Box *newbox = [view box];
 	memset(newbox, 0, sizeof(Box));
 	newbox->pad = pad;
 	newbox->type = type;
+DW_MUTEX_UNLOCK;
 	return view;
 }
 /*
 * Create a new Group Box to be packed.
 *       vsize: TRUE if the window (widget) should expand vertically to fill space given.
 *       pad: Number of pixels of padding around the item.
 */
 void API dw_box_pack_end(HWND box, HWND item, int width, int height, int hsize, int vsize, int pad)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	NSObject *object = box;
 	DWBox *view = box;
 	DWBox *this = item;
 	Box *thisbox;
 int z;
 	[view addSubview:this];
 	/* Free the old data */
 if(thisbox->count)
 free(thisitem);
+DW_MUTEX_UNLOCK;
 }
 /*
 * Pack windows (widgets) into a box from the start (or top).
 * Parameters:
 *       vsize: TRUE if the window (widget) should expand vertically to fill space given.
 *       pad: Number of pixels of padding around the item.
 */
 void API dw_box_pack_start(HWND box, HWND item, int width, int height, int hsize, int vsize, int pad)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	NSObject *object = box;
 	DWBox *view = box;
 	DWBox *this = item;
 	Box *thisbox;
 int z;
 	[view addSubview:this];
 	/* Free the old data */
 if(thisbox->count)
 free(thisitem);
+DW_MUTEX_UNLOCK;
 }
 HWND _button_new(char *text, ULONG cid)
 {
 	DWButton *button = [[DWButton alloc] init];
 	DWButton *button = _button_new("", resid);
 	[button setImage:image];
 //[button setBezelStyle:0];
 [button setButtonType:NSMomentaryLight];
 [button setBordered:NO];
-[bundle release];
-[respath release];
-[filepath release];
 [image release];
 	return button;
 }
 /*
 if(!image)
 {
 nstr = [nstr stringByAppendingString:@".png"];
 image = [[NSImage alloc] initWithContentsOfFile:nstr];
 }
-[nstr release];
 	DWButton *button = _button_new("", cid);
 	[button setImage:image];
+[image release];
 	return button;
 }
 /*
 * Create a new bitmap button window (widget) to be packed from data.
 {
 	NSData *thisdata = [[NSData alloc] dataWithBytes:data length:len];
 	NSImage *image = [[NSImage alloc] initWithData:thisdata];
 	DWButton *button = _button_new("", cid);
 	[button setImage:image];
+[image release];
 	return button;
 }
 /*
 * Create a new spinbutton window (widget) to be packed.
 *       increments: Number of increments available.
 *       id: An ID to be used with dw_window_from_id() or 0L.
 */
 HWND API dw_scrollbar_new(int vertical, ULONG cid)
 {
-DWScrollbar *scrollbar = [DWScrollbar alloc];
+DWScrollbar *scrollbar;
 if(vertical)
 {
-[scrollbar init];
+scrollbar = [[DWScrollbar alloc] init];
 }
 else
 {
-[scrollbar initWithFrame:NSMakeRect(0,0,100,5)];
+scrollbar = [[DWScrollbar alloc] initWithFrame:NSMakeRect(0,0,100,5)];
 }
 [scrollbar setArrowsPosition:NSScrollerArrowsDefaultSetting];
 [scrollbar setTarget:scrollbar];
 [scrollbar setAction:@selector(changed:)];
 [scrollbar setRange:0.0 andVisible:0.0];
 		[cont setAllowsMultipleSelection:NO];
 	}
 	[cont setDataSource:cont];
 [scrollview setDocumentView:cont];
 [cont setTag:cid];
+[scrollview release];
 	return cont;
 }
 /*
 * Create a new listbox window (widget) to be packed.
 *       id: An ID to be used with dw_window_from_id() or 0L.
 *       multi: Multiple select TRUE or FALSE.
 */
 HWND API dw_listbox_new(ULONG cid, int multi)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	DWContainer *cont = _cont_new(cid, multi);
 	[cont setHeaderView:nil];
 	int type = DW_CFA_STRING;
 	[cont setup];
 	NSTableColumn *column = [[NSTableColumn alloc] init];
 	[cont addTableColumn:column];
 	[cont addColumn:column andType:type];
+[column release];
+DW_MUTEX_UNLOCK;
 	return cont;
 }
 /*
 * Appends the specified text to the listbox's (or combobox) entry list.
 *          handle: Handle to the listbox to be appended to.
 *          text: Text to append into listbox.
 */
 void API dw_listbox_append(HWND handle, char *text)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	id object = handle;
 	if([object isMemberOfClass:[DWComboBox class]])
 	{
 		DWComboBox *combo = handle;
 [cont addRow:newrow];
 /*[cont performSelectorOnMainThread:@selector(addRow:)
 withObject:newrow
 waitUntilDone:YES];*/
 [cont reloadData];
-[newrow release];
 }
+DW_MUTEX_UNLOCK;
 }
 /*
 * Inserts the specified text into the listbox's (or combobox) entry list.
 * Parameters:
 *          text: Text to insert into listbox.
 *          pos: 0-based position to insert text
 */
 void API dw_listbox_insert(HWND handle, char *text, int pos)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	id object = handle;
 	if([object isMemberOfClass:[DWComboBox class]])
 	{
 		DWComboBox *combo = handle;
 NSString *nstr = [ NSString stringWithUTF8String:text ];
 NSArray *newrow = [NSArray arrayWithObject:nstr];
 [cont insertRow:newrow at:pos];
 [cont reloadData];
-[newrow release];
 }
+DW_MUTEX_UNLOCK;
 }
 /*
 * Appends the specified text items to the listbox's (or combobox) entry list.
 * Parameters:
 *          text: Text strings to append into listbox.
 *          count: Number of text strings to append
 */
 void API dw_listbox_list_append(HWND handle, char **text, int count)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	id object = handle;
 	if([object isMemberOfClass:[DWComboBox class]])
 	{
 		DWComboBox *combo = handle;
 		{
 NSString *nstr = [ NSString stringWithUTF8String:text[z] ];
 NSArray *newrow = [[NSArray alloc] arrayWithObject:nstr];
 [cont addRow:newrow];
-[newrow release];
 }
 [cont reloadData];
 }
+DW_MUTEX_UNLOCK;
 }
 /*
 * Clears the listbox's (or combobox) list of all entries.
 * Parameters:
 *          handle: Handle to the listbox to be cleared.
 */
 void API dw_listbox_clear(HWND handle)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	id object = handle;
 	if([object isMemberOfClass:[DWComboBox class]])
 	{
 		DWComboBox *combo = handle;
 DWContainer *cont = handle;
 [cont clear];
 [cont reloadData];
 }
+DW_MUTEX_UNLOCK;
 }
 /*
 * Returns the listbox's item count.
 * Parameters:
 		return (int)[combo numberOfItems];
 	}
 else if([object isMemberOfClass:[DWContainer class]])
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 DWContainer *cont = handle;
+int result = (int)[cont numberOfRowsInTableView:cont];
-return (int)[cont numberOfRowsInTableView:cont];
+DW_MUTEX_UNLOCK;
+return result;
 }
 	return 0;
 }
 /*
 *          handle: Handle to the listbox to be cleared.
 *          top: Index to the top item.
 */
 void API dw_listbox_set_top(HWND handle, int top)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	id object = handle;
 	if([object isMemberOfClass:[DWComboBox class]])
 	{
 		DWComboBox *combo = handle;
 {
 DWContainer *cont = handle;
 [cont scrollRowToVisible:top];
 }
+DW_MUTEX_UNLOCK;
 }
 /*
 * Copies the given index item's text into buffer.
 * Parameters:
 *          buffer: Buffer where text will be copied.
 *          length: Length of the buffer (including NULL).
 */
 void API dw_listbox_get_text(HWND handle, unsigned int index, char *buffer, unsigned int length)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	id object = handle;
 	if([object isMemberOfClass:[DWComboBox class]])
 	{
 		DWComboBox *combo = handle;
 DWContainer *cont = handle;
 NSString *nstr = [cont getRow:index and:0];
 strncpy(buffer, [ nstr UTF8String ], length - 1);
 }
+DW_MUTEX_UNLOCK;
 }
 /*
 * Sets the text of a given listbox entry.
 * Parameters:
 *          index: Index into the list to be queried.
 *          buffer: Buffer where text will be copied.
 */
 void API dw_listbox_set_text(HWND handle, unsigned int index, char *buffer)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	id object = handle;
 	if([object isMemberOfClass:[DWComboBox class]])
 	{
 		DWComboBox *combo = handle;
 NSString *nstr = [ NSString stringWithUTF8String:buffer ];
 [cont editCell:nstr at:index and:0];
 [cont reloadData];
 }
+DW_MUTEX_UNLOCK;
 }
 /*
 * Returns the index to the item in the list currently selected.
 * Parameters:
 		DWComboBox *combo = handle;
 		return (int)[combo indexOfSelectedItem];
 	}
 else if([object isMemberOfClass:[DWContainer class]])
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 DWContainer *cont = handle;
+int result = (int)[cont selectedRow];
-return (int)[cont selectedRow];
+DW_MUTEX_UNLOCK;
+return result;
 }
 	return -1;
 }
 /*
 *          handle: Handle to the listbox to be queried.
 *          where: Either the previous return or -1 to restart.
 */
 int API dw_listbox_selected_multi(HWND handle, int where)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	id object = handle;
 int retval = -1;
 if([object isMemberOfClass:[DWContainer class]])
 {
 if(result != NSNotFound)
 {
 retval = (int)result;
 }
-[selected release];
+}
-}
+DW_MUTEX_UNLOCK;
 	return retval;
 }
 /*
 * Sets the selection state of a given index.
 *          index: Item index.
 *          state: TRUE if selected FALSE if unselected.
 */
 void API dw_listbox_select(HWND handle, int index, int state)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	id object = handle;
 	if([object isMemberOfClass:[DWComboBox class]])
 	{
 		DWComboBox *combo = handle;
 DWContainer *cont = handle;
 NSIndexSet *selected = [[NSIndexSet alloc] initWithIndex:(NSUInteger)index];
 [cont selectRowIndexes:selected byExtendingSelection:YES];
 [selected release];
 }
+DW_MUTEX_UNLOCK;
 }
 /*
 * Deletes the item with given index from the list.
 * Parameters:
 *          handle: Handle to the listbox to be set.
 *          index: Item index.
 */
 void API dw_listbox_delete(HWND handle, int index)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	id object = handle;
 	if([object isMemberOfClass:[DWComboBox class]])
 	{
 		DWComboBox *combo = handle;
 DWContainer *cont = handle;
 [cont removeRow:index];
 [cont reloadData];
 }
+DW_MUTEX_UNLOCK;
 }
 /*
 * Create a new Combobox window (widget) to be packed.
 * Parameters:
 [scrollview setAutohidesScrollers:YES];
 [scrollview setAutoresizingMask:NSViewWidthSizable|NSViewHeightSizable];
 [scrollview setDocumentView:mle];
 [mle setAutoresizingMask:NSViewWidthSizable];
 /* [mle setTag:cid]; Why doesn't this work? */
+[mle release];
 	return scrollview;
 }
 /*
 * Adds text to an MLE box and returns the current point.
 *       x: X coordinate.
 *       y: Y coordinate.
 */
 void API dw_draw_point(HWND handle, HPIXMAP pixmap, int x, int y)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	id image = handle;
 	if(pixmap)
 	{
 		image = (id)pixmap->handle;
 		[image lockFocus];
 	}
 	NSBezierPath* aPath = [NSBezierPath bezierPath];
 	[aPath setLineWidth: 0.5];
 NSColor *color = [NSColor colorWithDeviceRed: DW_RED_VALUE(_foreground)/255.0 green: DW_GREEN_VALUE(_foreground)/255.0 blue: DW_BLUE_VALUE(_foreground)/255.0 alpha: 1];
 [color set];
-[color release];
 	[aPath moveToPoint:NSMakePoint(x, y)];
 	[aPath stroke];
-[aPath release];
 	[image unlockFocus];
+DW_MUTEX_UNLOCK;
 }
 /* Draw a line on a window (preferably a render window).
 * Parameters:
 *       handle: Handle to the window.
 *       x2: Second X coordinate.
 *       y2: Second Y coordinate.
 */
 void API dw_draw_line(HWND handle, HPIXMAP pixmap, int x1, int y1, int x2, int y2)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	id image = handle;
 	if(pixmap)
 	{
 		image = (id)pixmap->handle;
 		[image lockFocus];
 	}
 	NSBezierPath* aPath = [NSBezierPath bezierPath];
 	[aPath setLineWidth: 0.5];
 NSColor *color = [NSColor colorWithDeviceRed: DW_RED_VALUE(_foreground)/255.0 green: DW_GREEN_VALUE(_foreground)/255.0 blue: DW_BLUE_VALUE(_foreground)/255.0 alpha: 1];
 [color set];
-[color release];
 	[aPath moveToPoint:NSMakePoint(x1, y1)];
 	[aPath lineToPoint:NSMakePoint(x2, y2)];
 	[aPath stroke];
-[aPath release];
 	[image unlockFocus];
+DW_MUTEX_UNLOCK;
 }
 /* Draw text on a window (preferably a render window).
 * Parameters:
 *       handle: Handle to the window.
 *       y: Y coordinate.
 *       text: Text to be displayed.
 */
 void API dw_draw_text(HWND handle, HPIXMAP pixmap, int x, int y, char *text)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	id image = handle;
 	NSString *nstr = [ NSString stringWithUTF8String:text ];
 	if(image)
 	{
 		if([image isMemberOfClass:[NSView class]])
 NSDictionary *dict = [[NSDictionary alloc] initWithObjectsAndKeys:
 /*[NSFont fontWithName:@"Helvetica" size:26], NSFontAttributeName,*/
 color, NSForegroundColorAttributeName, nil];
 			[nstr drawAtPoint:NSMakePoint(x, y) withAttributes:dict];
 [dict release];
-[color release];
 			[image unlockFocus];
 		}
 		_DWLastDrawable = handle;
 	}
 	if(pixmap)
 NSDictionary *dict = [[NSDictionary alloc] initWithObjectsAndKeys:
 /*[NSFont fontWithName:@"Helvetica" size:26], NSFontAttributeName,*/
 color, NSForegroundColorAttributeName, nil];
 		[nstr drawAtPoint:NSMakePoint(x, y) withAttributes:dict];
 [dict release];
-[color release];
 		[image unlockFocus];
 	}
-[nstr release];
+DW_MUTEX_UNLOCK;
 }
 /* Query the width and height of a text string.
 * Parameters:
 *       handle: Handle to the window.
 *       width: Pointer to a variable to be filled in with the width.
 *       height Pointer to a variable to be filled in with the height.
 */
 void API dw_font_text_extents_get(HWND handle, HPIXMAP pixmap, char *text, int *width, int *height)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	id image = handle;
-	NSString *nstr = [[ NSString stringWithUTF8String:text ] autorelease];
+	NSString *nstr = [NSString stringWithUTF8String:text];
 	if(pixmap)
 	{
 		image = (id)pixmap->handle;
 		[image lockFocus];
 	}
 	}
 	if(height)
 	{
 		*height = size.height;
 	}
-[nstr release];
 	[image unlockFocus];
+DW_MUTEX_UNLOCK;
 }
 /* Draw a polygon on a window (preferably a render window).
 * Parameters:
 *       handle: Handle to the window.
 *       width: Width of rectangle.
 *       height: Height of rectangle.
 */
 void API dw_draw_polygon( HWND handle, HPIXMAP pixmap, int fill, int npoints, int *x, int *y )
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	id image = handle;
 	int z;
 	if(pixmap)
 	{
 		image = (id)pixmap->handle;
 	}
 	NSBezierPath* aPath = [NSBezierPath bezierPath];
 	[aPath setLineWidth: 0.5];
 NSColor *color = [NSColor colorWithDeviceRed: DW_RED_VALUE(_foreground)/255.0 green: DW_GREEN_VALUE(_foreground)/255.0 blue: DW_BLUE_VALUE(_foreground)/255.0 alpha: 1];
 [color set];
-[color release];
 	[aPath moveToPoint:NSMakePoint(*x, *y)];
 	for(z=1;z<npoints;z++)
 	{
 		[aPath lineToPoint:NSMakePoint(x[z], y[z])];
 	if(fill)
 	{
 		[aPath fill];
 	}
 	[aPath stroke];
-[aPath release];
 	[image unlockFocus];
+DW_MUTEX_UNLOCK;
 }
 /* Draw a rectangle on a window (preferably a render window).
 * Parameters:
 *       handle: Handle to the window.
 *       width: Width of rectangle.
 *       height: Height of rectangle.
 */
 void API dw_draw_rect(HWND handle, HPIXMAP pixmap, int fill, int x, int y, int width, int height)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	id image = handle;
 	if(pixmap)
 	{
 		image = (id)pixmap->handle;
 		[image lockFocus];
 	}
 	NSBezierPath* aPath = [NSBezierPath bezierPath];
 	[aPath setLineWidth: 0.5];
 NSColor *color = [NSColor colorWithDeviceRed: DW_RED_VALUE(_foreground)/255.0 green: DW_GREEN_VALUE(_foreground)/255.0 blue: DW_BLUE_VALUE(_foreground)/255.0 alpha: 1];
 [color set];
-[color release];
 	[aPath moveToPoint:NSMakePoint(x, y)];
 	[aPath lineToPoint:NSMakePoint(x, y + height)];
 	[aPath lineToPoint:NSMakePoint(x + width, y + height)];
 	[aPath lineToPoint:NSMakePoint(x + width, y)];
 [aPath closePath];
 [aPath fill];
 	[aPath stroke];
-[aPath release];
 	[image unlockFocus];
+DW_MUTEX_UNLOCK;
 }
 /*
 * Create a tree object to be packed.
 * Parameters:
 *       id: An ID to be used for getting the resource from the
 *           resource file.
 */
 HWND API dw_tree_new(ULONG cid)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 NSScrollView *scrollview  = [[NSScrollView alloc] init];
 	DWTree *tree = [[DWTree alloc] init];
 [tree setScrollview:scrollview];
 [scrollview setBorderType:NSBezelBorder];
 [tree setAllowsMultipleSelection:NO];
 	[tree setDataSource:tree];
 [scrollview setDocumentView:tree];
 [tree setHeaderView:nil];
 [tree setTag:cid];
+[scrollview release];
+DW_MUTEX_UNLOCK;
 return tree;
 }
 /*
 * Inserts an item into a tree window (widget) after another item.
 *          parent: Parent handle or 0 if root.
 *          itemdata: Item specific data.
 */
 HTREEITEM API dw_tree_insert_after(HWND handle, HTREEITEM item, char *title, HICN icon, HTREEITEM parent, void *itemdata)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 DWTree *tree = handle;
 NSString *nstr = [NSString stringWithUTF8String:title];
 NSPointerArray *treenode = [NSPointerArray pointerArrayWithWeakObjects];
 [treenode addPointer:icon];
 [treenode addPointer:nstr];
 [treenode addPointer:itemdata];
 [treenode addPointer:NULL];
 [tree addTree:treenode and:parent];
 [tree reloadData];
+DW_MUTEX_UNLOCK;
 	return treenode;
 }
 /*
 * Inserts an item into a tree window (widget).
 *          handle: Handle to the tree containing the item.
 *          item: Handle of the item to be modified.
 */
 char * API dw_tree_get_title(HWND handle, HTREEITEM item)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 NSPointerArray *array = (NSPointerArray *)item;
 NSString *nstr = (NSString *)[array pointerAtIndex:1];
+DW_MUTEX_UNLOCK;
 return strdup([nstr UTF8String]);
 }
 /*
 * Gets the text an item in a tree window (widget).
 *          title: The text title of the entry.
 *          icon: Handle to coresponding icon.
 */
 void API dw_tree_item_change(HWND handle, HTREEITEM item, char *title, HICN icon)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 DWTree *tree = handle;
 NSPointerArray *array = (NSPointerArray *)item;
 if(title)
 {
 NSString *nstr = [NSString stringWithUTF8String:title];
 if(icon)
 {
 [array replacePointerAtIndex:0 withPointer:icon];
 }
 [tree reloadData];
+DW_MUTEX_UNLOCK;
 }
 /*
 * Sets the item data of a tree item.
 * Parameters:
 *          item: Handle of the item to be modified.
 *          itemdata: User defined data to be associated with item.
 */
 void API dw_tree_item_set_data(HWND handle, HTREEITEM item, void *itemdata)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 NSPointerArray *array = (NSPointerArray *)item;
 [array replacePointerAtIndex:2 withPointer:itemdata];
+DW_MUTEX_UNLOCK;
 }
 /*
 * 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.
 */
 void * API dw_tree_item_get_data(HWND handle, HTREEITEM item)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 NSPointerArray *array = (NSPointerArray *)item;
-return [array pointerAtIndex:2];
+void *result = [array pointerAtIndex:2];
+DW_MUTEX_UNLOCK;
+return result;
 }
 /*
 * Sets this item as the active selection.
 * Parameters:
 *       handle: Handle to the tree window (widget) to be selected.
 *       item: Handle to the item to be selected.
 */
 void API dw_tree_item_select(HWND handle, HTREEITEM item)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 DWTree *tree = handle;
 NSInteger itemIndex = [tree rowForItem:item];
 if(itemIndex > -1)
 {
 [tree selectRowIndexes:[NSIndexSet indexSetWithIndex:itemIndex] byExtendingSelection:NO];
 }
+DW_MUTEX_UNLOCK;
 }
 /*
 * Removes all nodes from a tree.
 * Parameters:
 *       handle: Handle to the window (widget) to be cleared.
 */
 void API dw_tree_clear(HWND handle)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 DWTree *tree = handle;
 [tree clear];
+DW_MUTEX_UNLOCK;
 }
 /*
 * Expands a node on a tree.
 * Parameters:
 *       handle: Handle to the tree window (widget).
 *       item: Handle to node to be expanded.
 */
 void API dw_tree_item_expand(HWND handle, HTREEITEM item)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 DWTree *tree = handle;
 [tree expandItem:item];
+DW_MUTEX_UNLOCK;
 }
 /*
 * Collapses a node on a tree.
 * Parameters:
 *       handle: Handle to the tree window (widget).
 *       item: Handle to node to be collapsed.
 */
 void API dw_tree_item_collapse(HWND handle, HTREEITEM item)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 DWTree *tree = handle;
 [tree collapseItem:item];
+DW_MUTEX_UNLOCK;
 }
 /*
 * Removes a node from a tree.
 * Parameters:
 *       handle: Handle to the window (widget) to be cleared.
 *       item: Handle to node to be deleted.
 */
 void API dw_tree_item_delete(HWND handle, HTREEITEM item)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 DWTree *tree = handle;
 [tree deleteNode:item];
 [tree reloadData];
+DW_MUTEX_UNLOCK;
 }
 /*
 * Create a container object to be packed.
 * Parameters:
 *       id: An ID to be used for getting the resource from the
 *           resource file.
 */
 HWND API dw_container_new(ULONG cid, int multi)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	DWContainer *cont = _cont_new(cid, multi);
 NSScrollView *scrollview = [cont scrollview];
 [scrollview setHasHorizontalScroller:YES];
 	NSTableHeaderView *header = [[NSTableHeaderView alloc] init];
 	[cont setHeaderView:header];
+[header release];
+DW_MUTEX_UNLOCK;
 	return cont;
 }
 /*
 * Sets up the container columns.
 *          separator: The column number that contains the main separator.
 *                     (this item may only be used in OS/2)
 */
 int API dw_container_setup(HWND handle, unsigned long *flags, char **titles, int count, int separator)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	int z;
 	DWContainer *cont = handle;
 	[cont setup];
 	{
 		NSTableColumn *column = [[NSTableColumn alloc] init];
 		[[column headerCell] setStringValue:[ NSString stringWithUTF8String:titles[z] ]];
 if(flags[z] & DW_CFA_BITMAPORICON)
 {
-NSImageCell *imagecell = [[[NSImageCell alloc] init] autorelease];
+NSImageCell *imagecell = [[NSImageCell alloc] init];
 [column setDataCell:imagecell];
 if(z == 0 && titles[z] && strcmp(titles[z], "Icon") == 0)
 {
 [column setResizingMask:NSTableColumnNoResizing];
 [column setWidth:20];
 }
+[imagecell release];
 }
 		[cont addTableColumn:column];
 		[cont addColumn:column andType:(int)flags[z]];
+[column release];
 	}
+DW_MUTEX_UNLOCK;
 	return TRUE;
 }
 /*
 * Sets up the filesystem columns, note: filesystem always has an icon/filename field.
 *          handle: Handle to the container window (widget).
 *          rowcount: The number of items to be populated.
 */
 void * API dw_container_alloc(HWND handle, int rowcount)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	DWContainer *cont = handle;
 	[cont addRows:rowcount];
+DW_MUTEX_UNLOCK;
 	return cont;
 }
 /*
 * Sets an item in specified row and column to the given data.
 *          row: Zero based row of data being set.
 *          data: Pointer to the data to be added.
 */
 void API dw_container_set_item(HWND handle, void *pointer, int column, int row, void *data)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	DWContainer *cont = handle;
 	id object = nil;
 	int type = [cont cellType:column];
 	int lastadd = [cont lastAddPoint];
 if(!data)
 {
+DW_MUTEX_UNLOCK;
 return;
 }
 	if(type & DW_CFA_BITMAPORICON)
 	{
 		object = *((NSImage **)data);
 			strftime(textbuffer, 100, "%X", &curtm);
 		}
 		else
 		{
+DW_MUTEX_UNLOCK;
 			return;
 		}
 		object = [ NSString stringWithUTF8String:textbuffer ];
 	}
 	[cont editCell:object at:(row+lastadd) and:column];
+DW_MUTEX_UNLOCK;
 }
 /*
 * Changes an existing item in specified row and column to the given data.
 * Parameters:
 *          handle: Handle to the container window (widget).
 *          column: Zero based column.
 */
 int API dw_container_get_column_type(HWND handle, int column)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	DWContainer *cont = handle;
-	return [cont cellType:column];
+	int result = [cont cellType:column];
+DW_MUTEX_UNLOCK;
+return result;
 }
 /*
 * Gets column type for a filesystem container column
 * Parameters:
 *          handle: Handle to the container window (widget).
 *          column: Zero based column.
 */
 int API dw_filesystem_get_column_type(HWND handle, int column)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	DWContainer *cont = handle;
-	return [cont cellType:column+2];
+	int result = [cont cellType:column+2];
+DW_MUTEX_UNLOCK;
+return result;
 }
 /*
 * Sets the width of a column in the container.
 * Parameters:
 *          column: Zero based column of width being set.
 *          width: Width of column in pixels.
 */
 void API dw_container_set_column_width(HWND handle, int column, int width)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 DWContainer *cont = handle;
 NSTableColumn *col = [cont getColumn:column];
 [col setWidth:width];
+DW_MUTEX_UNLOCK;
 }
 /*
 * Sets the title of a row in the container.
 * Parameters:
 *          row: Zero based row of data being set.
 *          title: String title of the item.
 */
 void API dw_container_set_row_title(void *pointer, int row, char *title)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	DWContainer *cont = pointer;
-	return [cont setRow:row title:title];
+	[cont setRow:row title:title];
+DW_MUTEX_UNLOCK;
 }
 /*
 * Sets the title of a row in the container.
 * Parameters:
 *          pointer: Pointer to the allocated memory in dw_container_alloc().
 *          rowcount: The number of rows to be inserted.
 */
 void API dw_container_insert(HWND handle, void *pointer, int rowcount)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	DWContainer *cont = handle;
-	return [cont reloadData];
+[cont reloadData];
+DW_MUTEX_UNLOCK;
 }
 /*
 * Removes all rows from a container.
 * Parameters:
 *       handle: Handle to the window (widget) to be cleared.
 *       redraw: TRUE to cause the container to redraw immediately.
 */
 void API dw_container_clear(HWND handle, int redraw)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	DWContainer *cont = handle;
 	[cont clear];
 if(redraw)
 {
 [cont reloadData];
 }
+DW_MUTEX_UNLOCK;
 }
 /*
 * Removes the first x rows from a container.
 * Parameters:
 *       handle: Handle to the window (widget) to be deleted from.
 *       rowcount: The number of rows to be deleted.
 */
 void API dw_container_delete(HWND handle, int rowcount)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 DWContainer *cont = handle;
 int x;
 for(x=0;x<rowcount;x++)
 {
 [cont removeRow:0];
 }
+DW_MUTEX_UNLOCK;
 }
 /*
 * Scrolls container up or down.
 * Parameters:
 *              return items that are currently selected.  Otherwise
 *              it will return all records in the container.
 */
 char * API dw_container_query_start(HWND handle, unsigned long flags)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 DWContainer *cont = handle;
 NSIndexSet *selected = [cont selectedRowIndexes];
 NSUInteger result = [selected indexGreaterThanOrEqualToIndex:0];
 char *retval = NULL;
 if(result != NSNotFound)
 {
 retval = [cont getRowTitle:(int)result];
 [cont setLastQueryPoint:(int)result];
 }
-[selected release];
+DW_MUTEX_UNLOCK;
 	return retval;
 }
 /*
 * Continues an existing query of a container.
 *              return items that are currently selected.  Otherwise
 *              it will return all records in the container.
 */
 char * API dw_container_query_next(HWND handle, unsigned long flags)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 DWContainer *cont = handle;
 int lastQueryPoint = [cont lastQueryPoint];
 NSIndexSet *selected = [cont selectedRowIndexes];
 NSUInteger result = [selected indexGreaterThanIndex:lastQueryPoint];
 char *retval = NULL;
 if(result != NSNotFound)
 {
 retval = [cont getRowTitle:(int)result];
 [cont setLastQueryPoint:(int)result];
 }
-[selected release];
+DW_MUTEX_UNLOCK;
 	return retval;
 }
 /*
 * Cursors the item with the text speficied, and scrolls to that item.
 *       handle: Handle to the window (widget) to be queried.
 *       text:  Text usually returned by dw_container_query().
 */
 void API dw_container_cursor(HWND handle, char *text)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 DWContainer *cont = handle;
 char *thistext;
 int x, count = (int)[cont numberOfRowsInTableView:cont];
 for(x=0;x<count;x++)
 [cont selectRowIndexes:selected byExtendingSelection:YES];
 [selected release];
 }
 }
+DW_MUTEX_UNLOCK;
 }
 /*
 * Deletes the item with the text speficied.
 * Parameters:
 *       handle: Handle to the window (widget).
 *       text:  Text usually returned by dw_container_query().
 */
 void API dw_container_delete_row(HWND handle, char *text)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 DWContainer *cont = handle;
 char *thistext;
 int x, count = (int)[cont numberOfRowsInTableView:cont];
 for(x=0;x<count;x++)
 {
 [cont removeRow:x];
 return;
 }
 }
+DW_MUTEX_UNLOCK;
 }
 /*
 * Optimizes the column widths so that all data is visible.
 * Parameters:
 *       handle: Handle to the window (widget) to be optimized.
 */
 void API dw_container_optimize(HWND handle)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	DWContainer *cont = handle;
 	/*[cont sizeToFit];*/
 	[cont setColumnAutoresizingStyle:NSTableViewUniformColumnAutoresizingStyle];
+DW_MUTEX_UNLOCK;
 }
 /*
 * Inserts an icon into the taskbar.
 * Parameters:
 {
 NSBundle *bundle = [NSBundle mainBundle];
 NSString *respath = [bundle resourcePath];
 NSString *filepath = [respath stringByAppendingFormat:@"/%u.png", resid];
 	NSImage *image = [[NSImage alloc] initWithContentsOfFile:filepath];
-[bundle release];
-[respath release];
-[filepath release];
 	return image;
 }
 /*
 * Obtains an icon from a file.
 if(!image)
 {
 nstr = [nstr stringByAppendingString:@".png"];
 image = [[NSImage alloc] initWithContentsOfFile:nstr];
 }
-[nstr release];
 	return image;
 }
 /*
 * Obtains an icon from data
 *                 DW pick the appropriate file extension.
 *                 (ICO on OS/2 or Windows, XPM on Unix)
 */
 HICN API dw_icon_load_from_data(char *data, int len)
 {
-	NSData *thisdata = [[[NSData alloc] dataWithBytes:data length:len] autorelease];
+	NSData *thisdata = [[NSData alloc] dataWithBytes:data length:len];
 	NSImage *image = [[NSImage alloc] initWithData:thisdata];
-[thisdata release];
 	return image;
 }
 /*
 * Frees a loaded resource in OS/2 and Windows.
 * Returns:
 *       A handle to a splitbar window or NULL on failure.
 */
 HWND API dw_splitbar_new(int type, HWND topleft, HWND bottomright, unsigned long cid)
 {
+HWND tmpbox = dw_box_new(DW_VERT, 0);
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	DWSplitBar *split = [[DWSplitBar alloc] init];
-HWND tmpbox = dw_box_new(DW_VERT, 0);
 [split setDelegate:split];
 dw_box_pack_start(tmpbox, topleft, 0, 0, TRUE, TRUE, 0);
 	[split addSubview:tmpbox];
 tmpbox = dw_box_new(DW_VERT, 0);
 dw_box_pack_start(tmpbox, bottomright, 0, 0, TRUE, TRUE, 0);
 else
 {
 [split setVertical:YES];
 }
 /* [split setTag:cid]; Why doesn't this work? */
+DW_MUTEX_UNLOCK;
 	return split;
 }
 /*
 * Sets the position of a splitbar (pecentage).
 *       handle: The handle to the splitbar returned by dw_splitbar_new().
 */
 void API dw_splitbar_set(HWND handle, float percent)
 {
 	DWSplitBar *split = handle;
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 NSRect rect = [split frame];
 float pos;
 /* Calculate the position based on the size */
 if([split isVertical])
 {
 * event when we get an actual size to try
 * to set the splitbar again.
 */
 [split setPercent:percent];
 }
+DW_MUTEX_UNLOCK;
 }
 /*
 * Gets the position of a splitbar (pecentage).
 * Parameters:
 * Parameters:
 *       id: An ID to be used with dw_window_from_id() or 0L.
 */
 HWND API dw_bitmap_new(ULONG cid)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	NSImageView *bitmap = [[NSImageView alloc] init];
 	[bitmap setImageFrameStyle:NSImageFrameNone];
 	[bitmap setEditable:NO];
 [bitmap setTag:cid];
+DW_MUTEX_UNLOCK;
 	return bitmap;
 }
 /*
 * Creates a pixmap with given parameters.
 if(!image)
 {
 nstr = [nstr stringByAppendingString:@".png"];
 image = [[NSImage alloc] initWithContentsOfFile:nstr];
 }
-[nstr release];
 	NSSize size = [image size];
 	pixmap->width = size.width;
 	pixmap->height = size.height;
 	pixmap->handle = image;
 	return pixmap;
 {
 	HPIXMAP pixmap;
 	if (!(pixmap = calloc(1,sizeof(struct _hpixmap))))
 		return NULL;
-	NSData *thisdata = [[[NSData alloc] dataWithBytes:data length:len] autorelease];
+	NSData *thisdata = [[NSData alloc] dataWithBytes:data length:len];
 	NSImage *image = [[NSImage alloc] initWithData:thisdata];
 	NSSize size = [image size];
 	pixmap->width = size.width;
 	pixmap->height = size.height;
 	pixmap->handle = image;
-[thisdata release];
 	return pixmap;
 }
 /*
 * Creates a bitmap mask for rendering bitmaps with transparent backgrounds
 	NSImage *image = [[NSImage alloc] initWithContentsOfFile:filepath];
 	NSSize size = [image size];
 	pixmap->width = size.width;
 	pixmap->height = size.height;
 	pixmap->handle = image;
-[bundle release];
-[respath release];
-[filepath release];
 [image release];
 	return pixmap;
 }
 /*
 *       xsrc: X coordinate of source.
 *       ysrc: Y coordinate of source.
 */
 void API dw_pixmap_bitblt(HWND dest, HPIXMAP destp, int xdest, int ydest, int width, int height, HWND src, HPIXMAP srcp, int xsrc, int ysrc)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	id bltdest = dest;
 	id bltsrc = src;
 	if(destp)
 	{
 		bltdest = (id)destp->handle;
 		bltsrc = (id)srcp->handle;
 		NSImage *image = bltsrc;
 		[image drawAtPoint:NSMakePoint(xdest, ydest) fromRect:NSMakeRect(xsrc, ysrc, width, height) operation:NSCompositeCopy fraction:1.0];
 	}
 	[bltdest unlockFocus];
+DW_MUTEX_UNLOCK;
 }
 /*
 * Create a new static text window (widget) to be packed.
 * Not available under OS/2, eCS
 	sprintf(buffer, "%04d-%02d-%02d 00:00:00 +0600", year, month, day);
 	date = [[NSDate alloc] initWithString:[ NSString stringWithUTF8String:buffer ]];
 	[calendar setDateValue:date];
+[date release];
 }
 /*
 * Gets the position of a splitbar (pecentage).
 * Parameters:
 	DWCalendar *calendar = handle;
 	NSDate *date = [calendar dateValue];
 	NSDateFormatter *df = [[NSDateFormatter alloc] init];
 	NSString *nstr = [df stringFromDate:date];
 	sscanf([ nstr UTF8String ], "%d-%d-%d", year, month, day);
+[df release];
 }
 /*
 * Causes the embedded HTML widget to take action.
 * Parameters:
 *       text: The default text to be in the entryfield widget.
 *       id: An ID to be used with dw_window_from_id() or 0L.
 */
 HWND API dw_html_new(unsigned long cid)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	WebView *web = [[WebView alloc] init];
 /* [web setTag:cid]; Why doesn't this work? */
+DW_MUTEX_UNLOCK;
 	return web;
 }
 /*
 * Returns the current X and Y coordinates of the mouse pointer.
 	else
 	{
 		[notebook addTabViewItem:notepage];
 	}
 	[notebook setPageid:(page+1)];
+[notepage release];
 	return (unsigned long)page;
 }
 /*
 * Remove a page from a notebook.
 *       title: The Window title.
 *       flStyle: Style flags, see the PM reference.
 */
 HWND API dw_window_new(HWND hwndOwner, char *title, ULONG flStyle)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	NSRect frame = NSMakeRect(1,1,1,1);
 NSWindow *window = [[NSWindow alloc]
 						initWithContentRect:frame
 						styleMask:(flStyle | NSTexturedBackgroundWindowMask)
 						backing:NSBackingStoreBuffered
 [window setContentView:view];
 [window setDelegate:view];
 [window makeKeyAndOrderFront:nil];
 	[window setAllowsConcurrentViewDrawing:NO];
+[view release];
 /* If it isn't a toplevel window... */
 if(hwndOwner)
 {
 id object = hwndOwner;
 /* Set the window level to be floating */
 [window setLevel:NSFloatingWindowLevel];
 [window setHidesOnDeactivate:YES];
 }
 }
+	DW_MUTEX_UNLOCK;
 	return (HWND)window;
 }
 /*
 * Call a function from the window (widget)'s context.
 * Parameters:
 *           handle: The window handle to destroy.
 */
 int API dw_window_destroy(HWND handle)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	NSObject *object = handle;
 	if([ object isKindOfClass:[ NSWindow class ] ])
 	{
 		NSWindow *window = handle;
 		[window close];
 	}
+DW_MUTEX_UNLOCK;
 	return 0;
 }
 /*
 * Gets the text used for a given window.
 *       handle: Handle to the window.
 *       text: The text associsated with a given window.
 */
 void API dw_window_set_text(HWND handle, char *text)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	NSObject *object = handle;
 	if([ object isKindOfClass:[ NSControl class ] ])
 	{
 		NSControl *control = handle;
 	else if([ object isKindOfClass:[ NSWindow class ] ])
 	{
 		NSWindow *window = handle;
 		[window setTitle:[ NSString stringWithUTF8String:text ]];
 	}
+DW_MUTEX_UNLOCK;
 }
 /*
 * Disables given window (widget).
 * Parameters:
 if(pixmap)
 {
 [iv setImage:pixmap];
 }
+[pixmap release];
 	}
 }
 /*
 * Sets the bitmap used for a given static window.
 *          width: New width in pixels.
 *          height: New height in pixels.
 */
 void API dw_window_set_size(HWND handle, ULONG width, ULONG height)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	NSObject *object = handle;
 	NSSize size;
 	size.width = width;
 	size.height = height;
 	if([ object isKindOfClass:[ NSWindow class ] ])
 	{
 		NSWindow *window = handle;
 		[window setContentSize:size];
 	}
+DW_MUTEX_UNLOCK;
 }
 /*
 * Sets the position of a given window (widget).
 * Parameters:
 *          x: X location from the bottom left.
 *          y: Y location from the bottom left.
 */
 void API dw_window_set_pos(HWND handle, LONG x, LONG y)
 {
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 	NSObject *object = handle;
 	NSPoint point;
 	point.x = x;
 	point.y = y;
 	if([ object isKindOfClass:[ NSWindow class ] ])
 	{
 		NSWindow *window = handle;
 		[window setFrameOrigin:point];
 	}
+DW_MUTEX_UNLOCK;
 }
 /*
 * Sets the position and size of a given window (widget).
 * Parameters:
 void API dw_flush(void)
 {
 /* This may need to be thread specific */
 	if(_DWLastDrawable)
 	{
+int _locked_by_me = FALSE;
+DW_MUTEX_LOCK;
 		id object = _DWLastDrawable;
 		NSWindow *window = [object window];
 		[window flushWindow];
+DW_MUTEX_UNLOCK;
 	}
 }
 /* Functions for managing the user data lists that are associated with
 * a given window handle.  Used in dw_window_set_data() and
 * Parameters:
 *       mutex: The handle to the mutex returned by dw_mutex_new().
 */
 void dw_mutex_lock(HMTX mutex)
 {
-pthread_mutex_lock(mutex);
+DWTID saved = (DWTID)-1;
+if(DWThread == pthread_self())
+{
+saved = DWThread;
+DWThread = (DWTID)-1;
+pthread_mutex_unlock(DWRunMutex);
+}
+pthread_mutex_lock(mutex);
+if(saved != (DWTID)-1)
+{
+DWThread = saved;
+pthread_mutex_lock(DWRunMutex);
+}
 }
 /*
 * Reliquishes the access to the semaphore.
 * Parameters:

Mercurial > dwindows

comparison mac/dw.m @ 691:578bbfd8c904