fix issue on macos x

include/MiniFB.h

@@ -59,13 +59,13 @@ const uint8_t *     mfb_get_key_buffer(struct mfb_window *window);          // O
 void                mfb_set_target_fps(uint32_t fps);
 bool                mfb_wait_sync(struct mfb_window *window);
 
-struct mfb_timer *  mfb_timer_create();
+struct mfb_timer *  mfb_timer_create(void);
 void                mfb_timer_destroy(struct mfb_timer *tmr);
 void                mfb_timer_reset(struct mfb_timer *tmr);
 double              mfb_timer_now(struct mfb_timer *tmr);
 double              mfb_timer_delta(struct mfb_timer *tmr);
-double              mfb_timer_get_frequency();
+double              mfb_timer_get_frequency(void);
-double              mfb_timer_get_resolution();
+double              mfb_timer_get_resolution(void);
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 

src/MiniFB_common.c

@@ -565,6 +565,9 @@ mfb_get_key_name(mfb_key key) {
         case KB_KEY_MENU:
             return "Menu";
 
+        case KB_KEY_UNKNOWN:
+            return "Unknown";
     }
+    
     return "Unknown";
 }

src/MiniFB_internal.h

@@ -18,7 +18,7 @@ extern "C" {
 #endif
 
     extern short int g_keycodes[512];
-    void init_keycodes();
+    void init_keycodes(void);
     void keyboard_default(struct mfb_window *window, mfb_key key, mfb_key_mod mod, bool isPressed);
 
 #if defined(__cplusplus)

src/MiniFB_linux.c

@@ -1,3 +1,5 @@
+#if defined(__linux__)
+
 #include <time.h>
 #include <MiniFB.h>
 
@@ -30,3 +32,6 @@ mfb_timer_init() {
     }
     g_timer_resolution = 1.0 / g_timer_frequency;
 }
+
+#endif
+

src/MiniFB_timer.c

@@ -8,8 +8,8 @@ double      g_timer_resolution;
 double      g_time_for_frame = 1.0 / 60.0;
 
 //-------------------------------------
-extern uint64_t mfb_timer_tick();
+extern uint64_t mfb_timer_tick(void);
-extern void mfb_timer_init();
+extern void mfb_timer_init(void);
 
 //-------------------------------------
 void

src/macosx/MacMiniFB.m

