X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Fblackberry%2Ffg_window_blackberry.c;h=86668af1d865911a95ebaf44d3d24635acbb7355;hb=421588fbbc5a989c5722a0eae212917cb86e8f26;hp=d435dfba262cb2d8209fc12c32da071f69c52cf0;hpb=2d252401e5ed48358f8fb2d05be8169309d05eda;p=freeglut

diff --git a/src/blackberry/fg_window_blackberry.c b/src/blackberry/fg_window_blackberry.c
index d435dfb..86668af 100644
--- a/src/blackberry/fg_window_blackberry.c
+++ b/src/blackberry/fg_window_blackberry.c
@@ -31,8 +31,7 @@
 #include <GL/freeglut.h>
 #include "fg_internal.h"
 #include "egl/fg_window_egl.h"
-#include <screen/screen.h>
-#include <bps/screen.h>
+#include <sys/pps.h>
 
 /*
  * Opens a window. Requires a SFG_Window object created and attached
@@ -48,74 +47,160 @@ void fgPlatformOpenWindow( SFG_Window* window, const char* title,
         fgWarning("You can't have more than one window on BlackBerry");
         return;
     }
-    window->Window.pContext.event = NULL; //XXX Should probably be done elsewhere. Done here so there is no event at the moment
 
     /* Create window */
-    if (screen_create_context(&window->Window.pContext.screenContext, 0)) {
-        fgError("Could not create screen context");
-        return;
-    }
     screen_window_t sWindow;
