cl_gecko.c

   1 /* --- 8< --- 8< ---   OffscreenGecko headers   --- >8 --- >8 --- */
   2 /* NOTE: Documentation comments have been omitted. Documentation is
   3    available in the OffscreenGecko SDK download. */
   4
   5 /* OffscreenGecko/defs.h */
   6
   7 #define OSGK_CLASSTYPE_DEF      struct
   8 #define OSGK_CLASSTYPE_REF      struct
   9
  10 #include <assert.h>
  11 #include <stdlib.h>
  12 #define OSGK_ASSERT(x)  assert(x)
  13
  14 typedef unsigned int OSGK_GeckoResult;
  15
  16 #if defined(__cplusplus) || defined(__GNUC__)
  17 #  define OSGK_INLINE   inline
  18 #elif defined(_MSC_VER)
  19 #  define OSGK_INLINE   __inline
  20 #else
  21 #  define OSGK_INLINE
  22 #endif
  23
  24 /* OffscreenGecko/baseobj.h */
  25
  26 struct OSGK_BaseObject_s
  27 {
  28   int reserved;
  29 };
  30 typedef struct OSGK_BaseObject_s OSGK_BaseObject;
  31
  32 #define OSGK_DERIVEDTYPE(T)           \
  33   typedef struct T ## _s {            \
  34     OSGK_BaseObject baseobj;          \
  35   } T
  36
  37 static int (*osgk_addref) (OSGK_BaseObject* obj);
  38 static int (*osgk_release) (OSGK_BaseObject* obj);
  39
  40 static OSGK_INLINE int osgk_addref_real (OSGK_BaseObject* obj)
  41 {
  42   return osgk_addref (obj);
  43 }
  44
  45 static OSGK_INLINE int osgk_release_real (OSGK_BaseObject* obj)
  46 {
  47   return osgk_release (obj);
  48 }
  49
  50 #define osgk_addref(obj)    osgk_addref_real (&((obj)->baseobj))
  51 #define osgk_release(obj)   osgk_release_real (&((obj)->baseobj))
  52
  53 /* OffscreenGecko/embedding.h */
  54
  55 OSGK_DERIVEDTYPE(OSGK_EmbeddingOptions);
  56
  57 static OSGK_EmbeddingOptions* (*osgk_embedding_options_create) (void);
  58 static void (*osgk_embedding_options_add_search_path) (
  59   OSGK_EmbeddingOptions* options, const char* path);
  60 /*static void (*osgk_embedding_options_add_components_path) (
  61   OSGK_EmbeddingOptions* options, const char* path);*/
  62 static void (*osgk_embedding_options_set_profile_dir) (
  63   OSGK_EmbeddingOptions* options, const char* profileDir,
  64   const char* localProfileDir);
  65
  66 OSGK_DERIVEDTYPE(OSGK_Embedding);
  67
  68 #define OSGK_API_VERSION    1
  69
  70 static OSGK_Embedding* (*osgk_embedding_create2) (
  71   unsigned int apiVer, OSGK_EmbeddingOptions* options,
  72   OSGK_GeckoResult* geckoResult);
  73
  74 static OSGK_INLINE OSGK_Embedding* osgk_embedding_create (
  75   OSGK_GeckoResult* geckoResult)
  76 {
  77   return osgk_embedding_create2 (OSGK_API_VERSION, 0, geckoResult);
  78 }
  79
  80 static OSGK_INLINE OSGK_Embedding* osgk_embedding_create_with_options (
  81   OSGK_EmbeddingOptions* options, OSGK_GeckoResult* geckoResult)
  82 {
  83   return osgk_embedding_create2 (OSGK_API_VERSION, options, geckoResult);
  84 }
  85
  86 /*static OSGK_GeckoMem* (*osgk_embedding_get_gecko_mem) (
  87   OSGK_Embedding* embedding);*/
  88
  89 /*static OSGK_ComponentMgr* (*osgk_embedding_get_component_mgr) (
  90   OSGK_Embedding* embedding);*/
  91
  92 /*OSGK_CLASSTYPE_DEF nsIComponentManager;
  93 OSGK_CLASSTYPE_DEF nsIComponentRegistrar;
  94 OSGK_CLASSTYPE_DEF nsIServiceManager;*/
  95
  96 /*static OSGK_CLASSTYPE_REF nsIComponentManager*
  97 (*osgk_embedding_get_gecko_component_manager) (OSGK_Embedding* embedding);*/
  98 /*static OSGK_CLASSTYPE_REF nsIComponentRegistrar*
  99 (*osgk_embedding_get_gecko_component_registrar) (OSGK_Embedding* embedding);*/
 100 /*static OSGK_CLASSTYPE_REF nsIServiceManager*
 101 (*osgk_embedding_get_gecko_service_manager) (OSGK_Embedding* embedding);*/
 102
 103 enum
 104 {
 105   jsgPrivileged = 1
 106 };
 107 /*static int (*osgk_embedding_register_js_global) (
 108   OSGK_Embedding* embedding, const char* name, const char* contractID,
 109   unsigned int flags, OSGK_String** previousContract,
 110   OSGK_GeckoResult* geckoResult);*/
 111
 112 /*static void (*osgk_embedding_clear_focus*) (OSGK_Embedding* embedding);*/
 113 /*void (*osgk_embedding_set_auto_focus) (OSGK_Embedding* embedding, int autoFocus);*/
 114 /*static int (*osgk_embedding_get_auto_focus) (OSGK_Embedding* embedding);*/
 115
 116 /* OffscreenGecko/browser.h */
 117 OSGK_DERIVEDTYPE(OSGK_Browser);
 118
 119 static OSGK_Browser* (*osgk_browser_create) (
 120   OSGK_Embedding* embedding, int width, int height);
 121 static void (*osgk_browser_navigate) (OSGK_Browser* browser,
 122   const char* uri);
 123
 124 static int (*osgk_browser_query_dirty) (OSGK_Browser* browser);
 125 static const unsigned char* (*osgk_browser_lock_data) (
 126   OSGK_Browser* browser, int* isDirty);
 127 static void (*osgk_browser_unlock_data) (OSGK_Browser* browser,
 128   const unsigned char* data);
 129
 130 typedef enum OSGK_MouseButton
 131 {
 132   mbLeft,
 133   mbRight,
 134   mbMiddle
 135 } OSGK_MouseButton;
 136
 137 typedef enum OSGK_MouseButtonEventType
 138 {
 139   meDown,
 140   meUp,
 141   meDoubleClick
 142 } OSGK_MouseButtonEventType;
 143
 144 static void (*osgk_browser_event_mouse_move) (
 145   OSGK_Browser* browser, int x, int y);
 146 static void (*osgk_browser_event_mouse_button) (
 147   OSGK_Browser* browser, OSGK_MouseButton button,
 148   OSGK_MouseButtonEventType eventType);
 149
 150 typedef enum OSGK_WheelAxis
 151 {
 152   waVertical,
 153   waHorizontal
 154 } OSGK_WheelAxis;
 155
 156 typedef enum OSGK_WheelDirection
 157 {
 158   wdPositive,
 159   wdNegative,
 160   wdPositivePage,
 161   wdNegativePage
 162 } OSGK_WheelDirection;
 163
 164 static void (*osgk_browser_event_mouse_wheel) (
 165   OSGK_Browser* browser, OSGK_WheelAxis axis,
 166   OSGK_WheelDirection direction);
 167
 168 typedef enum OSGK_KeyboardEventType
 169 {
 170   keDown,
 171   keUp,
 172   kePress
 173 } OSGK_KeyboardEventType;
 174
 175 enum
 176 {
 177   OSGKKey_First = 0x110000,
 178
 179   OSGKKey_Backspace = OSGKKey_First,
 180   OSGKKey_Tab,
 181   OSGKKey_Return,
 182   OSGKKey_Shift,
 183   OSGKKey_Control,
 184   OSGKKey_Alt,
 185   OSGKKey_CapsLock,
 186   OSGKKey_Escape,
 187   OSGKKey_Space,
 188   OSGKKey_PageUp,
 189   OSGKKey_PageDown,
 190   OSGKKey_End,
 191   OSGKKey_Home,
 192   OSGKKey_Left,
 193   OSGKKey_Up,
 194   OSGKKey_Right,
 195   OSGKKey_Down,
 196   OSGKKey_Insert,
 197   OSGKKey_Delete,
 198   OSGKKey_F1,
 199   OSGKKey_F2,
 200   OSGKKey_F3,
 201   OSGKKey_F4,
 202   OSGKKey_F5,
 203   OSGKKey_F6,
 204   OSGKKey_F7,
 205   OSGKKey_F8,
 206   OSGKKey_F9,
 207   OSGKKey_F10,
 208   OSGKKey_F11,
 209   OSGKKey_F12,
 210   OSGKKey_NumLock,
 211   OSGKKey_ScrollLock,
 212   OSGKKey_Meta
 213 };
 214
 215 static int (*osgk_browser_event_key) (
 216   OSGK_Browser* browser, unsigned int key,
 217   OSGK_KeyboardEventType eventType);
 218
 219 typedef enum OSGK_AntiAliasType
 220 {
 221   aaNone,
 222   aaGray,
 223   aaSubpixel
 224 } OSGK_AntiAliasType;
 225
 226 /*static void (*osgk_browser_set_antialias) (
 227   OSGK_Browser* browser, OSGK_AntiAliasType aaType);*/
 228 /*static OSGK_AntiAliasType (*osgk_browser_get_antialias) (OSGK_Browser* browser);*/
 229
 230 /*static void (*osgk_browser_focus) (OSGK_Browser* browser);*/
 231
 232 static void (*osgk_browser_resize) (OSGK_Browser* browser,
 233   int width, int height);
 234
 235 /*static int (*osgk_browser_set_user_data) (OSGK_Browser* browser,
 236   unsigned int key, void* data, int overrideData);*/
 237 /*static int (*osgk_browser_get_user_data) (OSGK_Browser* browser,
 238   unsigned int key, void** data);*/
 239
 240 /* OffscreenGecko/string.h */
 241 OSGK_DERIVEDTYPE(OSGK_String);
 242
 243 /*static const char* (*osgk_string_get) (OSGK_String* str);*/
 244
 245 /*static OSGK_String* (*osgk_string_create) (const char* str);*/
 246
 247 /* OffscreenGecko/scriptvariant.h */
 248
 249 OSGK_CLASSTYPE_DEF nsISupports;
 250
 251 OSGK_DERIVEDTYPE(OSGK_ScriptVariant);
 252
 253 typedef enum OSGK_ScriptVariantType
 254 {
 255   svtEmpty,
 256   svtInt,
 257   svtUint,
 258   svtFloat,
 259   svtDouble,
 260   svtBool,
 261   svtChar,
 262   svtString,
 263   svtISupports,
 264   svtScriptObject,
 265   svtArray
 266 } OSGK_ScriptVariantType;
 267
 268 /*static OSGK_ScriptVariantType (*osgk_variant_get_type) (
 269   OSGK_ScriptVariant* variant);*/
 270 /*static OSGK_ScriptVariant* (*osgk_variant_convert) (
 271   OSGK_ScriptVariant* variant, OSGK_ScriptVariantType newType);*/
 272
 273 /*static int (*osgk_variant_get_int) (OSGK_ScriptVariant* variant,
 274   int* val);*/
 275 /*static int (*osgk_variant_get_uint) (OSGK_ScriptVariant* variant,
 276   unsigned int* val);*/
 277 /*static int (*osgk_variant_get_float) (OSGK_ScriptVariant* variant,
 278   float* val);*/
 279 /*static int (*osgk_variant_get_double) (OSGK_ScriptVariant* variant,
 280   double* val);*/
 281 /*static int (*osgk_variant_get_bool) (OSGK_ScriptVariant* variant,
 282   int* val);*/
 283 /*static int (*osgk_variant_get_char) (OSGK_ScriptVariant* variant,
 284   unsigned int* val);*/
 285 /*// Does not increase ref count
 286 static int (*osgk_variant_get_string) (OSGK_ScriptVariant* variant,
 287   OSGK_String** val);*/
 288 /*// Does not increase ref count
 289 static int (*osgk_variant_get_isupports) (OSGK_ScriptVariant* variant,
 290   OSGK_CLASSTYPE_REF nsISupports** val);*/
 291 /*static int (*osgk_variant_get_script_object) (OSGK_ScriptVariant* variant,
 292   void** tag);*/
 293 /*static int (*osgk_variant_get_array_size) (OSGK_ScriptVariant* variant,
 294   size_t* size);*/
 295 /*static int (*osgk_variant_get_array_item) (OSGK_ScriptVariant* variant,
 296   OSGK_ScriptVariant** val);*/
 297
 298 /*static OSGK_ScriptVariant* (*osgk_variant_create_empty) (
 299   OSGK_Embedding* embedding);*/
 300 /*static OSGK_ScriptVariant* (*osgk_variant_create_int) (
 301   OSGK_Embedding* embedding, int val);*/
 302 /*static OSGK_ScriptVariant* (*osgk_variant_create_uint) (
 303   OSGK_Embedding* embedding, unsigned int val);*/
 304 /*static OSGK_ScriptVariant* (*osgk_variant_create_float) (
 305   OSGK_Embedding* embedding, float val);*/
 306 /*static OSGK_ScriptVariant* (*osgk_variant_create_double) (
 307   OSGK_Embedding* embedding, double val);*/
 308 /*OSGK_ScriptVariant* (*osgk_variant_create_bool) (
 309   OSGK_Embedding* embedding, int val);*/
 310 /*static OSGK_ScriptVariant* (*osgk_variant_create_char) (
 311   OSGK_Embedding* embedding, unsigned int val);*/
 312 /*static OSGK_ScriptVariant* (*osgk_variant_create_string) (
 313   OSGK_Embedding* embedding, OSGK_String* val);*/
 314 /*static OSGK_ScriptVariant* (*osgk_variant_create_isupports) (
 315   OSGK_Embedding* embedding, OSGK_CLASSTYPE_REF nsISupports* val);*/
 316 /*static OSGK_ScriptVariant* (*osgk_variant_create_script_object) (
 317   OSGK_Embedding* embedding, void* tag);*/
 318 /*static OSGK_ScriptVariant* (*osgk_variant_create_array) (
 319   OSGK_Embedding* embedding, size_t numItems, OSGK_ScriptVariant** items);*/
 320
 321 /* OffscreenGecko/scriptobjecttemplate.h */
 322
 323 OSGK_DERIVEDTYPE(OSGK_ScriptObjectTemplate);
 324
 325 typedef enum OSGK_ScriptResult
 326 {
 327   srSuccess = 0,
 328   srFailed = 0x80004005L /* actually NS_ERROR_FAILURE */
 329 } OSGK_ScriptResult;
 330
 331 typedef struct OSGK_ScriptObjectCreateParams_s
 332 {
 333   void* createParam;
 334   OSGK_Browser* browser;
 335 } OSGK_ScriptObjectCreateParams;
 336
 337 typedef OSGK_ScriptResult (*OSGK_CreateObjFunc) (
 338   OSGK_ScriptObjectCreateParams* params, void** objTag);
 339 typedef void (*OSGK_DestroyObjFunc) (void* objTag);
 340
 341 /*static OSGK_ScriptObjectTemplate* (*osgk_sot_create) (
 342   OSGK_Embedding* embedding,
 343   OSGK_CreateObjFunc createFunc, OSGK_DestroyObjFunc destroyFunc,
 344   void* createParam);*/
 345
 346 typedef OSGK_ScriptVariant* (*OSGK_GetPropertyFunc) (void* objTag,
 347   void* propTag);
 348 typedef OSGK_ScriptResult (*OSGK_SetPropertyFunc) (void* objTag,
 349   void* propTag, OSGK_ScriptVariant* val);
 350
 351 /*static int (*osgk_sot_add_property) (
 352   OSGK_ScriptObjectTemplate* templ, const char* propName, void* propTag,
 353   OSGK_GetPropertyFunc getter, OSGK_SetPropertyFunc setter);*/
 354
 355 typedef OSGK_ScriptResult (*OSGK_FunctionCallFunc) (void* objTag,
 356   void* methTag, size_t numParams, OSGK_ScriptVariant** params,
 357   OSGK_ScriptVariant** returnVal);
 358
 359 /*static int (*osgk_sot_add_function) (
 360   OSGK_ScriptObjectTemplate* templ, const char* funcName, void* funcTag,
 361   OSGK_FunctionCallFunc callFunc);*/
 362
 363 /*static OSGK_ScriptVariant* (*osgk_sot_instantiate) (
 364   OSGK_ScriptObjectTemplate* templ, void** objTag);    */
 365
 366 /*static int (*osgk_sot_register) (
 367   OSGK_ScriptObjectTemplate* templ, OSGK_Embedding* embedding,
 368   const char* name, unsigned int flags);*/
 369
 370 /* --- >8 --- >8 --- End OffscreenGecko headers --- 8< --- 8< --- */
 371
 372 #include "quakedef.h"
 373 #include "cl_dyntexture.h"
 374 #include "cl_gecko.h"
 375 #include "timing.h"
 376
 377 #define DEFAULT_GECKO_SIZE        512
 378
 379 static rtexturepool_t *cl_geckotexturepool;
 380 static OSGK_Embedding *cl_geckoembedding;
 381
 382 struct clgecko_s {
 383         qboolean active;
 384         char name[ MAX_QPATH + 32 ];
 385
 386         OSGK_Browser *browser;
 387         int width, height;
 388         int texWidth, texHeight;
 389
 390         rtexture_t *texture;
 391 };
 392
 393 static clgecko_t cl_geckoinstances[ MAX_GECKO_INSTANCES ];
 394
 395 static dllhandle_t osgk_dll = NULL;
 396
 397 static clgecko_t * cl_gecko_findunusedinstance( void ) {
 398         int i;
 399         for( i = 0 ; i < MAX_GECKO_INSTANCES ; i++ ) {
 400                 clgecko_t *instance = &cl_geckoinstances[ i ];
 401                 if( !instance->active ) {
 402                         return instance;
 403                 }
 404         }
 405         if( developer.integer > 0 ) {
 406                 Con_Printf( "cl_gecko_findunusedinstance: out of geckos\n" );
 407         }
 408         return NULL;
 409 }
 410
 411 clgecko_t * CL_Gecko_FindBrowser( const char *name ) {
 412         int i;
 413
 414         if( !name || !*name || strncmp( name, CLGECKOPREFIX, sizeof( CLGECKOPREFIX ) - 1 ) != 0 ) {
 415                 if( developer.integer > 0 ) {
 416                         Con_Printf( "CL_Gecko_FindBrowser: Bad gecko texture name '%s'!\n", name );
 417                 }
 418                 return NULL;
 419         }
 420
 421         for( i = 0 ; i < MAX_GECKO_INSTANCES ; i++ ) {
 422                 clgecko_t *instance = &cl_geckoinstances[ i ];
 423                 if( instance->active && strcmp( instance->name, name ) == 0 ) {
 424                         return instance;
 425                 }
 426         }
 427
 428         if( developer.integer > 0 ) {
 429                 Con_Printf( "CL_Gecko_FindBrowser: No browser named '%s'!\n", name );
 430         }
 431
 432         return NULL;
 433 }
 434
 435 static void cl_gecko_updatecallback( rtexture_t *texture, void* callbackData ) {
 436         clgecko_t *instance = callbackData;
 437         const unsigned char *data;
 438         if( instance->browser ) {
 439                 // TODO: OSGK only supports BGRA right now
 440                 TIMING_TIMESTATEMENT(data = osgk_browser_lock_data( instance->browser, NULL ));
 441                 R_UpdateTexture( texture, data, 0, 0, instance->width, instance->height );
 442                 osgk_browser_unlock_data( instance->browser, data );
 443         }
 444 }
 445
 446 static void cl_gecko_linktexture( clgecko_t *instance ) {
 447         // TODO: assert that instance->texture == NULL
 448         instance->texture = R_LoadTexture2D( cl_geckotexturepool, instance->name,
 449                 instance->texWidth, instance->texHeight, NULL, TEXTYPE_BGRA, TEXF_ALPHA | TEXF_PERSISTENT, NULL );
 450         R_MakeTextureDynamic( instance->texture, cl_gecko_updatecallback, instance );
 451         CL_LinkDynTexture( instance->name, instance->texture );
 452 }
 453
 454 static void cl_gecko_unlinktexture( clgecko_t *instance ) {
 455         if( instance->texture ) {
 456                 CL_UnlinkDynTexture( instance->name );
 457                 R_FreeTexture( instance->texture );
 458                 instance->texture = NULL;
 459         }
 460 }
 461
 462 void CL_Gecko_Resize( clgecko_t *instance, int width, int height ) {
 463         int newWidth, newHeight;
 464
 465         // early out if bad parameters are passed (no resize to a texture size bigger than the original texture size)
 466         if( !instance || !instance->browser) {
 467                 return;
 468         }
 469
 470         newWidth = CeilPowerOf2( width );
 471         newHeight = CeilPowerOf2( height );
 472         if ((newWidth != instance->texWidth) || (newHeight != instance->texHeight))
 473         {
 474                 cl_gecko_unlinktexture( instance );
 475                 instance->texWidth = newWidth;
 476                 instance->texHeight = newHeight;
 477                 cl_gecko_linktexture( instance );
 478         }
 479         else
 480         {
 481                 /* The gecko area will only cover a part of the texture; to avoid
 482                 'old' pixels bleeding in at the border clear the texture. */
 483                 R_ClearTexture( instance->texture );
 484         }
 485
 486         osgk_browser_resize( instance->browser, width, height);
 487         instance->width = width;
 488         instance->height = height;
 489 }
 490
 491 void CL_Gecko_GetTextureExtent( clgecko_t *instance, float* pwidth, float* pheight )
 492 {
 493         if( !instance || !instance->browser ) {
 494                 return;
 495         }
 496
 497         *pwidth = (float)instance->width / instance->texWidth;
 498         *pheight = (float)instance->height / instance->texHeight;
 499 }
 500
 501 #if defined(WIN64)
 502 # define XULRUNNER_DIR_SUFFIX   "win64"
 503 #elif defined(WIN32)
 504 # define XULRUNNER_DIR_SUFFIX   "win32"
 505 #elif defined(DP_OS_STR) && defined(DP_ARCH_STR)
 506 # define XULRUNNER_DIR_SUFFIX   DP_OS_STR "-" DP_ARCH_STR
 507 #endif
 508
 509 clgecko_t * CL_Gecko_CreateBrowser( const char *name ) {
 510         clgecko_t *instance;
 511
 512         if (!osgk_dll) return NULL;
 513
 514         // TODO: verify that we dont use a name twice
 515         instance = cl_gecko_findunusedinstance();
 516         // TODO: assert != NULL
 517
 518         if( cl_geckoembedding == NULL ) {
 519                 char profile_path [MAX_OSPATH];
 520                 OSGK_GeckoResult grc;
 521                 OSGK_EmbeddingOptions *options;
 522
 523                 if( developer.integer > 0 ) {
 524                         Con_Printf( "CL_Gecko_CreateBrowser: setting up gecko embedding\n" );
 525                 }
 526
 527                 options = osgk_embedding_options_create();
 528         #ifdef XULRUNNER_DIR_SUFFIX
 529                 osgk_embedding_options_add_search_path( options, "./xulrunner-" XULRUNNER_DIR_SUFFIX "/" );
 530         #endif
 531                 osgk_embedding_options_add_search_path( options, "./xulrunner/" );
 532                 dpsnprintf (profile_path, sizeof (profile_path), "%s/xulrunner_profile/", fs_gamedir);
 533                 osgk_embedding_options_set_profile_dir( options, profile_path, 0 );
 534                 cl_geckoembedding = osgk_embedding_create_with_options( options, &grc );
 535                 osgk_release( options );
 536
 537                 if( cl_geckoembedding == NULL ) {
 538                         Con_Printf( "CL_Gecko_CreateBrowser: Couldn't retrieve gecko embedding object (%.8x)!\n", grc );
 539                         return NULL;
 540                 } else if( developer.integer > 0 ) {
 541                         Con_Printf( "CL_Gecko_CreateBrowser: Embedding set up correctly\n" );
 542                 }
 543         }
 544
 545         instance->active = true;
 546         strlcpy( instance->name, name, sizeof( instance->name ) );
 547         instance->browser = osgk_browser_create( cl_geckoembedding, DEFAULT_GECKO_SIZE, DEFAULT_GECKO_SIZE );
 548         if( instance->browser == NULL ) {
 549                 Con_Printf( "CL_Gecko_CreateBrowser: Browser object creation failed!\n" );
 550         }
 551         // TODO: assert != NULL
 552
 553         instance->width = instance->texWidth = DEFAULT_GECKO_SIZE;
 554         instance->height = instance->texHeight = DEFAULT_GECKO_SIZE;
 555         cl_gecko_linktexture( instance );
 556
 557         return instance;
 558 }
 559
 560 void CL_Gecko_DestroyBrowser( clgecko_t *instance ) {
 561    if( !instance || !instance->active ) {
 562                 return;
 563         }
 564
 565         instance->active = false;
 566         cl_gecko_unlinktexture( instance );
 567
 568         osgk_release( instance->browser );
 569         instance->browser = NULL;
 570 }
 571
 572 void CL_Gecko_Frame( void ) {
 573         int i;
 574         // FIXME: track cl_numgeckoinstances to avoid scanning the entire array?
 575         for( i = 0 ; i < MAX_GECKO_INSTANCES ; i++ ) {
 576                 clgecko_t *instance = &cl_geckoinstances[ i ];
 577                 if( instance->active ) {
 578                         if( instance->browser && osgk_browser_query_dirty( instance->browser ) == 1 ) {
 579                                 R_MarkDirtyTexture( instance->texture );
 580                         }
 581                 }
 582         }
 583 }
 584
 585 static void cl_gecko_start( void )
 586 {
 587         int i;
 588         cl_geckotexturepool = R_AllocTexturePool();
 589
 590         // recreate textures on module start
 591         for( i = 0 ; i < MAX_GECKO_INSTANCES ; i++ ) {
 592                 clgecko_t *instance = &cl_geckoinstances[ i ];
 593                 if( instance->active ) {
 594                         cl_gecko_linktexture( instance );
 595                 }
 596         }
 597 }
 598
 599 static void cl_gecko_shutdown( void )
 600 {
 601         int i;
 602         for( i = 0 ; i < MAX_GECKO_INSTANCES ; i++ ) {
 603                 clgecko_t *instance = &cl_geckoinstances[ i ];
 604                 if( instance->active ) {
 605                         cl_gecko_unlinktexture( instance );
 606                 }
 607         }
 608         R_FreeTexturePool( &cl_geckotexturepool );
 609 }
 610
 611 static void cl_gecko_newmap( void )
 612 {
 613         // DO NOTHING
 614 }
 615
 616 void CL_Gecko_Shutdown( void ) {
 617         int i;
 618         for( i = 0 ; i < MAX_GECKO_INSTANCES ; i++ ) {
 619                 clgecko_t *instance = &cl_geckoinstances[ i ];
 620                 if( instance->active ) {
 621                         cl_gecko_unlinktexture( instance );
 622                 }
 623         }
 624
 625         if (cl_geckoembedding != NULL)
 626         {
 627             osgk_release( cl_geckoembedding );
 628             cl_geckoembedding = NULL;
 629         }
 630
 631         if (osgk_dll != NULL)
 632         {
 633             Sys_UnloadLibrary (&osgk_dll);
 634         }
 635 }
 636
 637 static void cl_gecko_create_f( void ) {
 638         char name[MAX_QPATH];
 639
 640         if (Cmd_Argc() != 2)
 641         {
 642                 Con_Print("usage: gecko_create <name>\npcreates a browser (full texture path " CLGECKOPREFIX "<name>)\n");
 643                 return;
 644         }
 645
 646         // TODO: use snprintf instead
 647         sprintf(name, CLGECKOPREFIX "%s", Cmd_Argv(1));
 648         CL_Gecko_CreateBrowser( name );
 649 }
 650
 651 static void cl_gecko_destroy_f( void ) {
 652         char name[MAX_QPATH];
 653
 654         if (Cmd_Argc() != 2)
 655         {
 656                 Con_Print("usage: gecko_destroy <name>\ndestroys a browser\n");
 657                 return;
 658         }
 659
 660         // TODO: use snprintf instead
 661         sprintf(name, CLGECKOPREFIX "%s", Cmd_Argv(1));
 662         CL_Gecko_DestroyBrowser( CL_Gecko_FindBrowser( name ) );
 663 }
 664
 665 static void cl_gecko_navigate_f( void ) {
 666         char name[MAX_QPATH];
 667         const char *URI;
 668
 669         if (Cmd_Argc() != 3)
 670         {
 671                 Con_Print("usage: gecko_navigate <name> <URI>\nnavigates to a certain URI\n");
 672                 return;
 673         }
 674
 675         // TODO: use snprintf instead
 676         sprintf(name, CLGECKOPREFIX "%s", Cmd_Argv(1));
 677         URI = Cmd_Argv( 2 );
 678         CL_Gecko_NavigateToURI( CL_Gecko_FindBrowser( name ), URI );
 679 }
 680
 681 static void cl_gecko_injecttext_f( void ) {
 682         char name[MAX_QPATH];
 683         const char *text;
 684         clgecko_t *instance;
 685         const char *p;
 686
 687         if (Cmd_Argc() < 3)
 688         {
 689                 Con_Print("usage: gecko_injecttext <name> <text>\ninjects a certain text into the browser\n");
 690                 return;
 691         }
 692
 693         // TODO: use snprintf instead
 694         sprintf(name, CLGECKOPREFIX "%s", Cmd_Argv(1));
 695         instance = CL_Gecko_FindBrowser( name );
 696         if( !instance ) {
 697                 Con_Printf( "cl_gecko_injecttext_f: gecko instance '%s' couldn't be found!\n", name );
 698                 return;
 699         }
 700
 701         text = Cmd_Argv( 2 );
 702
 703         for( p = text ; *p ; p++ ) {
 704                 unsigned key = *p;
 705                 switch( key ) {
 706                         case ' ':
 707                                 key = K_SPACE;
 708                                 break;
 709                         case '\\':
 710                                 key = *++p;
 711                                 switch( key ) {
 712                                 case 'n':
 713                                         key = K_ENTER;
 714                                         break;
 715                                 case '\0':
 716                                         --p;
 717                                         key = '\\';
 718                                         break;
 719                                 }
 720                                 break;
 721                 }
 722
 723                 CL_Gecko_Event_Key( instance, key, CLG_BET_PRESS );
 724         }
 725 }
 726
 727 static void gl_gecko_movecursor_f( void ) {
 728         char name[MAX_QPATH];
 729         float x, y;
 730
 731         if (Cmd_Argc() != 4)
 732         {
 733                 Con_Print("usage: gecko_movecursor <name> <x> <y>\nmove the cursor to a certain position\n");
 734                 return;
 735         }
 736
 737         // TODO: use snprintf instead
 738         sprintf(name, CLGECKOPREFIX "%s", Cmd_Argv(1));
 739         x = atof( Cmd_Argv( 2 ) );
 740         y = atof( Cmd_Argv( 3 ) );
 741
 742         CL_Gecko_Event_CursorMove( CL_Gecko_FindBrowser( name ), x, y );
 743 }
 744
 745 #undef osgk_addref
 746 #undef osgk_release
 747
 748 static const dllfunction_t osgkFuncs[] =
 749 {
 750         {"osgk_addref",                             (void **) &osgk_addref},
 751         {"osgk_release",                            (void **) &osgk_release},
 752         {"osgk_embedding_create2",                  (void **) &osgk_embedding_create2},
 753         {"osgk_embedding_options_create",           (void **) &osgk_embedding_options_create},
 754         {"osgk_embedding_options_add_search_path",  (void **) &osgk_embedding_options_add_search_path},
 755         {"osgk_embedding_options_set_profile_dir",  (void **) &osgk_embedding_options_set_profile_dir},
 756         {"osgk_browser_create",                     (void **) &osgk_browser_create},
 757         {"osgk_browser_query_dirty",                (void **) &osgk_browser_query_dirty},
 758         {"osgk_browser_navigate",                   (void **) &osgk_browser_navigate},
 759         {"osgk_browser_lock_data",                  (void **) &osgk_browser_lock_data},
 760         {"osgk_browser_unlock_data",                (void **) &osgk_browser_unlock_data},
 761         {"osgk_browser_resize",                     (void **) &osgk_browser_resize},
 762         {"osgk_browser_event_mouse_move",           (void **) &osgk_browser_event_mouse_move},
 763         {"osgk_browser_event_mouse_button",         (void **) &osgk_browser_event_mouse_button},
 764         {"osgk_browser_event_mouse_wheel",          (void **) &osgk_browser_event_mouse_wheel},
 765         {"osgk_browser_event_key",                  (void **) &osgk_browser_event_key},
 766         {NULL, NULL}
 767 };
 768
 769 void CL_Gecko_Init( void )
 770 {
 771         const char* dllnames [] =
 772         {
 773         #if defined(WIN64)
 774                 "OffscreenGecko64.dll",
 775         #elif defined(WIN32)
 776                 "OffscreenGecko.dll",
 777         #elif defined(MACOSX)
 778                 "OffscreenGecko.dylib",
 779         #else
 780                 "libOffscreenGecko.so",
 781         #endif
 782                 NULL
 783         };
 784
 785         if (!osgk_dll)
 786         {
 787                 if (! Sys_LoadLibrary (dllnames, &osgk_dll, osgkFuncs))
 788                 {
 789                         Con_Printf ("Could not load OffscreenGecko, Gecko support unavailable\n");
 790                 }
 791         }
 792
 793         Cmd_AddCommand( "gecko_create", cl_gecko_create_f, "Create a gecko browser instance" );
 794         Cmd_AddCommand( "gecko_destroy", cl_gecko_destroy_f, "Destroy a gecko browser instance" );
 795         Cmd_AddCommand( "gecko_navigate", cl_gecko_navigate_f, "Navigate a gecko browser to a URI" );
 796         Cmd_AddCommand( "gecko_injecttext", cl_gecko_injecttext_f, "Injects text into a browser" );
 797         Cmd_AddCommand( "gecko_movecursor", gl_gecko_movecursor_f, "Move the cursor to a certain position" );
 798
 799         R_RegisterModule( "CL_Gecko", cl_gecko_start, cl_gecko_shutdown, cl_gecko_newmap );
 800 }
 801
 802 void CL_Gecko_NavigateToURI( clgecko_t *instance, const char *URI ) {
 803         if( !instance || !instance->browser ) {
 804                 return;
 805         }
 806
 807         if( instance->active ) {
 808                 osgk_browser_navigate( instance->browser, URI );
 809         }
 810 }
 811
 812 void CL_Gecko_Event_CursorMove( clgecko_t *instance, float x, float y ) {
 813         // TODO: assert x, y \in [0.0, 1.0]
 814         int mappedx, mappedy;
 815
 816         if( !instance || !instance->browser ) {
 817                 return;
 818         }
 819
 820         mappedx = x * instance->width;
 821         mappedy = y * instance->height;
 822         osgk_browser_event_mouse_move( instance->browser, mappedx, mappedy );
 823 }
 824
 825 typedef struct geckokeymapping_s {
 826         keynum_t keycode;
 827         unsigned int geckokeycode;
 828 } geckokeymapping_t;
 829
 830 static geckokeymapping_t geckokeymappingtable[] = {
 831         { K_BACKSPACE, OSGKKey_Backspace },
 832         { K_TAB, OSGKKey_Tab },
 833         { K_ENTER, OSGKKey_Return },
 834         { K_SHIFT, OSGKKey_Shift },
 835         { K_CTRL, OSGKKey_Control },
 836         { K_ALT, OSGKKey_Alt },
 837         { K_CAPSLOCK, OSGKKey_CapsLock },
 838         { K_ESCAPE, OSGKKey_Escape },
 839         { K_SPACE, OSGKKey_Space },
 840         { K_PGUP, OSGKKey_PageUp },
 841         { K_PGDN, OSGKKey_PageDown },
 842         { K_END, OSGKKey_End },
 843         { K_HOME, OSGKKey_Home },
 844         { K_LEFTARROW, OSGKKey_Left },
 845         { K_UPARROW, OSGKKey_Up },
 846         { K_RIGHTARROW, OSGKKey_Right },
 847         { K_DOWNARROW, OSGKKey_Down },
 848         { K_INS, OSGKKey_Insert },
 849         { K_DEL, OSGKKey_Delete },
 850         { K_F1, OSGKKey_F1 },
 851         { K_F2, OSGKKey_F2 },
 852         { K_F3, OSGKKey_F3 },
 853         { K_F4, OSGKKey_F4 },
 854         { K_F5, OSGKKey_F5 },
 855         { K_F6, OSGKKey_F6 },
 856         { K_F7, OSGKKey_F7 },
 857         { K_F8, OSGKKey_F8 },
 858         { K_F9, OSGKKey_F9 },
 859         { K_F10, OSGKKey_F10 },
 860         { K_F11, OSGKKey_F11 },
 861         { K_F12, OSGKKey_F12 },
 862         { K_NUMLOCK, OSGKKey_NumLock },
 863         { K_SCROLLOCK, OSGKKey_ScrollLock }
 864 };
 865
 866 qboolean CL_Gecko_Event_Key( clgecko_t *instance, keynum_t key, clgecko_buttoneventtype_t eventtype ) {
 867         if( !instance || !instance->browser ) {
 868                 return false;
 869         }
 870
 871         // determine whether its a keyboard event
 872         if( key < K_OTHERDEVICESBEGIN ) {
 873
 874                 OSGK_KeyboardEventType mappedtype = kePress;
 875                 unsigned int mappedkey = key;
 876
 877                 unsigned int i;
 878                 // yes! then convert it if necessary!
 879                 for( i = 0 ; i < sizeof( geckokeymappingtable ) / sizeof( *geckokeymappingtable ) ; i++ ) {
 880                         const geckokeymapping_t * const mapping = &geckokeymappingtable[ i ];
 881                         if( key == mapping->keycode ) {
 882                                 mappedkey = mapping->geckokeycode;
 883                                 break;
 884                         }
 885                 }
 886
 887                 // convert the eventtype
 888                 // map the type
 889                 switch( eventtype ) {
 890                 case CLG_BET_DOWN:
 891                         mappedtype = keDown;
 892                         break;
 893                 case CLG_BET_UP:
 894                         mappedtype = keUp;
 895                         break;
 896                 case CLG_BET_DOUBLECLICK:
 897                         // TODO: error message
 898                         break;
 899                 case CLG_BET_PRESS:
 900                         mappedtype = kePress;
 901                 }
 902
 903                 return osgk_browser_event_key( instance->browser, mappedkey, mappedtype ) != 0;
 904         } else if( K_MOUSE1 <= key && key <= K_MOUSE3 ) {
 905                 OSGK_MouseButtonEventType mappedtype = meDoubleClick;
 906                 OSGK_MouseButton mappedbutton;
 907
 908                 mappedbutton = (OSGK_MouseButton) (mbLeft + (key - K_MOUSE1));
 909
 910                 switch( eventtype ) {
 911                 case CLG_BET_DOWN:
 912                         mappedtype = meDown;
 913                         break;
 914                 case CLG_BET_UP:
 915                         mappedtype = meUp;
 916                         break;
 917                 case CLG_BET_DOUBLECLICK:
 918                         mappedtype = meDoubleClick;
 919                         break;
 920                 case CLG_BET_PRESS:
 921                         // hihi, hacky hacky
 922                         osgk_browser_event_mouse_button( instance->browser, mappedbutton, meDown );
 923                         mappedtype = meUp;
 924                         break;
 925                 }
 926
 927                 osgk_browser_event_mouse_button( instance->browser, mappedbutton, mappedtype );
 928                 return true;
 929         } else if( K_MWHEELUP <= key && key <= K_MWHEELDOWN ) {
 930                 if( eventtype == CLG_BET_DOWN )
 931                         osgk_browser_event_mouse_wheel( instance->browser,
 932                                 waVertical, (key == K_MWHEELUP) ? wdNegative : wdPositive );
 933                 return true;
 934         }
 935         // TODO: error?
 936         return false;
 937 }