@@ -310,11 +310,14 @@ mfb_update(struct mfb_window *window, void *buffer) {
 #endif
 
     update_events(window_data);
-    if(window_data->close == false) {
+    if(window_data->close) {
-        SWindowData_OSX *window_data_osx = (SWindowData_OSX *) window_data->specific;
+        destroy_window_data(window_data);
-        [[window_data_osx->window contentView] setNeedsDisplay:YES];
+        return STATE_EXIT;
     }
 
+    SWindowData_OSX *window_data_osx = (SWindowData_OSX *) window_data->specific;
+    [[window_data_osx->window contentView] setNeedsDisplay:YES];
+
     return STATE_OK;
 }
 
@@ -333,11 +336,14 @@ mfb_update_events(struct mfb_window *window) {
     }
 
     update_events(window_data);
-    if(window_data->close == false) {
+    if(window_data->close) {
-        SWindowData_OSX *window_data_osx = (SWindowData_OSX *) window_data->specific;
+        destroy_window_data(window_data);
-        [[window_data_osx->window contentView] setNeedsDisplay:YES];
+        return STATE_EXIT;
     }
 
+    SWindowData_OSX *window_data_osx = (SWindowData_OSX *) window_data->specific;
+    [[window_data_osx->window contentView] setNeedsDisplay:YES];
+
     return STATE_OK;
 }
 
@@ -362,6 +368,10 @@ mfb_wait_sync(struct mfb_window *window) {
     //NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
 
     SWindowData_OSX *window_data_osx = (SWindowData_OSX *) window_data->specific;
+    if(window_data_osx == 0x0) {
+        return false;
+    }
+
     double      current;
     uint32_t    millis = 1;
     while(1) {
@@ -397,6 +407,10 @@ mfb_wait_sync(struct mfb_window *window) {
 
 bool 
 mfb_set_viewport(struct mfb_window *window, unsigned offset_x, unsigned offset_y, unsigned width, unsigned height) {
+    if(window == 0x0) {
+        return false;
+    }
+
     SWindowData *window_data = (SWindowData *) window;
 
     if(offset_x + width > window_data->window_width) {

src/macosx/OSXWindow.m

@@ -72,6 +72,9 @@
 
 - (void)flagsChanged:(NSEvent *)event
 {
+    if(window_data == 0x0)
+        return;
+
     const uint32_t flags = [event modifierFlags];
     uint32_t	mod_keys = 0, mod_keys_aux = 0;
 
@@ -135,42 +138,48 @@
 
 - (void)keyDown:(NSEvent *)event
 {
-    short int key_code = g_keycodes[[event keyCode] & 0x1ff];
+    if(window_data != 0x0) {
-    window_data->key_status[key_code] = true;
+        short int key_code = g_keycodes[[event keyCode] & 0x1ff];
-    kCall(keyboard_func, key_code, window_data->mod_keys, true);
+        window_data->key_status[key_code] = true;
+        kCall(keyboard_func, key_code, window_data->mod_keys, true);
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 - (void)keyUp:(NSEvent *)event
 {
-    short int key_code = g_keycodes[[event keyCode] & 0x1ff];
+    if(window_data != 0x0) {
-    window_data->key_status[key_code] = false;
+        short int key_code = g_keycodes[[event keyCode] & 0x1ff];
-    kCall(keyboard_func, key_code, window_data->mod_keys, false);
+        window_data->key_status[key_code] = false;
+        kCall(keyboard_func, key_code, window_data->mod_keys, false);
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 - (void)insertText:(id)string replacementRange:(NSRange)replacementRange
 {
-    NSString    *characters;
-    NSUInteger  length;
-    
     kUnused(replacementRange);
 
-    if ([string isKindOfClass:[NSAttributedString class]])
+    if(window_data != 0x0) {
-        characters = [string string];
+        NSString    *characters;
-    else
+        NSUInteger  length;    
-        characters = (NSString*) string;
 
-    length = [characters length];
+        if ([string isKindOfClass:[NSAttributedString class]])
-    for (NSUInteger i = 0;  i < length;  i++)
+            characters = [string string];
-    {
+        else
-        const unichar code = [characters characterAtIndex:i];
+            characters = (NSString*) string;
-        if ((code & 0xff00) == 0xf700)
-            continue;
 
-        kCall(char_input_func, code);
+        length = [characters length];
+        for (NSUInteger i = 0;  i < length;  i++)
+        {
+            const unichar code = [characters characterAtIndex:i];
+            if ((code & 0xff00) == 0xf700)
+                continue;
+
+            kCall(char_input_func, code);
+        }
     }
 }
 
@@ -180,9 +189,11 @@
 {
     kUnused(notification);
 
-    if(window_data->is_active == true) {
+    if(window_data != 0x0) {
-        window_data->is_active = false;
+        if(window_data->is_active == true) {
-        kCall(active_func, false);
+            window_data->is_active = false;
+            kCall(active_func, false);
+        }
     }
 }
 
@@ -190,10 +201,10 @@
 
 - (void)setContentView:(NSView *)aView
 {
-    if ([childContentView isEqualTo:aView])
+    if ([childContentView isEqualTo:aView]) {
-    {
         return;
     }
+
     NSRect bounds = [self frame];
     bounds.origin = NSZeroPoint;
 
@@ -232,15 +243,19 @@
 - (void)windowDidBecomeKey:(NSNotification *)notification
 {
     kUnused(notification);
-    window_data->is_active = true;
+    if(window_data != 0x0) {
-    kCall(active_func, true);
+        window_data->is_active = true;
+        kCall(active_func, true);
+    }
 }
 
 - (void)windowDidResignKey:(NSNotification *)notification
 {
     kUnused(notification);
-    window_data->is_active = false;
+    if(window_data) {
-    kCall(active_func, false);
+        window_data->is_active = false;
+        kCall(active_func, false);
+    }
 }
 
 - (void)windowWillClose:(NSNotification *)notification {
@@ -277,19 +292,23 @@
 
 - (void)willClose
 {
-    window_data->close = true;
+    if(window_data != 0x0) {
+        window_data->close = true;
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 - (void)windowDidResize:(NSNotification *)notification {
     kUnused(notification);
-    CGSize size = [self contentRectForFrameRect:[self frame]].size;
+    if(window_data != 0x0) {
+        CGSize size = [self contentRectForFrameRect:[self frame]].size;
 
-    window_data->window_width  = size.width;
+        window_data->window_width  = size.width;
-    window_data->window_height = size.height;
+        window_data->window_height = size.height;
 
-    kCall(resize_func, size.width, size.height);
+        kCall(resize_func, size.width, size.height);
+    }
 }
 
 @end

src/macosx/OSXWindowFrameView.m

@@ -65,7 +65,7 @@ extern Vertex g_vertices[4];
         renderEncoder.label = @"minifb_command_encoder";
 
         // Set render command encoder state
-        OSXWindow     *window            = (OSXWindow *) view.window;
+        OSXWindow       *window          = (OSXWindow *) view.window;
         SWindowData_OSX *window_data_osx = (SWindowData_OSX *) window->window_data->specific;
         [renderEncoder setRenderPipelineState:window_data_osx->metal.pipeline_state];
 
@@ -136,7 +136,7 @@ extern Vertex g_vertices[4];
 {
 	(void)rect;
 
-    if(!window_data)
+    if(window_data == 0x0)
         return;
 
     SWindowData_OSX *window_data_osx = (SWindowData_OSX *) window_data->specific;    
@@ -181,7 +181,9 @@ extern Vertex g_vertices[4];
 - (void)mouseDown:(NSEvent*)event
 {
     (void)event;
-    kCall(mouse_btn_func, MOUSE_BTN_1, window_data->mod_keys, true);
+    if(window_data != 0x0) {
+        kCall(mouse_btn_func, MOUSE_BTN_1, window_data->mod_keys, true);
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -189,7 +191,9 @@ extern Vertex g_vertices[4];
 - (void)mouseUp:(NSEvent*)event
 {
     (void)event;
-    kCall(mouse_btn_func, MOUSE_BTN_1, window_data->mod_keys, false);
+    if(window_data != 0x0) {
+        kCall(mouse_btn_func, MOUSE_BTN_1, window_data->mod_keys, false);
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -197,7 +201,9 @@ extern Vertex g_vertices[4];
 - (void)rightMouseDown:(NSEvent*)event
 {
     (void)event;
-    kCall(mouse_btn_func, MOUSE_BTN_2, window_data->mod_keys, true);
+    if(window_data != 0x0) {
+        kCall(mouse_btn_func, MOUSE_BTN_2, window_data->mod_keys, true);
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -205,7 +211,9 @@ extern Vertex g_vertices[4];
 - (void)rightMouseUp:(NSEvent*)event
 {
     (void)event;
-    kCall(mouse_btn_func, MOUSE_BTN_1, window_data->mod_keys, false);
+    if(window_data != 0x0) {
+        kCall(mouse_btn_func, MOUSE_BTN_1, window_data->mod_keys, false);
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -213,7 +221,9 @@ extern Vertex g_vertices[4];
 - (void)otherMouseDown:(NSEvent *)event
 {
     (void)event;
-    kCall(mouse_btn_func, [event buttonNumber], window_data->mod_keys, true);
+    if(window_data != 0x0) {
+        kCall(mouse_btn_func, [event buttonNumber], window_data->mod_keys, true);
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -221,14 +231,18 @@ extern Vertex g_vertices[4];
 - (void)otherMouseUp:(NSEvent *)event
 {
     (void)event;
-    kCall(mouse_btn_func, [event buttonNumber], window_data->mod_keys, false);
+    if(window_data != 0x0) {
+        kCall(mouse_btn_func, [event buttonNumber], window_data->mod_keys, false);
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 - (void)scrollWheel:(NSEvent *)event
 {
-    kCall(mouse_wheel_func, window_data->mod_keys, [event deltaX], [event deltaY]);
+    if(window_data != 0x0) {
+        kCall(mouse_wheel_func, window_data->mod_keys, [event deltaX], [event deltaY]);
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -250,11 +264,13 @@ extern Vertex g_vertices[4];
 
 - (void)mouseMoved:(NSEvent *)event
 {
-    NSPoint point = [event locationInWindow];
+    if(window_data != 0x0) {
-    //NSPoint localPoint = [self convertPoint:point fromView:nil];
+        NSPoint point = [event locationInWindow];
-    window_data->mouse_pos_x = point.x;
+        //NSPoint localPoint = [self convertPoint:point fromView:nil];
-    window_data->mouse_pos_y = point.y;
+        window_data->mouse_pos_x = point.x;
-    kCall(mouse_move_func, point.x, point.y);
+        window_data->mouse_pos_y = point.y;
+        kCall(mouse_move_func, point.x, point.y);
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

tests/multiple_windows.c

@@ -107,6 +107,7 @@ main()
     mfb_set_mouse_scroll_callback(window_a, mouse_scroll);
 
     mfb_set_user_data(window_a, (void *) "Window A");
+    mfb_set_viewport(window_a, 25, 25, WIDTH_A-25, HEIGHT_A-25);
 
     //--
     struct mfb_window *window_b = mfb_open_ex("Secondary Window", WIDTH_B, HEIGHT_B, WF_RESIZABLE);
@@ -150,44 +151,48 @@ main()
         
         mfb_update_state state_a, state_b;
 
-        for (i = 0; i < WIDTH_A * HEIGHT_A; ++i)
+        if(window_a != 0x0) {
-        {
+            for (i = 0; i < WIDTH_A * HEIGHT_A; ++i)
-            noise = seed;
+            {
-            noise >>= 3;
+                noise = seed;
-            noise ^= seed;
+                noise >>= 3;
-            carry = noise & 1;
+                noise ^= seed;
-            noise >>= 1;
+                carry = noise & 1;
-            seed >>= 1;
+                noise >>= 1;
-            seed |= (carry << 30);
+                seed >>= 1;
-            noise &= 0xFF;
+                seed |= (carry << 30);
-            g_buffer_a[i] = MFB_RGB(noise, noise, noise); 
+                noise &= 0xFF;
-        }
+                g_buffer_a[i] = MFB_RGB(noise, noise, noise); 
+            }
 
-        //--
+            //--
-        time_x = sinf(time * kPI / 180.0f);
+            state_a = mfb_update(window_a, g_buffer_a);
-        time_y = cosf(time * kPI / 180.0f);
+            if (state_a != STATE_OK) {
-        i = 0;
+                window_a = 0x0;
-        for(y=0; y<HEIGHT_B; ++y) {
-            dy = cosf((y * time_y) * kPI / 180.0f);                // [-1, 1]
-            for(x=0; x<WIDTH_B; ++x) {
-                dx = sinf((x * time_x) * kPI / 180.0f);            // [-1, 1]
-
-                index = (int) ((2.0f + dx + dy) * 0.25f * 511.0f);  // [0, 511]
-                g_buffer_b[i++] = pallete[index];
             }
         }
-        time += 0.1f;
 
         //--
-        state_a = mfb_update(window_a, g_buffer_a);
+        if(window_b != 0x0) {
-        if (state_a != STATE_OK) {
+            time_x = sinf(time * kPI / 180.0f);
-            window_a = 0x0;
+            time_y = cosf(time * kPI / 180.0f);
-        }
+            i = 0;
+            for(y=0; y<HEIGHT_B; ++y) {
+                dy = cosf((y * time_y) * kPI / 180.0f);                // [-1, 1]
+                for(x=0; x<WIDTH_B; ++x) {
+                    dx = sinf((x * time_x) * kPI / 180.0f);            // [-1, 1]
 
-        //--
+                    index = (int) ((2.0f + dx + dy) * 0.25f * 511.0f);  // [0, 511]
-        state_b = mfb_update(window_b, g_buffer_b);
+                    g_buffer_b[i++] = pallete[index];
-        if (state_b != STATE_OK) {
+                }
-            window_b = 0x0;
+            }
+            time += 0.1f;
+
+            //--
+            state_b = mfb_update(window_b, g_buffer_b);
+            if (state_b != STATE_OK) {
+                window_b = 0x0;
+            }
         }
 
         if(window_a == 0x0 && window_b == 0x0) {
@@ -195,10 +200,16 @@ main()
         }
 
         // Don't need to do this for both windows in the same thread
-        if(window_a != 0x0)
+        if(window_a != 0x0) {
-            mfb_wait_sync(window_a);
+            if(mfb_wait_sync(window_a) == false) {
-        else if(window_b != 0x0)
+                window_a = 0x0;
-            mfb_wait_sync(window_b);
+            }
+        }
+        else if(window_b != 0x0) {
+            if(mfb_wait_sync(window_b) == false) {
+                window_b = 0x0;
+            }
+        }
     }
 
     return 0;