Force window to front/focus?

I'm writing an MacOSX bundled app in GLFW.

When the window pops up, I want it to be on top of all the other windows. I开发者_JAVA百科 also want it to grab focus (I'm coding in vim, and I type ":make run" -- and I after that, I want to interact with the app).

Question:

1) Is there some API call I can use to make this happen? 2) Is there some configuration I can do in MacOSX to say something like "the program named blah, have it steal focus on startup"?

Thanks!

The cocoa API is [NSWindow makeKeyAndOrderFront:] there's probably something similar you can do from your library.

If you wrap your built executable in a application bundle, then you should be able to open it in the terminal (e.g. via the open command) and the focus will automatically switch to it.

Note that you will probably need to package your application in a bundle anyway.

1. First, you need to package it because that is what the GLFW FAQ says.

2. I personally found this to be necessary because, at least in GLFW currently available on github (commit 3e78), atop Mac OS X 10.7.5, the keyboard handling is stolen by the terminal if you don't have the executable sitting in an app bundle.

I witnessed the keyboard-input-stealing behavior occurring even when I manually switched the mouse focus to the window that popped up when I ran the binary. That is, the keystrokes I typed still ended up in the terminal window.

You can test this behavior yourself on your own system by taking one of the example apps for GLFW, like Triangle.app, copy its binary to a different directory, like /tmp/, and then run the binary from there. Here is a demonstration of the distinction I am making.

% pwd
/Users/pnkfelix/Dev/OpenGL/glfw/objdir/examples/Triangle.app/Contents/MacOS
% ./Triangle

(The open command works too:)

% open ../../../Triangle.app

In the above scenarios, hitting ESC with the triangle window focused made it quit, as expected.

However, the problem comes when the program is not sitting in an bundle:

% cp ./Triangle /tmp
% /tmp/Triangle 
^[^[^[^[^[^[^

In this scenario, hitting ESC with the triangle window focused passed the keystroke to the terminal window that launched the program. (That is what the ^[ glyphs are -- the terminal responding to the ESC keystrokes it has received.)

The good news is, it is relatively easy to wrap a built executable in a bundle.

For example, when I was doing other experiments with binding the GLFW library, I found the following Makefile rule sufficed for constructing a makeshift bundle from an executable:

test: Triangle.app
        open Triangle.app

Triangle.app: Triangle.app/Contents/MacOS/Triangle

Triangle.app/Contents/MacOS/Triangle: triangle
        mkdir -p Triangle.app/Contents/MacOS
        cp $< $@

(note that the 8-space indented commands above should not be copied verbatim, but rather rewritten as tabs as required for Makefiles).

However, please note that the above Makefile rule is not the official structure for application bundles, and shouldn't be trusted for anything except personal experimentation. Apple has the documentation on how to officially package your application in a bundle, so you should take the time to do whatever steps they describe before you release anything you produce into the wild. (For example, the Makefile rules listed above make no attempt to generate an Info.plist file, which is one of the required components according to Apple's documentation.)