-    if (screen_create_window(&sWindow, window->Window.pContext.screenContext)) {
-        screen_destroy_context(window->Window.pContext.screenContext);
+    if (screen_create_window(&sWindow, fgDisplay.pDisplay.screenContext)) {
         fgError("Could not create window");
         return;
     }
     fgDisplay.pDisplay.single_native_window = sWindow;
 
+    /* Choose config and screen format */
+    fghChooseConfig(&window->Window.pContext.egl.Config);
+    int screenFormat = SCREEN_FORMAT_RGBA8888; //Only SCREEN_FORMAT_RGBA8888 and SCREEN_FORMAT_RGB565 are supported. See fg_window_egl for more info
+    int configAttri;
+#define EGL_QUERY_COMP(att, comp) (eglGetConfigAttrib(fgDisplay.pDisplay.egl.Display, window->Window.pContext.egl.Config, att, &configAttri) == GL_TRUE && (configAttri comp))
+    if (EGL_QUERY_COMP(EGL_ALPHA_SIZE, <= 0) && EGL_QUERY_COMP(EGL_RED_SIZE, <= 5) &&
+            EGL_QUERY_COMP(EGL_GREEN_SIZE, <= 6) && EGL_QUERY_COMP(EGL_BLUE_SIZE, <= 5)) {
+        screenFormat = SCREEN_FORMAT_RGB565;
+    }
+#undef EGL_QUERY_COMP
+
     /* Set window properties */
-    int screenFormat = SCREEN_FORMAT_RGBA8888; //XXX Should this be determined by config?
-#ifdef GL_ES_VERSION_2_0
-    int screenUsage = SCREEN_USAGE_OPENGL_ES2;
-#elif GL_VERSION_ES_CM_1_0 || GL_VERSION_ES_CL_1_0 || GL_VERSION_ES_CM_1_1 || GL_VERSION_ES_CL_1_1
-    int screenUsage = SCREEN_USAGE_OPENGL_ES1;
+    int orientation = atoi(getenv("ORIENTATION"));
+    int screenUsage = SCREEN_USAGE_ROTATION;
+#ifdef SCREEN_USAGE_OPENGL_ES3
+    if (fgState.MajorVersion >= 3) {
+        screenUsage |= SCREEN_USAGE_OPENGL_ES3;
+    } else
 #endif
-#ifndef __X86__
+    if (fgState.MajorVersion >= 2) {
+        screenUsage |= SCREEN_USAGE_OPENGL_ES2;
+    } else {
+        screenUsage |= SCREEN_USAGE_OPENGL_ES1;
+    }
+#if !defined(__X86__) && !defined(__PLAYBOOK__)
     screenUsage |= SCREEN_USAGE_DISPLAY; // Physical device copy directly into physical display
 #endif
     if (screen_set_window_property_iv(sWindow, SCREEN_PROPERTY_FORMAT, &screenFormat)) {
         screen_destroy_window(sWindow);
-        screen_destroy_context(window->Window.pContext.screenContext);
         fgError("Could not set window format");
         return;
     }
     if (screen_set_window_property_iv(sWindow, SCREEN_PROPERTY_USAGE, &screenUsage)) {
         screen_destroy_window(sWindow);
-        screen_destroy_context(window->Window.pContext.screenContext);
         fgError("Could not set window usage");
         return;
     }
 
-    /* Could set size based on what is specified for window. Work on another time
-    int size[2];
-    size[0] = w;
-    size[1] = h;
-    if (screen_set_window_property_iv(sWindow, SCREEN_PROPERTY_BUFFER_SIZE, size)) {
+    int value[2];
+    /* Uncomment when multiple windows are supported
+    if(positionUse) {
+        value[0] = x;
+        value[1] = y;
+        if (screen_set_window_property_iv(sWindow, SCREEN_PROPERTY_POSITION, value)) {
+            screen_destroy_window(sWindow);
+            fgError("Could not set window position");
+            return;
+        }
+    }*/
+
+    if(sizeUse) {
+        /* Uncomment when multiple windows are supported
+        value[0] = w;
+        value[1] = h;
+        */
+        //TEMP until ^^ is uncommented
+        if (screen_get_window_property_iv(sWindow, SCREEN_PROPERTY_BUFFER_SIZE, value)) {
+            screen_destroy_window(sWindow);
+            fgError("Could not get window mode");
+            return;
+        }
+    } else {
+        /* From PlatformBlackBerry in GamePlay3d */
+        screen_display_t display;
+        if (screen_get_window_property_pv(sWindow, SCREEN_PROPERTY_DISPLAY, (void**)&display)) {
+            screen_destroy_window(sWindow);
+            fgError("Could not get window display");
+            return;
+        }
+
+        screen_display_mode_t displayMode;
+        if (screen_get_display_property_pv(display, SCREEN_PROPERTY_MODE, (void**)&displayMode)) {
+            screen_destroy_window(sWindow);
+            fgError("Could not get display mode");
+            return;
+        }
+
+        if (screen_get_window_property_iv(sWindow, SCREEN_PROPERTY_BUFFER_SIZE, value)) {
+            screen_destroy_window(sWindow);
+            fgError("Could not get window mode");
+            return;
+        }
+
+        /* Adjust buffer sizes based on rotation */
+        if ((orientation == 0) || (orientation == 180))
+        {
+            if (((displayMode.width > displayMode.height) && (value[0] < value[1])) ||
+                ((displayMode.width < displayMode.height) && (value[0] > value[1])))
+            {
+                int tmp = value[1];
+                value[1] = value[0];
+                value[0] = tmp;
+            }
+        }
+        else if ((orientation == 90) || (orientation == 270))
+        {
+            if (((displayMode.width > displayMode.height) && (value[0] > value[1])) ||
+                ((displayMode.width < displayMode.height) && (value[0] < value[1])))
+            {
+                int tmp = value[1];
+                value[1] = value[0];
+                value[0] = tmp;
+            }
+        }
+        else
+        {
+            screen_destroy_window(sWindow);
+            fgError("Unexpected rotation angle");
+            return;
+        }
+    }
+
+    /* Set rotation if usage allows it */
+    if (screen_set_window_property_iv(sWindow, SCREEN_PROPERTY_ROTATION, &orientation)) {
+        screen_destroy_window(sWindow);
+        fgError("Could not set window rotation");
+        return;
+    }
+    window->State.pWState.originalRotation = orientation;
+
+    /* Set buffer sizes */
+    if (screen_set_window_property_iv(sWindow, SCREEN_PROPERTY_BUFFER_SIZE, value)) {
         screen_destroy_window(sWindow);
-        screen_destroy_context(window->Window.pContext.screenContext);
         fgError("Could not set window buffer size");
         return;
-    }*/
+    }
 
     /* Create window buffers */
     if (screen_create_window_buffers(sWindow, (fgState.DisplayMode & GLUT_DOUBLE) ? 2 : 1)) {
         screen_destroy_window(sWindow);
-        screen_destroy_context(window->Window.pContext.screenContext);
         fgError("Could not create window buffers");
         return;
     }
 
-    /* Request window events */
-    screen_request_events(window->Window.pContext.screenContext);
-
     /* Save window and set state */
-    window->Window.Handle = fgDisplay.pDisplay.single_native_window;
+    window->Window.Handle = sWindow;
     window->State.WorkMask |= GLUT_INIT_WORK;
     window->State.IsFullscreen = GL_TRUE; //XXX Always fullscreen for now
 
     /* Create context */
-    fghChooseConfig(&window->Window.pContext.egl.Config);
-    window->Window.Context = fghCreateNewContextEGL(window);
+    window->Window.Context = EGL_NO_CONTEXT;
+    if( fgState.UseCurrentContext == GL_TRUE )
+        window->Window.Context = eglGetCurrentContext();
+    if( window->Window.Context == EGL_NO_CONTEXT )
+        window->Window.Context = fghCreateNewContextEGL(window);
 
     /* Create EGL window */
     fghPlatformOpenWindowEGL(window);
@@ -123,6 +208,20 @@ void fgPlatformOpenWindow( SFG_Window* window, const char* title,
     window->State.Visible = GL_TRUE;
 }
 
+void fgPlatformFlushCommands()
+{
+    if(screen_flush_context(fgDisplay.pDisplay.screenContext, 0)) {
+        fgWarning("Could not flush screen context");
+    }
+}
+
+void fgPlatformRotateWindow(SFG_Window* window, int rotation)
+{
+    if(screen_set_window_property_iv(window->Window.Handle, SCREEN_PROPERTY_ROTATION, &rotation)) {
+        fgWarning("Could not set window rotation");
+    }
+}
+
 /*
  * Request a window resize
  */
@@ -138,11 +237,7 @@ void fgPlatformCloseWindow( SFG_Window* window )
 {
     fghPlatformCloseWindowEGL(window);
 
-    screen_stop_events(window->Window.pContext.screenContext);
-
     screen_destroy_window((screen_window_t)window->Window.Handle);
-
-    screen_destroy_context(window->Window.pContext.screenContext);
 }
 
 /*
@@ -166,8 +261,20 @@ void fgPlatformHideWindow( SFG_Window *window )
  */
 void fgPlatformIconifyWindow( SFG_Window *window )
 {
-    //XXX This is possible via Cascades, but can't seem to find a C-level API
+#ifndef __PLAYBOOK__
+    pps_encoder_t encoder;
+
+    pps_encoder_initialize(&encoder, false);
+    pps_encoder_add_string(&encoder, "msg", "minimizeWindow");
+
+    if (navigator_raw_write(pps_encoder_buffer(&encoder), pps_encoder_length(&encoder)) != BPS_SUCCESS) {
+        fgWarning("Could not iconify window on BlackBerry");
+    }
+
+    pps_encoder_cleanup(&encoder);
+#else
     fprintf(stderr, "fgPlatformGlutIconifyWindow: STUB\n");
+#endif
 }
 
 /*
@@ -183,6 +290,7 @@ void fgPlatformGlutSetWindowTitle( const char* title )
  */
 void fgPlatformGlutSetIconTitle( const char* title )
 {
+    //XXX Possibly a window cover label?
     fprintf(stderr, "fgPlatformGlutSetIconTitle: STUB\n");
 }