开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llwindowsdl.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：69k
源码类别：

游戏引擎

开发平台：

C++ Builder

llwindowsdl.cpp：源码内容
  1. /** 
  2.  * @file llwindowsdl.cpp
  3.  * @brief SDL implementation of LLWindow class
  4.  * @author This module has many fathers, and it shows.
  5.  *
  6.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  7.  * 
  8.  * Copyright (c) 2001-2010, Linden Research, Inc.
  9.  * 
  10.  * Second Life Viewer Source Code
  11.  * The source code in this file ("Source Code") is provided by Linden Lab
  12.  * to you under the terms of the GNU General Public License, version 2.0
  13.  * ("GPL"), unless you have obtained a separate licensing agreement
  14.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  15.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  16.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  17.  * 
  18.  * There are special exceptions to the terms and conditions of the GPL as
  19.  * it is applied to this Source Code. View the full text of the exception
  20.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  21.  * online at
  22.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  23.  * 
  24.  * By copying, modifying or distributing this software, you acknowledge
  25.  * that you have read and understood your obligations described above,
  26.  * and agree to abide by those obligations.
  27.  * 
  28.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  29.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  30.  * COMPLETENESS OR PERFORMANCE.
  31.  * $/LicenseInfo$
  32.  */
  34. #if LL_SDL
  36. #include "linden_common.h"
  38. #include "llwindowsdl.h"
  40. #include "llwindowcallbacks.h"
  41. #include "llkeyboardsdl.h"
  43. #include "llerror.h"
  44. #include "llgl.h"
  45. #include "llstring.h"
  46. #include "lldir.h"
  47. #include "llfindlocale.h"
  49. #if LL_GTK
  50. extern "C" {
  51. # include "gtk/gtk.h"
  52. }
  53. #include <locale.h>
  54. #endif // LL_GTK
  56. extern "C" {
  57. # include "fontconfig/fontconfig.h"
  58. }
  60. #if LL_LINUX || LL_SOLARIS
  61. // not necessarily available on random SDL platforms, so #if LL_LINUX
  62. // for execv(), waitpid(), fork()
  63. # include <unistd.h>
  64. # include <sys/types.h>
  65. # include <sys/wait.h>
  66. #endif // LL_LINUX || LL_SOLARIS
  68. extern BOOL gDebugWindowProc;
  70. const S32 MAX_NUM_RESOLUTIONS = 200;
  72. // static variable for ATI mouse cursor crash work-around:
  73. static bool ATIbug = false; 
  75. //
  76. // LLWindowSDL
  77. //
  79. #if LL_X11
  80. # include <X11/Xutil.h>
  81. #endif //LL_X11
  83. // TOFU HACK -- (*exactly* the same hack as LLWindowMacOSX for a similar
  84. // set of reasons): Stash a pointer to the LLWindowSDL object here and
  85. // maintain in the constructor and destructor.  This assumes that there will
  86. // be only one object of this class at any time.  Currently this is true.
  87. static LLWindowSDL *gWindowImplementation = NULL;
  90. void maybe_lock_display(void)
  91. {
  92. if (gWindowImplementation && gWindowImplementation->Lock_Display) {
  93. gWindowImplementation->Lock_Display();
  94. }
  95. }
  98. void maybe_unlock_display(void)
  99. {
  100. if (gWindowImplementation && gWindowImplementation->Unlock_Display) {
  101. gWindowImplementation->Unlock_Display();
  102. }
  103. }
  106. #if LL_GTK
  107. // Lazily initialize and check the runtime GTK version for goodness.
  108. // static
  109. bool LLWindowSDL::ll_try_gtk_init(void)
  110. {
  111. static BOOL done_gtk_diag = FALSE;
  112. static BOOL gtk_is_good = FALSE;
  113. static BOOL done_setlocale = FALSE;
  114. static BOOL tried_gtk_init = FALSE;
  116. if (!done_setlocale)
  117. {
  118. llinfos << "Starting GTK Initialization." << llendl;
  119. maybe_lock_display();
  120. gtk_disable_setlocale();
  121. maybe_unlock_display();
  122. done_setlocale = TRUE;
  123. }
  125. if (!tried_gtk_init)
  126. {
  127. tried_gtk_init = TRUE;
  128. if (!g_thread_supported ()) g_thread_init (NULL);
  129. maybe_lock_display();
  130. gtk_is_good = gtk_init_check(NULL, NULL);
  131. maybe_unlock_display();
  132. if (!gtk_is_good)
  133. llwarns << "GTK Initialization failed." << llendl;
  134. }
  136. if (gtk_is_good && !done_gtk_diag)
  137. {
  138. llinfos << "GTK Initialized." << llendl;
  139. llinfos << "- Compiled against GTK version "
  140. << GTK_MAJOR_VERSION << "."
  141. << GTK_MINOR_VERSION << "."
  142. << GTK_MICRO_VERSION << llendl;
  143. llinfos << "- Running against GTK version "
  144. << gtk_major_version << "."
  145. << gtk_minor_version << "."
  146. << gtk_micro_version << llendl;
  147. maybe_lock_display();
  148. const gchar* gtk_warning = gtk_check_version(
  149. GTK_MAJOR_VERSION,
  150. GTK_MINOR_VERSION,
  151. GTK_MICRO_VERSION);
  152. maybe_unlock_display();
  153. if (gtk_warning)
  154. {
  155. llwarns << "- GTK COMPATIBILITY WARNING: " <<
  156. gtk_warning << llendl;
  157. gtk_is_good = FALSE;
  158. } else {
  159. llinfos << "- GTK version is good." << llendl;
  160. }
  162. done_gtk_diag = TRUE;
  163. }
  165. return gtk_is_good;
  166. }
  167. #endif // LL_GTK
  170. #if LL_X11
  171. // static
  172. Window LLWindowSDL::get_SDL_XWindowID(void)
  173. {
  174. if (gWindowImplementation) {
  175. return gWindowImplementation->mSDL_XWindowID;
  176. }
  177. return None;
  178. }
  180. //static
  181. Display* LLWindowSDL::get_SDL_Display(void)
  182. {
  183. if (gWindowImplementation) {
  184. return gWindowImplementation->mSDL_Display;
  185. }
  186. return NULL;
  187. }
  188. #endif // LL_X11
  191. LLWindowSDL::LLWindowSDL(LLWindowCallbacks* callbacks,
  192.  const std::string& title, S32 x, S32 y, S32 width,
  193.  S32 height, U32 flags,
  194.  BOOL fullscreen, BOOL clearBg,
  195.  BOOL disable_vsync, BOOL use_gl,
  196.  BOOL ignore_pixel_depth, U32 fsaa_samples)
  197. : LLWindow(callbacks, fullscreen, flags),
  198.   Lock_Display(NULL),
  199.   Unlock_Display(NULL), mGamma(1.0f)
  200. {
  201. // Initialize the keyboard
  202. gKeyboard = new LLKeyboardSDL();
  203. gKeyboard->setCallbacks(callbacks);
  204. // Note that we can't set up key-repeat until after SDL has init'd video
  206. // Ignore use_gl for now, only used for drones on PC
  207. mWindow = NULL;
  208. mNeedsResize = FALSE;
  209. mOverrideAspectRatio = 0.f;
  210. mGrabbyKeyFlags = 0;
  211. mReallyCapturedCount = 0;
  212. mHaveInputFocus = -1;
  213. mIsMinimized = -1;
  214. mFSAASamples = fsaa_samples;
  216. #if LL_X11
  217. mSDL_XWindowID = None;
  218. mSDL_Display = NULL;
  219. #endif // LL_X11
  221. #if LL_GTK
  222. // We MUST be the first to initialize GTK so that GTK doesn't get badly
  223. // initialized with a non-C locale and cause lots of serious random
  224. // weirdness.
  225. ll_try_gtk_init();
  226. #endif // LL_GTK
  228. // Assume 4:3 aspect ratio until we know better
  229. mOriginalAspectRatio = 1024.0 / 768.0;
  231. if (title.empty())
  232. mWindowTitle = "SDL Window";  // *FIX: (???)
  233. else
  234. mWindowTitle = title;
  236. // Create the GL context and set it up for windowed or fullscreen, as appropriate.
  237. if(createContext(x, y, width, height, 32, fullscreen, disable_vsync))
  238. {
  239. gGLManager.initGL();
  241. //start with arrow cursor
  242. initCursors();
  243. setCursor( UI_CURSOR_ARROW );
  244. }
  246. stop_glerror();
  248. // Stash an object pointer for OSMessageBox()
  249. gWindowImplementation = this;
  251. #if LL_X11
  252. mFlashing = FALSE;
  253. #endif // LL_X11
  255. mKeyScanCode = 0;
  256. mKeyVirtualKey = 0;
  257. mKeyModifiers = KMOD_NONE;
  258. }
  260. static SDL_Surface *Load_BMP_Resource(const char *basename)
  261. {
  262. const int PATH_BUFFER_SIZE=1000;
  263. char path_buffer[PATH_BUFFER_SIZE]; /* Flawfinder: ignore */
  265. // Figure out where our BMP is living on the disk
  266. snprintf(path_buffer, PATH_BUFFER_SIZE-1, "%s%sres-sdl%s%s",
  267.  gDirUtilp->getAppRODataDir().c_str(),
  268.  gDirUtilp->getDirDelimiter().c_str(),
  269.  gDirUtilp->getDirDelimiter().c_str(),
  270.  basename);
  271. path_buffer[PATH_BUFFER_SIZE-1] = '';
  273. return SDL_LoadBMP(path_buffer);
  274. }
  276. #if LL_X11
  277. // This is an XFree86/XOrg-specific hack for detecting the amount of Video RAM
  278. // on this machine.  It works by searching /var/log/var/log/Xorg.?.log or
  279. // /var/log/XFree86.?.log for a ': (VideoRAM ?|Memory): (%d+) kB' regex, where
  280. // '?' is the X11 display number derived from $DISPLAY
  281. static int x11_detect_VRAM_kb_fp(FILE *fp, const char *prefix_str)
  282. {
  283. const int line_buf_size = 1000;
  284. char line_buf[line_buf_size];
  285. while (fgets(line_buf, line_buf_size, fp))
  286. {
  287. //lldebugs << "XLOG: " << line_buf << llendl;
  289. // Why the ad-hoc parser instead of using a regex?  Our
  290. // favourite regex implementation - libboost_regex - is
  291. // quite a heavy and troublesome dependency for the client, so
  292. // it seems a shame to introduce it for such a simple task.
  293. // *FIXME: libboost_regex is a dependency now anyway, so we may
  294. // as well use it instead of this hand-rolled nonsense.
  295. const char *part1_template = prefix_str;
  296. const char part2_template[] = " kB";
  297. char *part1 = strstr(line_buf, part1_template);
  298. if (part1) // found start of matching line
  299. {
  300. part1 = &part1[strlen(part1_template)]; // -> after
  301. char *part2 = strstr(part1, part2_template);
  302. if (part2) // found end of matching line
  303. {
  304. // now everything between part1 and part2 is
  305. // supposed to be numeric, describing the
  306. // number of kB of Video RAM supported
  307. int rtn = 0;
  308. for (; part1 < part2; ++part1)
  309. {
  310. if (*part1 < '0' || *part1 > '9')
  311. {
  312. // unexpected char, abort parse
  313. rtn = 0;
  314. break;
  315. }
  316. rtn *= 10;
  317. rtn += (*part1) - '0';
  318. }
  319. if (rtn > 0)
  320. {
  321. // got the kB number.  return it now.
  322. return rtn;
  323. }
  324. }
  325. }
  326. }
  327. return 0; // 'could not detect'
  328. }
  330. static int x11_detect_VRAM_kb()
  331. {
  332. #if LL_SOLARIS && defined(__sparc)
  333.       //  NOTE: there's no Xorg server on SPARC so just return 0
  334.       //        and allow SDL to attempt to get the amount of VRAM
  335.       return(0);
  336. #else
  338. std::string x_log_location("/var/log/");
  339. std::string fname;
  340. int rtn = 0; // 'could not detect'
  341. int display_num = 0;
  342. FILE *fp;
  343. char *display_env = getenv("DISPLAY"); // e.g. :0 or :0.0 or :1.0 etc
  344. // parse DISPLAY number so we can go grab the right log file
  345. if (display_env[0] == ':' &&
  346.     display_env[1] >= '0' && display_env[1] <= '9')
  347. {
  348. display_num = display_env[1] - '0';
  349. }
  351. // *TODO: we could be smarter and see which of Xorg/XFree86 has the
  352. // freshest time-stamp.
  354. // Try Xorg log first
  355. fname = x_log_location;
  356. fname += "Xorg.";
  357. fname += ('0' + display_num);
  358. fname += ".log";
  359. fp = fopen(fname.c_str(), "r");
  360. if (fp)
  361. {
  362. llinfos << "Looking in " << fname
  363. << " for VRAM info..." << llendl;
  364. rtn = x11_detect_VRAM_kb_fp(fp, ": VideoRAM: ");
  365. fclose(fp);
  366. if (0 == rtn)
  367. {
  368. fp = fopen(fname.c_str(), "r");
  369. if (fp)
  370. {
  371. rtn = x11_detect_VRAM_kb_fp(fp, ": Video RAM: ");
  372. fclose(fp);
  373. if (0 == rtn)
  374. {
  375. fp = fopen(fname.c_str(), "r");
  376. if (fp)
  377. {
  378. rtn = x11_detect_VRAM_kb_fp(fp, ": Memory: ");
  379. fclose(fp);
  380. }
  381. }
  382. }
  383. }
  384. }
  385. else
  386. {
  387. llinfos << "Could not open " << fname
  388. << " - skipped." << llendl;
  389. // Try old XFree86 log otherwise
  390. fname = x_log_location;
  391. fname += "XFree86.";
  392. fname += ('0' + display_num);
  393. fname += ".log";
  394. fp = fopen(fname.c_str(), "r");
  395. if (fp)
  396. {
  397. llinfos << "Looking in " << fname
  398. << " for VRAM info..." << llendl;
  399. rtn = x11_detect_VRAM_kb_fp(fp, ": VideoRAM: ");
  400. fclose(fp);
  401. if (0 == rtn)
  402. {
  403. fp = fopen(fname.c_str(), "r");
  404. if (fp)
  405. {
  406. rtn = x11_detect_VRAM_kb_fp(fp, ": Memory: ");
  407. fclose(fp);
  408. }
  409. }
  410. }
  411. else
  412. {
  413. llinfos << "Could not open " << fname
  414. << " - skipped." << llendl;
  415. }
  416. }
  417. return rtn;
  418. #endif // LL_SOLARIS
  419. }
  420. #endif // LL_X11
  422. BOOL LLWindowSDL::createContext(int x, int y, int width, int height, int bits, BOOL fullscreen, BOOL disable_vsync)
  423. {
  424. //bool glneedsinit = false;
  426. llinfos << "createContext, fullscreen=" << fullscreen <<
  427.     " size=" << width << "x" << height << llendl;
  429. // captures don't survive contexts
  430. mGrabbyKeyFlags = 0;
  431. mReallyCapturedCount = 0;
  433. if (SDL_Init(SDL_INIT_VIDEO) < 0)
  434. {
  435. llinfos << "sdl_init() failed! " << SDL_GetError() << llendl;
  436. setupFailure("sdl_init() failure,  window creation error", "error", OSMB_OK);
  437. return false;
  438. }
  440. SDL_version c_sdl_version;
  441. SDL_VERSION(&c_sdl_version);
  442. llinfos << "Compiled against SDL "
  443. << int(c_sdl_version.major) << "."
  444. << int(c_sdl_version.minor) << "."
  445. << int(c_sdl_version.patch) << llendl;
  446. const SDL_version *r_sdl_version;
  447. r_sdl_version = SDL_Linked_Version();
  448. llinfos << " Running against SDL "
  449. << int(r_sdl_version->major) << "."
  450. << int(r_sdl_version->minor) << "."
  451. << int(r_sdl_version->patch) << llendl;
  453. const SDL_VideoInfo *video_info = SDL_GetVideoInfo( );
  454. if (!video_info)
  455. {
  456. llinfos << "SDL_GetVideoInfo() failed! " << SDL_GetError() << llendl;
  457. setupFailure("SDL_GetVideoInfo() failed, Window creation error", "Error", OSMB_OK);
  458. return FALSE;
  459. }
  461. if (video_info->current_h > 0)
  462. {
  463. mOriginalAspectRatio = (float)video_info->current_w / (float)video_info->current_h;
  464. llinfos << "Original aspect ratio was " << video_info->current_w << ":" << video_info->current_h << "=" << mOriginalAspectRatio << llendl;
  465. }
  467. SDL_EnableUNICODE(1);
  468. SDL_WM_SetCaption(mWindowTitle.c_str(), mWindowTitle.c_str());
  470. // Set the application icon.
  471. SDL_Surface *bmpsurface;
  472. bmpsurface = Load_BMP_Resource("ll_icon.BMP");
  473. if (bmpsurface)
  474. {
  475. // This attempts to give a black-keyed mask to the icon.
  476. SDL_SetColorKey(bmpsurface,
  477. SDL_SRCCOLORKEY,
  478. SDL_MapRGB(bmpsurface->format, 0,0,0) );
  479. SDL_WM_SetIcon(bmpsurface, NULL);
  480. // The SDL examples cheerfully avoid freeing the icon
  481. // surface, but I'm betting that's leaky.
  482. SDL_FreeSurface(bmpsurface);
  483. bmpsurface = NULL;
  484. }
  486. // note: these SetAttributes make Tom's 9600-on-AMD64 fail to
  487. // get a visual, but it's broken anyway when it does, and without
  488. // these SetAttributes we might easily get an avoidable substandard
  489. // visual to work with on most other machines.
  490. SDL_GL_SetAttribute(SDL_GL_RED_SIZE,  8);
  491. SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE,8);
  492. SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
  493. #if !LL_SOLARIS
  494.         SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, (bits <= 16) ? 16 : 24);
  495. // We need stencil support for a few (minor) things.
  496. if (!getenv("LL_GL_NO_STENCIL"))
  497. SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
  498. #else
  499. // NOTE- use smaller Z-buffer to enable more graphics cards
  500.         //     - This should not affect better GPUs and has been proven
  501.         //  to provide 24-bit z-buffers when available.
  502. //
  503.         // As the API states: 
  504. //
  505.         // GLX_DEPTH_SIZE    Must be followed by a nonnegative
  506.         //                   minimum size specification.  If this
  507.         //                   value is zero, visuals with no depth
  508.         //                   buffer are preferred.  Otherwise, the
  509.         //                   largest available depth buffer of at
  510.         //                   least the minimum size is preferred.
  512.         SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
  513. #endif
  514.         SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, (bits <= 16) ? 1 : 8);
  516.         // *FIX: try to toggle vsync here?
  518. mFullscreen = fullscreen;
  520. int sdlflags = SDL_OPENGL | SDL_RESIZABLE | SDL_ANYFORMAT;
  522. SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
  524. if (mFSAASamples > 0)
  525. {
  526. SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
  527. SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, mFSAASamples);
  528. }
  530.      mSDLFlags = sdlflags;
  532. if (mFullscreen)
  533. {
  534. llinfos << "createContext: setting up fullscreen " << width << "x" << height << llendl;
  536. // If the requested width or height is 0, find the best default for the monitor.
  537. if((width == 0) || (height == 0))
  538. {
  539. // Scan through the list of modes, looking for one which has:
  540. // height between 700 and 800
  541. // aspect ratio closest to the user's original mode
  542. S32 resolutionCount = 0;
  543. LLWindowResolution *resolutionList = getSupportedResolutions(resolutionCount);
  545. if(resolutionList != NULL)
  546. {
  547. F32 closestAspect = 0;
  548. U32 closestHeight = 0;
  549. U32 closestWidth = 0;
  550. int i;
  552. llinfos << "createContext: searching for a display mode, original aspect is " << mOriginalAspectRatio << llendl;
  554. for(i=0; i < resolutionCount; i++)
  555. {
  556. F32 aspect = (F32)resolutionList[i].mWidth / (F32)resolutionList[i].mHeight;
  558. llinfos << "createContext: width " << resolutionList[i].mWidth << " height " << resolutionList[i].mHeight << " aspect " << aspect << llendl;
  560. if( (resolutionList[i].mHeight >= 700) && (resolutionList[i].mHeight <= 800) &&
  561. (fabs(aspect - mOriginalAspectRatio) < fabs(closestAspect - mOriginalAspectRatio)))
  562. {
  563. llinfos << " (new closest mode) " << llendl;
  565. // This is the closest mode we've seen yet.
  566. closestWidth = resolutionList[i].mWidth;
  567. closestHeight = resolutionList[i].mHeight;
  568. closestAspect = aspect;
  569. }
  570. }
  572. width = closestWidth;
  573. height = closestHeight;
  574. }
  575. }
  577. if((width == 0) || (height == 0))
  578. {
  579. // Mode search failed for some reason.  Use the old-school default.
  580. width = 1024;
  581. height = 768;
  582. }
  584. mWindow = SDL_SetVideoMode(width, height, bits, sdlflags | SDL_FULLSCREEN);
  585. if (!mWindow && bits > 16)
  586. {
  587. SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
  588. mWindow = SDL_SetVideoMode(width, height, bits, sdlflags | SDL_FULLSCREEN);
  589. }
  591. if (mWindow)
  592. {
  593. mFullscreen = TRUE;
  594. mFullscreenWidth   = mWindow->w;
  595. mFullscreenHeight  = mWindow->h;
  596. mFullscreenBits    = mWindow->format->BitsPerPixel;
  597. mFullscreenRefresh = -1;
  599. llinfos << "Running at " << mFullscreenWidth
  600. << "x"   << mFullscreenHeight
  601. << "x"   << mFullscreenBits
  602. << " @ " << mFullscreenRefresh
  603. << llendl;
  604. }
  605. else
  606. {
  607. llwarns << "createContext: fullscreen creation failure. SDL: " << SDL_GetError() << llendl;
  608. // No fullscreen support
  609. mFullscreen = FALSE;
  610. mFullscreenWidth   = -1;
  611. mFullscreenHeight  = -1;
  612. mFullscreenBits    = -1;
  613. mFullscreenRefresh = -1;
  615. std::string error = llformat("Unable to run fullscreen at %d x %d.nRunning in window.", width, height);
  616. OSMessageBox(error, "Error", OSMB_OK);
  617. }
  618. }
  620. if(!mFullscreen && (mWindow == NULL))
  621. {
  622. if (width == 0)
  623.     width = 1024;
  624. if (height == 0)
  625.     width = 768;
  627. llinfos << "createContext: creating window " << width << "x" << height << "x" << bits << llendl;
  628. mWindow = SDL_SetVideoMode(width, height, bits, sdlflags);
  629. if (!mWindow && bits > 16)
  630. {
  631. SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
  632. mWindow = SDL_SetVideoMode(width, height, bits, sdlflags);
  633. }
  635. if (!mWindow)
  636. {
  637. llwarns << "createContext: window creation failure. SDL: " << SDL_GetError() << llendl;
  638. setupFailure("Window creation error", "Error", OSMB_OK);
  639. return FALSE;
  640. }
  641. } else if (!mFullscreen && (mWindow != NULL))
  642. {
  643. llinfos << "createContext: SKIPPING - !fullscreen, but +mWindow " << width << "x" << height << "x" << bits << llendl;
  644. }
  646. // Detect video memory size.
  647. # if LL_X11
  648. gGLManager.mVRAM = x11_detect_VRAM_kb() / 1024;
  649. if (gGLManager.mVRAM != 0)
  650. {
  651. llinfos << "X11 log-parser detected " << gGLManager.mVRAM << "MB VRAM." << llendl;
  652. } else
  653. # endif // LL_X11
  654. {
  655. // fallback to letting SDL detect VRAM.
  656. // note: I've not seen SDL's detection ever actually find
  657. // VRAM != 0, but if SDL *does* detect it then that's a bonus.
  658. gGLManager.mVRAM = video_info->video_mem / 1024;
  659. if (gGLManager.mVRAM != 0)
  660. {
  661. llinfos << "SDL detected " << gGLManager.mVRAM << "MB VRAM." << llendl;
  662. }
  663. }
  664. // If VRAM is not detected, that is handled later
  666. // *TODO: Now would be an appropriate time to check for some
  667. // explicitly unsupported cards.
  668. //const char* RENDERER = (const char*) glGetString(GL_RENDERER);
  670. GLint depthBits, stencilBits, redBits, greenBits, blueBits, alphaBits;
  672. glGetIntegerv(GL_RED_BITS, &redBits);
  673. glGetIntegerv(GL_GREEN_BITS, &greenBits);
  674. glGetIntegerv(GL_BLUE_BITS, &blueBits);
  675. glGetIntegerv(GL_ALPHA_BITS, &alphaBits);
  676. glGetIntegerv(GL_DEPTH_BITS, &depthBits);
  677. glGetIntegerv(GL_STENCIL_BITS, &stencilBits);
  679. llinfos << "GL buffer:" << llendl;
  680.         llinfos << "  Red Bits " << S32(redBits) << llendl;
  681.         llinfos << "  Green Bits " << S32(greenBits) << llendl;
  682.         llinfos << "  Blue Bits " << S32(blueBits) << llendl;
  683. llinfos << "  Alpha Bits " << S32(alphaBits) << llendl;
  684. llinfos << "  Depth Bits " << S32(depthBits) << llendl;
  685. llinfos << "  Stencil Bits " << S32(stencilBits) << llendl;
  687. GLint colorBits = redBits + greenBits + blueBits + alphaBits;
  688. // fixme: actually, it's REALLY important for picking that we get at
  689. // least 8 bits each of red,green,blue.  Alpha we can be a bit more
  690. // relaxed about if we have to.
  691. #if LL_SOLARIS && defined(__sparc)
  692. //  again the __sparc required because Xsun support, 32bit are very pricey on SPARC
  693. if(colorBits < 24) //HACK:  on SPARC allow 24-bit color
  694. #else
  695. if (colorBits < 32)
  696. #endif
  697. {
  698. close();
  699. setupFailure(
  700. #if LL_SOLARIS && defined(__sparc)
  701. "Second Life requires at least 24-bit color on SPARC to run in a window.n"
  702. "Please use fbconfig to set your default color depth to 24 bits.n"
  703. "You may also need to adjust the X11 setting in SMF.  To do so usen"
  704. "  'svccfg -s svc:/application/x11/x11-server setprop options/default_depth=24'n"
  705. #else
  706. "Second Life requires True Color (32-bit) to run in a window.n"
  707. "Please go to Control Panels -> Display -> Settings andn"
  708. "set the screen to 32-bit color.n"
  709. #endif
  710. "Alternately, if you choose to run fullscreen, Second Lifen"
  711. "will automatically adjust the screen each time it runs.",
  712. "Error",
  713. OSMB_OK);
  714. return FALSE;
  715. }
  717. #if 0  // *FIX: we're going to brave it for now...
  718. if (alphaBits < 8)
  719. {
  720. close();
  721. setupFailure(
  722. "Second Life is unable to run because it can't get an 8 bit alphan"
  723. "channel.  Usually this is due to video card driver issues.n"
  724. "Please make sure you have the latest video card drivers installed.n"
  725. "Also be sure your monitor is set to True Color (32-bit) inn"
  726. "Control Panels -> Display -> Settings.n"
  727. "If you continue to receive this message, contact customer service.",
  728. "Error",
  729. OSMB_OK);
  730. return FALSE;
  731. }
  732. #endif
  734. #if LL_X11
  735. /* Grab the window manager specific information */
  736. SDL_SysWMinfo info;
  737. SDL_VERSION(&info.version);
  738. if ( SDL_GetWMInfo(&info) )
  739. {
  740. /* Save the information for later use */
  741. if ( info.subsystem == SDL_SYSWM_X11 )
  742. {
  743. mSDL_Display = info.info.x11.display;
  744. mSDL_XWindowID = info.info.x11.wmwindow;
  745. Lock_Display = info.info.x11.lock_func;
  746. Unlock_Display = info.info.x11.unlock_func;
  747. }
  748. else
  749. {
  750. llwarns << "We're not running under X11?  Wild."
  751. << llendl;
  752. }
  753. }
  754. else
  755. {
  756. llwarns << "We're not running under any known WM.  Wild."
  757. << llendl;
  758. }
  759. #endif // LL_X11
  762. //make sure multisampling is disabled by default
  763. glDisable(GL_MULTISAMPLE_ARB);
  765. // We need to do this here, once video is init'd
  766. if (-1 == SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY,
  767.       SDL_DEFAULT_REPEAT_INTERVAL))
  768.     llwarns << "Couldn't enable key-repeat: " << SDL_GetError() <<llendl;
  770. // Don't need to get the current gamma, since there's a call that restores it to the system defaults.
  771. return TRUE;
  772. }
  775. // changing fullscreen resolution, or switching between windowed and fullscreen mode.
  776. BOOL LLWindowSDL::switchContext(BOOL fullscreen, const LLCoordScreen &size, BOOL disable_vsync, const LLCoordScreen * const posp)
  777. {
  778. const BOOL needsRebuild = TRUE;  // Just nuke the context and start over.
  779. BOOL result = true;
  781. llinfos << "switchContext, fullscreen=" << fullscreen << llendl;
  782. stop_glerror();
  783. if(needsRebuild)
  784. {
  785. destroyContext();
  786. result = createContext(0, 0, size.mX, size.mY, 0, fullscreen, disable_vsync);
  787. if (result)
  788. {
  789. gGLManager.initGL();
  791. //start with arrow cursor
  792. initCursors();
  793. setCursor( UI_CURSOR_ARROW );
  794. }
  795. }
  797. stop_glerror();
  799. return result;
  800. }
  802. void LLWindowSDL::destroyContext()
  803. {
  804. llinfos << "destroyContext begins" << llendl;
  806. #if LL_X11
  807. mSDL_Display = NULL;
  808. mSDL_XWindowID = None;
  809. Lock_Display = NULL;
  810. Unlock_Display = NULL;
  811. #endif // LL_X11
  813. // Clean up remaining GL state before blowing away window
  814. llinfos << "shutdownGL begins" << llendl;
  815. gGLManager.shutdownGL();
  816. llinfos << "SDL_QuitSS/VID begins" << llendl;
  817. SDL_QuitSubSystem(SDL_INIT_VIDEO);  // *FIX: this might be risky...
  819. mWindow = NULL;
  820. }
  822. LLWindowSDL::~LLWindowSDL()
  823. {
  824. quitCursors();
  825. destroyContext();
  827. if(mSupportedResolutions != NULL)
  828. {
  829. delete []mSupportedResolutions;
  830. }
  832. gWindowImplementation = NULL;
  833. }
  836. void LLWindowSDL::show()
  837. {
  838.     // *FIX: What to do with SDL?
  839. }
  841. void LLWindowSDL::hide()
  842. {
  843.     // *FIX: What to do with SDL?
  844. }
  846. //virtual
  847. void LLWindowSDL::minimize()
  848. {
  849.     // *FIX: What to do with SDL?
  850. }
  852. //virtual
  853. void LLWindowSDL::restore()
  854. {
  855.     // *FIX: What to do with SDL?
  856. }
  859. // close() destroys all OS-specific code associated with a window.
  860. // Usually called from LLWindowManager::destroyWindow()
  861. void LLWindowSDL::close()
  862. {
  863. // Is window is already closed?
  864. // if (!mWindow)
  865. // {
  866. // return;
  867. // }
  869. // Make sure cursor is visible and we haven't mangled the clipping state.
  870. setMouseClipping(FALSE);
  871. showCursor();
  873. destroyContext();
  874. }
  876. BOOL LLWindowSDL::isValid()
  877. {
  878. return (mWindow != NULL);
  879. }
  881. BOOL LLWindowSDL::getVisible()
  882. {
  883. BOOL result = FALSE;
  885.     // *FIX: This isn't really right...
  886. // Then what is?
  887. if (mWindow)
  888. {
  889. result = TRUE;
  890. }
  892. return(result);
  893. }
  895. BOOL LLWindowSDL::getMinimized()
  896. {
  897. BOOL result = FALSE;
  899. if (mWindow && (1 == mIsMinimized))
  900. {
  901. result = TRUE;
  902. }
  903. return(result);
  904. }
  906. BOOL LLWindowSDL::getMaximized()
  907. {
  908. BOOL result = FALSE;
  910. if (mWindow)
  911. {
  912. // TODO
  913. }
  915. return(result);
  916. }
  918. BOOL LLWindowSDL::maximize()
  919. {
  920. // TODO
  921. return FALSE;
  922. }
  924. BOOL LLWindowSDL::getFullscreen()
  925. {
  926. return mFullscreen;
  927. }
  929. BOOL LLWindowSDL::getPosition(LLCoordScreen *position)
  930. {
  931.     // *FIX: can anything be done with this?
  932. position->mX = 0;
  933. position->mY = 0;
  934.     return TRUE;
  935. }
  937. BOOL LLWindowSDL::getSize(LLCoordScreen *size)
  938. {
  939.     if (mWindow)
  940.     {
  941.         size->mX = mWindow->w;
  942.         size->mY = mWindow->h;
  943. return (TRUE);
  944.     }
  946.     return (FALSE);
  947. }
  949. BOOL LLWindowSDL::getSize(LLCoordWindow *size)
  950. {
  951.     if (mWindow)
  952.     {
  953.         size->mX = mWindow->w;
  954.         size->mY = mWindow->h;
  955. return (TRUE);
  956.     }
  958.     return (FALSE);
  959. }
  961. BOOL LLWindowSDL::setPosition(const LLCoordScreen position)
  962. {
  963. if(mWindow)
  964. {
  965.         // *FIX: (???)
  966. //MacMoveWindow(mWindow, position.mX, position.mY, false);
  967. }
  969. return TRUE;
  970. }
  972. BOOL LLWindowSDL::setSize(const LLCoordScreen size)
  973. {
  974. if(mWindow)
  975. {
  976. // Push a resize event onto SDL's queue - we'll handle it
  977. // when it comes out again.
  978. SDL_Event event;
  979. event.type = SDL_VIDEORESIZE;
  980. event.resize.w = size.mX;
  981. event.resize.h = size.mY;
  982. SDL_PushEvent(&event); // copied into queue
  984. return TRUE;
  985. }
  987. return FALSE;
  988. }
  990. void LLWindowSDL::swapBuffers()
  991. {
  992. if (mWindow)
  993. SDL_GL_SwapBuffers();
  994. }
  996. U32 LLWindowSDL::getFSAASamples()
  997. {
  998. return mFSAASamples;
  999. }
  1001. void LLWindowSDL::setFSAASamples(const U32 samples)
  1002. {
  1003. mFSAASamples = samples;
  1004. }
  1006. F32 LLWindowSDL::getGamma()
  1007. {
  1008. return 1/mGamma;
  1009. }
  1011. BOOL LLWindowSDL::restoreGamma()
  1012. {
  1013. //CGDisplayRestoreColorSyncSettings();
  1014.     SDL_SetGamma(1.0f, 1.0f, 1.0f);
  1015. return true;
  1016. }
  1018. BOOL LLWindowSDL::setGamma(const F32 gamma)
  1019. {
  1020. mGamma = gamma;
  1021. if (mGamma == 0) mGamma = 0.1f;
  1022. mGamma = 1/mGamma;
  1023. SDL_SetGamma(mGamma, mGamma, mGamma);
  1024. return true;
  1025. }
  1027. BOOL LLWindowSDL::isCursorHidden()
  1028. {
  1029. return mCursorHidden;
  1030. }
  1034. // Constrains the mouse to the window.
  1035. void LLWindowSDL::setMouseClipping( BOOL b )
  1036. {
  1037.     //SDL_WM_GrabInput(b ? SDL_GRAB_ON : SDL_GRAB_OFF);
  1038. }
  1040. BOOL LLWindowSDL::setCursorPosition(const LLCoordWindow position)
  1041. {
  1042. BOOL result = TRUE;
  1043. LLCoordScreen screen_pos;
  1045. if (!convertCoords(position, &screen_pos))
  1046. {
  1047. return FALSE;
  1048. }
  1050. //llinfos << "setCursorPosition(" << screen_pos.mX << ", " << screen_pos.mY << ")" << llendl;
  1052. // do the actual forced cursor move.
  1053. SDL_WarpMouse(screen_pos.mX, screen_pos.mY);
  1055. //llinfos << llformat("llcw %d,%d -> scr %d,%d", position.mX, position.mY, screen_pos.mX, screen_pos.mY) << llendl;
  1057. return result;
  1058. }
  1060. BOOL LLWindowSDL::getCursorPosition(LLCoordWindow *position)
  1061. {
  1062. //Point cursor_point;
  1063. LLCoordScreen screen_pos;
  1065. //GetMouse(&cursor_point);
  1066.     int x, y;
  1067.     SDL_GetMouseState(&x, &y);
  1069. screen_pos.mX = x;
  1070. screen_pos.mY = y;
  1072. return convertCoords(screen_pos, position);
  1073. }
  1076. F32 LLWindowSDL::getNativeAspectRatio()
  1077. {
  1078. #if 0
  1079. // RN: this hack presumes that the largest supported resolution is monitor-limited
  1080. // and that pixels in that mode are square, therefore defining the native aspect ratio
  1081. // of the monitor...this seems to work to a close approximation for most CRTs/LCDs
  1082. S32 num_resolutions;
  1083. LLWindowResolution* resolutions = getSupportedResolutions(num_resolutions);
  1086. return ((F32)resolutions[num_resolutions - 1].mWidth / (F32)resolutions[num_resolutions - 1].mHeight);
  1087. //rn: AC
  1088. #endif
  1090. // MBW -- there are a couple of bad assumptions here.  One is that the display list won't include
  1091. // ridiculous resolutions nobody would ever use.  The other is that the list is in order.
  1093. // New assumptions:
  1094. // - pixels are square (the only reasonable choice, really)
  1095. // - The user runs their display at a native resolution, so the resolution of the display
  1096. //    when the app is launched has an aspect ratio that matches the monitor.
  1098. //RN: actually, the assumption that there are no ridiculous resolutions (above the display's native capabilities) has 
  1099. // been born out in my experience.  
  1100. // Pixels are often not square (just ask the people who run their LCDs at 1024x768 or 800x600 when running fullscreen, like me)
  1101. // The ordering of display list is a blind assumption though, so we should check for max values
  1102. // Things might be different on the Mac though, so I'll defer to MBW
  1104. // The constructor for this class grabs the aspect ratio of the monitor before doing any resolution
  1105. // switching, and stashes it in mOriginalAspectRatio.  Here, we just return it.
  1107. if (mOverrideAspectRatio > 0.f)
  1108. {
  1109. return mOverrideAspectRatio;
  1110. }
  1112. return mOriginalAspectRatio;
  1113. }
  1115. F32 LLWindowSDL::getPixelAspectRatio()
  1116. {
  1117. F32 pixel_aspect = 1.f;
  1118. if (getFullscreen())
  1119. {
  1120. LLCoordScreen screen_size;
  1121. if (getSize(&screen_size))
  1122. {
  1123. pixel_aspect = getNativeAspectRatio() * (F32)screen_size.mY / (F32)screen_size.mX;
  1124. }
  1125. }
  1127. return pixel_aspect;
  1128. }
  1131. // This is to support 'temporarily windowed' mode so that
  1132. // dialogs are still usable in fullscreen.
  1133. void LLWindowSDL::beforeDialog()
  1134. {
  1135. bool running_x11 = false;
  1136. #if LL_X11
  1137. running_x11 = (mSDL_XWindowID != None);
  1138. #endif //LL_X11
  1140. llinfos << "LLWindowSDL::beforeDialog()" << llendl;
  1142. if (SDLReallyCaptureInput(FALSE)) // must ungrab input so popup works!
  1143. {
  1144. if (mFullscreen)
  1145. {
  1146. // need to temporarily go non-fullscreen; bless SDL
  1147. // for providing a SDL_WM_ToggleFullScreen() - though
  1148. // it only works in X11
  1149. if (running_x11 && mWindow)
  1150. {
  1151. SDL_WM_ToggleFullScreen(mWindow);
  1152. }
  1153. }
  1154. }
  1156. #if LL_X11
  1157. if (mSDL_Display)
  1158. {
  1159. // Everything that we/SDL asked for should happen before we
  1160. // potentially hand control over to GTK.
  1161. maybe_lock_display();
  1162. XSync(mSDL_Display, False);
  1163. maybe_unlock_display();
  1164. }
  1165. #endif // LL_X11
  1167. #if LL_GTK
  1168. // this is a good time to grab some GTK version information for
  1169. // diagnostics, if not already done.
  1170. ll_try_gtk_init();
  1171. #endif // LL_GTK
  1173. maybe_lock_display();
  1174. }
  1176. void LLWindowSDL::afterDialog()
  1177. {
  1178. bool running_x11 = false;
  1179. #if LL_X11
  1180. running_x11 = (mSDL_XWindowID != None);
  1181. #endif //LL_X11
  1183. llinfos << "LLWindowSDL::afterDialog()" << llendl;
  1185. maybe_unlock_display();
  1187. if (mFullscreen)
  1188. {
  1189. // need to restore fullscreen mode after dialog - only works
  1190. // in X11
  1191. if (running_x11 && mWindow)
  1192. {
  1193. SDL_WM_ToggleFullScreen(mWindow);
  1194. }
  1195. }
  1196. }
  1199. #if LL_X11
  1200. // set/reset the XWMHints flag for 'urgency' that usually makes the icon flash
  1201. void LLWindowSDL::x11_set_urgent(BOOL urgent)
  1202. {
  1203. if (mSDL_Display && !mFullscreen)
  1204. {
  1205. XWMHints *wm_hints;
  1207. llinfos << "X11 hint for urgency, " << urgent << llendl;
  1209. maybe_lock_display();
  1210. wm_hints = XGetWMHints(mSDL_Display, mSDL_XWindowID);
  1211. if (!wm_hints)
  1212. wm_hints = XAllocWMHints();
  1214. if (urgent)
  1215. wm_hints->flags |= XUrgencyHint;
  1216. else
  1217. wm_hints->flags &= ~XUrgencyHint;
  1219. XSetWMHints(mSDL_Display, mSDL_XWindowID, wm_hints);
  1220. XFree(wm_hints);
  1221. XSync(mSDL_Display, False);
  1222. maybe_unlock_display();
  1223. }
  1224. }
  1225. #endif // LL_X11
  1227. void LLWindowSDL::flashIcon(F32 seconds)
  1228. {
  1229. #if !LL_X11
  1230. llinfos << "Stub LLWindowSDL::flashIcon(" << seconds << ")" << llendl;
  1231. #else
  1232. llinfos << "X11 LLWindowSDL::flashIcon(" << seconds << ")" << llendl;
  1234. F32 remaining_time = mFlashTimer.getRemainingTimeF32();
  1235. if (remaining_time < seconds)
  1236. remaining_time = seconds;
  1237. mFlashTimer.reset();
  1238. mFlashTimer.setTimerExpirySec(remaining_time);
  1240. x11_set_urgent(TRUE);
  1241. mFlashing = TRUE;
  1242. #endif // LL_X11
  1243. }
  1246. #if LL_GTK
  1247. BOOL LLWindowSDL::isClipboardTextAvailable()
  1248. {
  1249. if (ll_try_gtk_init())
  1250. {
  1251. GtkClipboard * const clipboard =
  1252. gtk_clipboard_get(GDK_NONE);
  1253. return gtk_clipboard_wait_is_text_available(clipboard) ?
  1254. TRUE : FALSE;
  1255. }
  1256. return FALSE; // failure
  1257. }
  1259. BOOL LLWindowSDL::pasteTextFromClipboard(LLWString &text)
  1260. {
  1261. if (ll_try_gtk_init())
  1262. {
  1263. GtkClipboard * const clipboard =
  1264. gtk_clipboard_get(GDK_NONE);
  1265. gchar * const data = gtk_clipboard_wait_for_text(clipboard);
  1266. if (data)
  1267. {
  1268. text = LLWString(utf8str_to_wstring(data));
  1269. g_free(data);
  1270. return TRUE;
  1271. }
  1272. }
  1273. return FALSE; // failure
  1274. }
  1276. BOOL LLWindowSDL::copyTextToClipboard(const LLWString &text)
  1277. {
  1278. if (ll_try_gtk_init())
  1279. {
  1280. const std::string utf8 = wstring_to_utf8str(text);
  1281. GtkClipboard * const clipboard =
  1282. gtk_clipboard_get(GDK_NONE);
  1283. gtk_clipboard_set_text(clipboard, utf8.c_str(), utf8.length());
  1284. return TRUE;
  1285. }
  1286. return FALSE; // failure
  1287. }
  1290. BOOL LLWindowSDL::isPrimaryTextAvailable()
  1291. {
  1292. if (ll_try_gtk_init())
  1293. {
  1294. GtkClipboard * const clipboard =
  1295. gtk_clipboard_get(GDK_SELECTION_PRIMARY);
  1296. return gtk_clipboard_wait_is_text_available(clipboard) ?
  1297. TRUE : FALSE;
  1298. }
  1299. return FALSE; // failure
  1300. }
  1302. BOOL LLWindowSDL::pasteTextFromPrimary(LLWString &text)
  1303. {
  1304. if (ll_try_gtk_init())
  1305. {
  1306. GtkClipboard * const clipboard =
  1307. gtk_clipboard_get(GDK_SELECTION_PRIMARY);
  1308. gchar * const data = gtk_clipboard_wait_for_text(clipboard);
  1309. if (data)
  1310. {
  1311. text = LLWString(utf8str_to_wstring(data));
  1312. g_free(data);
  1313. return TRUE;
  1314. }
  1315. }
  1316. return FALSE; // failure
  1317. }
  1319. BOOL LLWindowSDL::copyTextToPrimary(const LLWString &text)
  1320. {
  1321. if (ll_try_gtk_init())
  1322. {
  1323. const std::string utf8 = wstring_to_utf8str(text);
  1324. GtkClipboard * const clipboard =
  1325. gtk_clipboard_get(GDK_SELECTION_PRIMARY);
  1326. gtk_clipboard_set_text(clipboard, utf8.c_str(), utf8.length());
  1327. return TRUE;
  1328. }
  1329. return FALSE; // failure
  1330. }
  1332. #else
  1334. BOOL LLWindowSDL::isClipboardTextAvailable()
  1335. {
  1336. return FALSE; // unsupported
  1337. }
  1339. BOOL LLWindowSDL::pasteTextFromClipboard(LLWString &dst)
  1340. {
  1341. return FALSE; // unsupported
  1342. }
  1344. BOOL LLWindowSDL::copyTextToClipboard(const LLWString &s)
  1345. {
  1346. return FALSE;  // unsupported
  1347. }
  1349. BOOL LLWindowSDL::isPrimaryTextAvailable()
  1350. {
  1351. return FALSE; // unsupported
  1352. }
  1354. BOOL LLWindowSDL::pasteTextFromPrimary(LLWString &dst)
  1355. {
  1356. return FALSE; // unsupported
  1357. }
  1359. BOOL LLWindowSDL::copyTextToPrimary(const LLWString &s)
  1360. {
  1361. return FALSE;  // unsupported
  1362. }
  1364. #endif // LL_GTK
  1366. LLWindow::LLWindowResolution* LLWindowSDL::getSupportedResolutions(S32 &num_resolutions)
  1367. {
  1368. if (!mSupportedResolutions)
  1369. {
  1370. mSupportedResolutions = new LLWindowResolution[MAX_NUM_RESOLUTIONS];
  1371. mNumSupportedResolutions = 0;
  1373.         SDL_Rect **modes = SDL_ListModes(NULL, SDL_OPENGL | SDL_FULLSCREEN);
  1374.         if ( (modes != NULL) && (modes != ((SDL_Rect **) -1)) )
  1375.         {
  1376.             int count = 0;
  1377.             while (*modes && count<MAX_NUM_RESOLUTIONS)  // they're sorted biggest to smallest, so find end...
  1378.             {
  1379.                 modes++;
  1380.                 count++;
  1381.             }
  1383.             while (count--)
  1384.             {
  1385.                 modes--;
  1386.                 SDL_Rect *r = *modes;
  1387.                 int w = r->w;
  1388.                 int h = r->h;
  1389.                 if ((w >= 800) && (h >= 600))
  1390.                 {
  1391.                     // make sure we don't add the same resolution multiple times!
  1392.                     if ( (mNumSupportedResolutions == 0) ||
  1393.                          ((mSupportedResolutions[mNumSupportedResolutions-1].mWidth != w) &&
  1394.                           (mSupportedResolutions[mNumSupportedResolutions-1].mHeight != h)) )
  1395.                     {
  1396.                         mSupportedResolutions[mNumSupportedResolutions].mWidth = w;
  1397.                         mSupportedResolutions[mNumSupportedResolutions].mHeight = h;
  1398.                         mNumSupportedResolutions++;
  1399.                     }
  1400.                 }
  1401.             }
  1402.         }
  1403. }
  1405. num_resolutions = mNumSupportedResolutions;
  1406. return mSupportedResolutions;
  1407. }
  1409. BOOL LLWindowSDL::convertCoords(LLCoordGL from, LLCoordWindow *to)
  1410. {
  1411.     if (!to)
  1412.         return FALSE;
  1414. to->mX = from.mX;
  1415. to->mY = mWindow->h - from.mY - 1;
  1417. return TRUE;
  1418. }
  1420. BOOL LLWindowSDL::convertCoords(LLCoordWindow from, LLCoordGL* to)
  1421. {
  1422.     if (!to)
  1423.         return FALSE;
  1425. to->mX = from.mX;
  1426. to->mY = mWindow->h - from.mY - 1;
  1428. return TRUE;
  1429. }
  1431. BOOL LLWindowSDL::convertCoords(LLCoordScreen from, LLCoordWindow* to)
  1432. {
  1433.     if (!to)
  1434. return FALSE;
  1436. // In the fullscreen case, window and screen coordinates are the same.
  1437. to->mX = from.mX;
  1438. to->mY = from.mY;
  1439.     return (TRUE);
  1440. }
  1442. BOOL LLWindowSDL::convertCoords(LLCoordWindow from, LLCoordScreen *to)
  1443. {
  1444.     if (!to)
  1445. return FALSE;
  1447. // In the fullscreen case, window and screen coordinates are the same.
  1448. to->mX = from.mX;
  1449. to->mY = from.mY;
  1450.     return (TRUE);
  1451. }
  1453. BOOL LLWindowSDL::convertCoords(LLCoordScreen from, LLCoordGL *to)
  1454. {
  1455. LLCoordWindow window_coord;
  1457. return(convertCoords(from, &window_coord) && convertCoords(window_coord, to));
  1458. }
  1460. BOOL LLWindowSDL::convertCoords(LLCoordGL from, LLCoordScreen *to)
  1461. {
  1462. LLCoordWindow window_coord;
  1464. return(convertCoords(from, &window_coord) && convertCoords(window_coord, to));
  1465. }
  1470. void LLWindowSDL::setupFailure(const std::string& text, const std::string& caption, U32 type)
  1471. {
  1472. destroyContext();
  1474. OSMessageBox(text, caption, type);
  1475. }
  1477. BOOL LLWindowSDL::SDLReallyCaptureInput(BOOL capture)
  1478. {
  1479. // note: this used to be safe to call nestedly, but in the
  1480. // end that's not really a wise usage pattern, so don't.
  1482. if (capture)
  1483. mReallyCapturedCount = 1;
  1484. else
  1485. mReallyCapturedCount = 0;
  1487. SDL_GrabMode wantmode, newmode;
  1488. if (mReallyCapturedCount <= 0) // uncapture
  1489. {
  1490. wantmode = SDL_GRAB_OFF;
  1491. } else // capture
  1492. {
  1493. wantmode = SDL_GRAB_ON;
  1494. }
  1496. if (mReallyCapturedCount < 0) // yuck, imbalance.
  1497. {
  1498. mReallyCapturedCount = 0;
  1499. llwarns << "ReallyCapture count was < 0" << llendl;
  1500. }
  1502. if (!mFullscreen) /* only bother if we're windowed anyway */
  1503. {
  1504. #if LL_X11
  1505. if (mSDL_Display)
  1506. {
  1507. /* we dirtily mix raw X11 with SDL so that our pointer
  1508.    isn't (as often) constrained to the limits of the
  1509.    window while grabbed, which feels nicer and
  1510.    hopefully eliminates some reported 'sticky pointer'
  1511.    problems.  We use raw X11 instead of
  1512.    SDL_WM_GrabInput() because the latter constrains
  1513.    the pointer to the window and also steals all
  1514.    *keyboard* input from the window manager, which was
  1515.    frustrating users. */
  1516. int result;
  1517. if (wantmode == SDL_GRAB_ON)
  1518. {
  1519. //llinfos << "X11 POINTER GRABBY" << llendl;
  1520. //newmode = SDL_WM_GrabInput(wantmode);
  1521. maybe_lock_display();
  1522. result = XGrabPointer(mSDL_Display, mSDL_XWindowID,
  1523.       True, 0, GrabModeAsync,
  1524.       GrabModeAsync,
  1525.       None, None, CurrentTime);
  1526. maybe_unlock_display();
  1527. if (GrabSuccess == result)
  1528. newmode = SDL_GRAB_ON;
  1529. else
  1530. newmode = SDL_GRAB_OFF;
  1531. } else if (wantmode == SDL_GRAB_OFF)
  1532. {
  1533. //llinfos << "X11 POINTER UNGRABBY" << llendl;
  1534. newmode = SDL_GRAB_OFF;
  1535. //newmode = SDL_WM_GrabInput(SDL_GRAB_OFF);
  1537. maybe_lock_display();
  1538. XUngrabPointer(mSDL_Display, CurrentTime);
  1539. // Make sure the ungrab happens RIGHT NOW.
  1540. XSync(mSDL_Display, False);
  1541. maybe_unlock_display();
  1542. } else
  1543. {
  1544. newmode = SDL_GRAB_QUERY; // neutral
  1545. }
  1546. } else // not actually running on X11, for some reason
  1547. newmode = wantmode;
  1548. #endif // LL_X11
  1549. } else {
  1550. // pretend we got what we wanted, when really we don't care.
  1551. newmode = wantmode;
  1552. }
  1554. // return boolean success for whether we ended up in the desired state
  1555. return (capture && SDL_GRAB_ON==newmode) ||
  1556. (!capture && SDL_GRAB_OFF==newmode);
  1557. }
  1559. U32 LLWindowSDL::SDLCheckGrabbyKeys(SDLKey keysym, BOOL gain)
  1560. {
  1561. /* part of the fix for SL-13243: Some popular window managers like
  1562.    to totally eat alt-drag for the purposes of moving windows.  We
  1563.    spoil their day by acquiring the exclusive X11 mouse lock for as
  1564.    long as ALT is held down, so the window manager can't easily
  1565.    see what's happening.  Tested successfully with Metacity.
  1566.    And... do the same with CTRL, for other darn WMs.  We don't
  1567.    care about other metakeys as SL doesn't use them with dragging
  1568.    (for now). */
  1570. /* We maintain a bitmap of critical keys which are up and down
  1571.    instead of simply key-counting, because SDL sometimes reports
  1572.    misbalanced keyup/keydown event pairs to us for whatever reason. */
  1574. U32 mask = 0;
  1575. switch (keysym)
  1576. {
  1577. case SDLK_LALT:
  1578. mask = 1U << 0; break;
  1579. case SDLK_RALT:
  1580. mask = 1U << 1; break;
  1581. case SDLK_LCTRL:
  1582. mask = 1U << 2; break;
  1583. case SDLK_RCTRL:
  1584. mask = 1U << 3; break;
  1585. default:
  1586. break;
  1587. }
  1589. if (gain)
  1590. mGrabbyKeyFlags |= mask;
  1591. else
  1592. mGrabbyKeyFlags &= ~mask;
  1594. //llinfos << "mGrabbyKeyFlags=" << mGrabbyKeyFlags << llendl;
  1596. /* 0 means we don't need to mousegrab, otherwise grab. */
  1597. return mGrabbyKeyFlags;
  1598. }
  1600. // virtual
  1601. void LLWindowSDL::processMiscNativeEvents()
  1602. {
  1603. #if LL_GTK
  1604. // Pump GTK events to avoid starvation for:
  1605. // * Embedded Gecko
  1606. // * DBUS servicing
  1607. // * Anything else which quietly hooks into the default glib/GTK loop
  1608.     if (ll_try_gtk_init())
  1609.     {
  1610.     // Yuck, Mozilla's GTK callbacks play with the locale - push/pop
  1611.     // the locale to protect it, as exotic/non-C locales
  1612.     // causes our code lots of general critical weirdness
  1613.     // and crashness. (SL-35450)
  1614.     static std::string saved_locale;
  1615.     saved_locale = ll_safe_string(setlocale(LC_ALL, NULL));
  1617.     // Pump until we've nothing left to do or passed 1/15th of a
  1618.     // second pumping for this frame.
  1619.     static LLTimer pump_timer;
  1620.     pump_timer.reset();
  1621.     pump_timer.setTimerExpirySec(1.0f / 15.0f);
  1622.     do {
  1623.      // Always do at least one non-blocking pump
  1624.     gtk_main_iteration_do(FALSE);
  1625.     } while (gtk_events_pending() &&
  1626.      !pump_timer.hasExpired());
  1628.     setlocale(LC_ALL, saved_locale.c_str() );
  1629.     }
  1630. #endif // LL_GTK
  1631. }
  1633. void LLWindowSDL::gatherInput()
  1634. {
  1635.     const Uint32 CLICK_THRESHOLD = 300;  // milliseconds
  1636.     static int leftClick = 0;
  1637.     static int rightClick = 0;
  1638.     static Uint32 lastLeftDown = 0;
  1639.     static Uint32 lastRightDown = 0;
  1640.     SDL_Event event;
  1642.     // Handle all outstanding SDL events
  1643.     while (SDL_PollEvent(&event))
  1644.     {
  1645.         switch (event.type)
  1646.         {
  1647.             case SDL_MOUSEMOTION:
  1648.             {
  1649.                 LLCoordWindow winCoord(event.button.x, event.button.y);
  1650.                 LLCoordGL openGlCoord;
  1651.                 convertCoords(winCoord, &openGlCoord);
  1652. MASK mask = gKeyboard->currentMask(TRUE);
  1653. mCallbacks->handleMouseMove(this, openGlCoord, mask);
  1654.                 break;
  1655.             }
  1657.             case SDL_KEYDOWN:
  1658.     mKeyScanCode = event.key.keysym.scancode;
  1659.     mKeyVirtualKey = event.key.keysym.unicode;
  1660.     mKeyModifiers = event.key.keysym.mod;
  1662.     gKeyboard->handleKeyDown(event.key.keysym.sym, event.key.keysym.mod);
  1663.     // part of the fix for SL-13243
  1664.     if (SDLCheckGrabbyKeys(event.key.keysym.sym, TRUE) != 0)
  1665.     SDLReallyCaptureInput(TRUE);
  1667.     if (event.key.keysym.unicode)
  1668.     {
  1669.     handleUnicodeUTF16(event.key.keysym.unicode,
  1670.        gKeyboard->currentMask(FALSE));
  1671.     }
  1672.                 break;
  1674.             case SDL_KEYUP:
  1675.     mKeyScanCode = event.key.keysym.scancode;
  1676.     mKeyVirtualKey = event.key.keysym.unicode;
  1677.     mKeyModifiers = event.key.keysym.mod;
  1679.     if (SDLCheckGrabbyKeys(event.key.keysym.sym, FALSE) == 0)
  1680.     SDLReallyCaptureInput(FALSE); // part of the fix for SL-13243
  1682.     gKeyboard->handleKeyUp(event.key.keysym.sym, event.key.keysym.mod);
  1683.     break;
  1685.             case SDL_MOUSEBUTTONDOWN:
  1686.             {
  1687.                 bool isDoubleClick = false;
  1688.                 LLCoordWindow winCoord(event.button.x, event.button.y);
  1689.                 LLCoordGL openGlCoord;
  1690.                 convertCoords(winCoord, &openGlCoord);
  1691. MASK mask = gKeyboard->currentMask(TRUE);
  1693.                 if (event.button.button == SDL_BUTTON_LEFT)   // SDL doesn't manage double clicking...
  1694.                 {
  1695.                     Uint32 now = SDL_GetTicks();
  1696.                     if ((now - lastLeftDown) > CLICK_THRESHOLD)
  1697.                         leftClick = 1;
  1698.                     else
  1699.                     {
  1700.                         if (++leftClick >= 2)
  1701.                         {
  1702.                             leftClick = 0;
  1703.     isDoubleClick = true;
  1704.                         }
  1705.                     }
  1706.                     lastLeftDown = now;
  1707.                 }
  1708.                 else if (event.button.button == SDL_BUTTON_RIGHT)
  1709.                 {
  1710.                     Uint32 now = SDL_GetTicks();
  1711.                     if ((now - lastRightDown) > CLICK_THRESHOLD)
  1712.                         rightClick = 1;
  1713.                     else
  1714.                     {
  1715.                         if (++rightClick >= 2)
  1716.                         {
  1717.                             rightClick = 0;
  1718.          isDoubleClick = true;
  1719.                         }
  1720.                     }
  1721.                     lastRightDown = now;
  1722.                 }
  1724.                 if (event.button.button == SDL_BUTTON_LEFT)  // left
  1725.                 {
  1726.                     if (isDoubleClick)
  1727.         mCallbacks->handleDoubleClick(this, openGlCoord, mask);
  1728.                     else
  1729.          mCallbacks->handleMouseDown(this, openGlCoord, mask);
  1730.                 }
  1732.                 else if (event.button.button == SDL_BUTTON_RIGHT)  // right
  1733.                 {
  1734. mCallbacks->handleRightMouseDown(this, openGlCoord, mask);
  1735.                 }
  1737.                 else if (event.button.button == SDL_BUTTON_MIDDLE)  // middle
  1738. {
  1739.     mCallbacks->handleMiddleMouseDown(this, openGlCoord, mask);
  1740. }
  1741.                 else if (event.button.button == 4)  // mousewheel up...thanks to X11 for making SDL consider these "buttons".
  1742. mCallbacks->handleScrollWheel(this, -1);
  1743.                 else if (event.button.button == 5)  // mousewheel down...thanks to X11 for making SDL consider these "buttons".
  1744. mCallbacks->handleScrollWheel(this, 1);
  1746.                 break;
  1747.             }
  1749.             case SDL_MOUSEBUTTONUP:
  1750.             {
  1751.                 LLCoordWindow winCoord(event.button.x, event.button.y);
  1752.                 LLCoordGL openGlCoord;
  1753.                 convertCoords(winCoord, &openGlCoord);
  1754. MASK mask = gKeyboard->currentMask(TRUE);
  1756.                 if (event.button.button == SDL_BUTTON_LEFT)  // left
  1757. mCallbacks->handleMouseUp(this, openGlCoord, mask);
  1758.                 else if (event.button.button == SDL_BUTTON_RIGHT)  // right
  1759. mCallbacks->handleRightMouseUp(this, openGlCoord, mask);
  1760.                 else if (event.button.button == SDL_BUTTON_MIDDLE)  // middle
  1761. mCallbacks->handleMiddleMouseUp(this, openGlCoord, mask);
  1762.                 // don't handle mousewheel here...
  1764.                 break;
  1765.             }
  1767.             case SDL_VIDEOEXPOSE:  // VIDEOEXPOSE doesn't specify the damage, but hey, it's OpenGL...repaint the whole thing!
  1768.     mCallbacks->handlePaint(this, 0, 0, mWindow->w, mWindow->h);
  1769.                 break;
  1771.             case SDL_VIDEORESIZE:  // *FIX: handle this?
  1772. llinfos << "Handling a resize event: " << event.resize.w <<
  1773. "x" << event.resize.h << llendl;
  1775. // *FIX: I'm not sure this is necessary!
  1776. mWindow = SDL_SetVideoMode(event.resize.w, event.resize.h, 32, mSDLFlags);
  1777. if (!mWindow)
  1778. {
  1779. // *FIX: More informative dialog?
  1780. llinfos << "Could not recreate context after resize! Quitting..." << llendl;
  1781. if(mCallbacks->handleCloseRequest(this))
  1782.      {
  1783.      // Get the app to initiate cleanup.
  1784.      mCallbacks->handleQuit(this);
  1785.      // The app is responsible for calling destroyWindow when done with GL
  1786.      }
  1787.                 break;
  1788. }
  1790. mCallbacks->handleResize(this, event.resize.w, event.resize.h );
  1791.                 break;
  1793.             case SDL_ACTIVEEVENT:
  1794.                 if (event.active.state & SDL_APPINPUTFOCUS)
  1795.                 {
  1796. // Note that for SDL (particularly on X11), keyboard
  1797. // and mouse focus are independent things.  Here we are
  1798. // tracking keyboard focus state changes.
  1800. // We have to do our own state massaging because SDL
  1801. // can send us two unfocus events in a row for example,
  1802. // which confuses the focus code [SL-24071].
  1803. if (event.active.gain != mHaveInputFocus)
  1804. {
  1805. mHaveInputFocus = !!event.active.gain;
  1807. if (mHaveInputFocus)
  1808. mCallbacks->handleFocus(this);
  1809. else
  1810. mCallbacks->handleFocusLost(this);
  1811. }
  1812.                 }
  1813.                 if (event.active.state & SDL_APPACTIVE)
  1814.                 {
  1815. // Change in iconification/minimization state.
  1816. if ((!event.active.gain) != mIsMinimized)
  1817. {
  1818. mIsMinimized = (!event.active.gain);
  1820. mCallbacks->handleActivate(this, !mIsMinimized);
  1821. llinfos << "SDL deiconification state switched to " << BOOL(event.active.gain) << llendl;
  1822. }
  1823. else
  1824. {
  1825. llinfos << "Ignored bogus redundant SDL deiconification state switch to " << BOOL(event.active.gain) << llendl;
  1826. }
  1827.                 }
  1828.                 break;
  1830.             case SDL_QUIT:
  1831.     if(mCallbacks->handleCloseRequest(this))
  1832.      {
  1833.      // Get the app to initiate cleanup.
  1834.      mCallbacks->handleQuit(this);
  1835.      // The app is responsible for calling destroyWindow when done with GL
  1836.      }
  1837.                 break;
  1838. default:
  1839. //llinfos << "Unhandled SDL event type " << event.type << llendl;
  1840. break;
  1841.         }
  1842.     }
  1844. #if LL_X11
  1845.     // This is a good time to stop flashing the icon if our mFlashTimer has
  1846.     // expired.
  1847.     if (mFlashing && mFlashTimer.hasExpired())
  1848.     {
  1849.     x11_set_urgent(FALSE);
  1850.     mFlashing = FALSE;
  1851.     }
  1852. #endif // LL_X11
  1853. }
  1855. static SDL_Cursor *makeSDLCursorFromBMP(const char *filename, int hotx, int hoty)
  1856. {
  1857. SDL_Cursor *sdlcursor = NULL;
  1858. SDL_Surface *bmpsurface;
  1860. // Load cursor pixel data from BMP file
  1861. bmpsurface = Load_BMP_Resource(filename);
  1862. if (bmpsurface && bmpsurface->w%8==0)
  1863. {
  1864. SDL_Surface *cursurface;
  1865. lldebugs << "Loaded cursor file " << filename << " "
  1866.  << bmpsurface->w << "x" << bmpsurface->h << llendl;
  1867. cursurface = SDL_CreateRGBSurface (SDL_SWSURFACE,
  1868.    bmpsurface->w,
  1869.    bmpsurface->h,
  1870.    32,
  1871.    SDL_SwapLE32(0xFFU),
  1872.    SDL_SwapLE32(0xFF00U),
  1873.    SDL_SwapLE32(0xFF0000U),
  1874.    SDL_SwapLE32(0xFF000000U));
  1875. SDL_FillRect(cursurface, NULL, SDL_SwapLE32(0x00000000U));
  1877. // Blit the cursor pixel data onto a 32-bit RGBA surface so we
  1878. // only have to cope with processing one type of pixel format.
  1879. if (0 == SDL_BlitSurface(bmpsurface, NULL,
  1880.  cursurface, NULL))
  1881. {
  1882. // n.b. we already checked that width is a multiple of 8.
  1883. const int bitmap_bytes = (cursurface->w * cursurface->h) / 8;
  1884. unsigned char *cursor_data = new unsigned char[bitmap_bytes];
  1885. unsigned char *cursor_mask = new unsigned char[bitmap_bytes];
  1886. memset(cursor_data, 0, bitmap_bytes);
  1887. memset(cursor_mask, 0, bitmap_bytes);
  1888. int i,j;
  1889. // Walk the RGBA cursor pixel data, extracting both data and
  1890. // mask to build SDL-friendly cursor bitmaps from.  The mask
  1891. // is inferred by color-keying against 200,200,200
  1892. for (i=0; i<cursurface->h; ++i) {
  1893. for (j=0; j<cursurface->w; ++j) {
  1894. U8 *pixelp =
  1895. ((U8*)cursurface->pixels)
  1896. + cursurface->pitch * i
  1897. + j*cursurface->format->BytesPerPixel;
  1898. U8 srcred = pixelp[0];
  1899. U8 srcgreen = pixelp[1];
  1900. U8 srcblue = pixelp[2];
  1901. BOOL mask_bit = (srcred != 200)
  1902. || (srcgreen != 200)
  1903. || (srcblue != 200);
  1904. BOOL data_bit = mask_bit && (srcgreen <= 80);//not 0x80
  1905. unsigned char bit_offset = (cursurface->w/8) * i
  1906. + j/8;
  1907. cursor_data[bit_offset] |= (data_bit) << (7 - (j&7));
  1908. cursor_mask[bit_offset] |= (mask_bit) << (7 - (j&7));
  1909. }
  1910. }
  1911. sdlcursor = SDL_CreateCursor((Uint8*)cursor_data,
  1912.      (Uint8*)cursor_mask,
  1913.      cursurface->w, cursurface->h,
  1914.      hotx, hoty);
  1915. delete[] cursor_data;
  1916. delete[] cursor_mask;
  1917. } else {
  1918. llwarns << "CURSOR BLIT FAILURE, cursurface: " << cursurface << llendl;
  1919. }
  1920. SDL_FreeSurface(cursurface);
  1921. SDL_FreeSurface(bmpsurface);
  1922. } else {
  1923. llwarns << "CURSOR LOAD FAILURE " << filename << llendl;
  1924. }
  1926. return sdlcursor;
  1927. }
  1929. void LLWindowSDL::setCursor(ECursorType cursor)
  1930. {
  1931. if (ATIbug) {
  1932. // cursor-updating is very flaky when this bug is
  1933. // present; do nothing.
  1934. return;
  1935. }
  1937. if (mCurrentCursor != cursor)
  1938. {
  1939. if (cursor < UI_CURSOR_COUNT)
  1940. {
  1941. SDL_Cursor *sdlcursor = mSDLCursors[cursor];
  1942. // Try to default to the arrow for any cursors that
  1943. // did not load correctly.
  1944. if (!sdlcursor && mSDLCursors[UI_CURSOR_ARROW])
  1945. sdlcursor = mSDLCursors[UI_CURSOR_ARROW];
  1946. if (sdlcursor)
  1947. SDL_SetCursor(sdlcursor);
  1948. } else {
  1949. llwarns << "Tried to set invalid cursor number " << cursor << llendl;
  1950. }
  1951. mCurrentCursor = cursor;
  1952. }
  1953. }
  1955. void LLWindowSDL::initCursors()
  1956. {
  1957. int i;
  1958. // Blank the cursor pointer array for those we may miss.
  1959. for (i=0; i<UI_CURSOR_COUNT; ++i)
  1960. {
  1961. mSDLCursors[i] = NULL;
  1962. }
  1963. // Pre-make an SDL cursor for each of the known cursor types.
  1964. // We hardcode the hotspots - to avoid that we'd have to write
  1965. // a .cur file loader.
  1966. // NOTE: SDL doesn't load RLE-compressed BMP files.
  1967. mSDLCursors[UI_CURSOR_ARROW] = makeSDLCursorFromBMP("llarrow.BMP",0,0);
  1968. mSDLCursors[UI_CURSOR_WAIT] = makeSDLCursorFromBMP("wait.BMP",12,15);
  1969. mSDLCursors[UI_CURSOR_HAND] = makeSDLCursorFromBMP("hand.BMP",7,10);
  1970. mSDLCursors[UI_CURSOR_IBEAM] = makeSDLCursorFromBMP("ibeam.BMP",15,16);
  1971. mSDLCursors[UI_CURSOR_CROSS] = makeSDLCursorFromBMP("cross.BMP",16,14);
  1972. mSDLCursors[UI_CURSOR_SIZENWSE] = makeSDLCursorFromBMP("sizenwse.BMP",14,17);
  1973. mSDLCursors[UI_CURSOR_SIZENESW] = makeSDLCursorFromBMP("sizenesw.BMP",17,17);
  1974. mSDLCursors[UI_CURSOR_SIZEWE] = makeSDLCursorFromBMP("sizewe.BMP",16,14);
  1975. mSDLCursors[UI_CURSOR_SIZENS] = makeSDLCursorFromBMP("sizens.BMP",17,16);
  1976. mSDLCursors[UI_CURSOR_NO] = makeSDLCursorFromBMP("llno.BMP",8,8);
  1977. mSDLCursors[UI_CURSOR_WORKING] = makeSDLCursorFromBMP("working.BMP",12,15);
  1978. mSDLCursors[UI_CURSOR_TOOLGRAB] = makeSDLCursorFromBMP("lltoolgrab.BMP",2,13);
  1979. mSDLCursors[UI_CURSOR_TOOLLAND] = makeSDLCursorFromBMP("lltoolland.BMP",1,6);
  1980. mSDLCursors[UI_CURSOR_TOOLFOCUS] = makeSDLCursorFromBMP("lltoolfocus.BMP",8,5);
  1981. mSDLCursors[UI_CURSOR_TOOLCREATE] = makeSDLCursorFromBMP("lltoolcreate.BMP",7,7);
  1982. mSDLCursors[UI_CURSOR_ARROWDRAG] = makeSDLCursorFromBMP("arrowdrag.BMP",0,0);
  1983. mSDLCursors[UI_CURSOR_ARROWCOPY] = makeSDLCursorFromBMP("arrowcop.BMP",0,0);
  1984. mSDLCursors[UI_CURSOR_ARROWDRAGMULTI] = makeSDLCursorFromBMP("llarrowdragmulti.BMP",0,0);
  1985. mSDLCursors[UI_CURSOR_ARROWCOPYMULTI] = makeSDLCursorFromBMP("arrowcopmulti.BMP",0,0);
  1986. mSDLCursors[UI_CURSOR_NOLOCKED] = makeSDLCursorFromBMP("llnolocked.BMP",8,8);
  1987. mSDLCursors[UI_CURSOR_ARROWLOCKED] = makeSDLCursorFromBMP("llarrowlocked.BMP",0,0);
  1988. mSDLCursors[UI_CURSOR_GRABLOCKED] = makeSDLCursorFromBMP("llgrablocked.BMP",2,13);
  1989. mSDLCursors[UI_CURSOR_TOOLTRANSLATE] = makeSDLCursorFromBMP("lltooltranslate.BMP",0,0);
  1990. mSDLCursors[UI_CURSOR_TOOLROTATE] = makeSDLCursorFromBMP("lltoolrotate.BMP",0,0);
  1991. mSDLCursors[UI_CURSOR_TOOLSCALE] = makeSDLCursorFromBMP("lltoolscale.BMP",0,0);
  1992. mSDLCursors[UI_CURSOR_TOOLCAMERA] = makeSDLCursorFromBMP("lltoolcamera.BMP",7,5);
  1993. mSDLCursors[UI_CURSOR_TOOLPAN] = makeSDLCursorFromBMP("lltoolpan.BMP",7,5);
  1994. mSDLCursors[UI_CURSOR_TOOLZOOMIN] = makeSDLCursorFromBMP("lltoolzoomin.BMP",7,5);
  1995. mSDLCursors[UI_CURSOR_TOOLPICKOBJECT3] = makeSDLCursorFromBMP("toolpickobject3.BMP",0,0);
  1996. mSDLCursors[UI_CURSOR_TOOLPLAY] = makeSDLCursorFromBMP("toolplay.BMP",0,0);
  1997. mSDLCursors[UI_CURSOR_TOOLPAUSE] = makeSDLCursorFromBMP("toolpause.BMP",0,0);
  1998. mSDLCursors[UI_CURSOR_TOOLMEDIAOPEN] = makeSDLCursorFromBMP("toolmediaopen.BMP",0,0);
  1999. mSDLCursors[UI_CURSOR_PIPETTE] = makeSDLCursorFromBMP("lltoolpipette.BMP",2,28);
  2001. if (getenv("LL_ATI_MOUSE_CURSOR_BUG") != NULL) {
  2002. llinfos << "Disabling cursor updating due to LL_ATI_MOUSE_CURSOR_BUG" << llendl;
  2003. ATIbug = true;
  2004. }
  2005. }
  2007. void LLWindowSDL::quitCursors()
  2008. {
  2009. int i;
  2010. if (mWindow)
  2011. {
  2012. for (i=0; i<UI_CURSOR_COUNT; ++i)
  2013. {
  2014. if (mSDLCursors[i])
  2015. {
  2016. SDL_FreeCursor(mSDLCursors[i]);
  2017. mSDLCursors[i] = NULL;
  2018. }
  2019. }
  2020. } else {
  2021. // SDL doesn't refcount cursors, so if the window has
  2022. // already been destroyed then the cursors have gone with it.
  2023. llinfos << "Skipping quitCursors: mWindow already gone." << llendl;
  2024. for (i=0; i<UI_CURSOR_COUNT; ++i)
  2025. mSDLCursors[i] = NULL;
  2026. }
  2027. }
  2029. void LLWindowSDL::captureMouse()
  2030. {
  2031. // SDL already enforces the semantics that captureMouse is
  2032. // used for, i.e. that we continue to get mouse events as long
  2033. // as a button is down regardless of whether we left the
  2034. // window, and in a less obnoxious way than SDL_WM_GrabInput
  2035. // which would confine the cursor to the window too.
  2037. lldebugs << "LLWindowSDL::captureMouse" << llendl;
  2038. }
  2040. void LLWindowSDL::releaseMouse()
  2041. {
  2042. // see LWindowSDL::captureMouse()
  2044. lldebugs << "LLWindowSDL::releaseMouse" << llendl;
  2045. }
  2047. void LLWindowSDL::hideCursor()
  2048. {
  2049. if(!mCursorHidden)
  2050. {
  2051. // llinfos << "hideCursor: hiding" << llendl;
  2052. mCursorHidden = TRUE;
  2053. mHideCursorPermanent = TRUE;
  2054. SDL_ShowCursor(0);
  2055. }
  2056. else
  2057. {
  2058. // llinfos << "hideCursor: already hidden" << llendl;
  2059. }
  2060. }
  2062. void LLWindowSDL::showCursor()
  2063. {
  2064. if(mCursorHidden)
  2065. {
  2066. // llinfos << "showCursor: showing" << llendl;
  2067. mCursorHidden = FALSE;
  2068. mHideCursorPermanent = FALSE;
  2069. SDL_ShowCursor(1);
  2070. }
  2071. else
  2072. {
  2073. // llinfos << "showCursor: already visible" << llendl;
  2074. }
  2075. }
  2077. void LLWindowSDL::showCursorFromMouseMove()
  2078. {
  2079. if (!mHideCursorPermanent)
  2080. {
  2081. showCursor();
  2082. }
  2083. }
  2085. void LLWindowSDL::hideCursorUntilMouseMove()
  2086. {
  2087. if (!mHideCursorPermanent)
  2088. {
  2089. hideCursor();
  2090. mHideCursorPermanent = FALSE;
  2091. }
  2092. }
  2096. //
  2097. // LLSplashScreenSDL - I don't think we'll bother to implement this; it's
  2098. // fairly obsolete at this point.
  2099. //
  2100. LLSplashScreenSDL::LLSplashScreenSDL()
  2101. {
  2102. }
  2104. LLSplashScreenSDL::~LLSplashScreenSDL()
  2105. {
  2106. }
  2108. void LLSplashScreenSDL::showImpl()
  2109. {
  2110. }
  2112. void LLSplashScreenSDL::updateImpl(const std::string& mesg)
  2113. {
  2114. }
  2116. void LLSplashScreenSDL::hideImpl()
  2117. {
  2118. }
  2122. #if LL_GTK
  2123. static void response_callback (GtkDialog *dialog,
  2124.        gint       arg1,
  2125.        gpointer   user_data)
  2126. {
  2127. gint *response = (gint*)user_data;
  2128. *response = arg1;
  2129. gtk_widget_destroy(GTK_WIDGET(dialog));
  2130. gtk_main_quit();
  2131. }
  2133. S32 OSMessageBoxSDL(const std::string& text, const std::string& caption, U32 type)
  2134. {
  2135. S32 rtn = OSBTN_CANCEL;
  2137. if(gWindowImplementation != NULL)
  2138. gWindowImplementation->beforeDialog();
  2140. if (LLWindowSDL::ll_try_gtk_init())
  2141. {
  2142. GtkWidget *win = NULL;
  2144. llinfos << "Creating a dialog because we're in windowed mode and GTK is happy." << llendl;
  2146. GtkDialogFlags flags = GTK_DIALOG_MODAL;
  2147. GtkMessageType messagetype;
  2148. GtkButtonsType buttons;
  2149. switch (type)
  2150. {
  2151. default:
  2152. case OSMB_OK:
  2153. messagetype = GTK_MESSAGE_WARNING;
  2154. buttons = GTK_BUTTONS_OK;
  2155. break;
  2156. case OSMB_OKCANCEL:
  2157. messagetype = GTK_MESSAGE_QUESTION;
  2158. buttons = GTK_BUTTONS_OK_CANCEL;
  2159. break;
  2160. case OSMB_YESNO:
  2161. messagetype = GTK_MESSAGE_QUESTION;
  2162. buttons = GTK_BUTTONS_YES_NO;
  2163. break;
  2164. }
  2165. win = gtk_message_dialog_new(NULL, flags, messagetype, buttons, "%s",
  2166.  text.c_str());
  2168. # if LL_X11
  2169. // Make GTK tell the window manager to associate this
  2170. // dialog with our non-GTK SDL window, which should try
  2171. // to keep it on top etc.
  2172. if (gWindowImplementation &&
  2173.     gWindowImplementation->mSDL_XWindowID != None)
  2174. {
  2175. gtk_widget_realize(GTK_WIDGET(win)); // so we can get its gdkwin
  2176. GdkWindow *gdkwin = gdk_window_foreign_new(gWindowImplementation->mSDL_XWindowID);
  2177. gdk_window_set_transient_for(GTK_WIDGET(win)->window,
  2178.      gdkwin);
  2179. }
  2180. # endif //LL_X11
  2182. gtk_window_set_position(GTK_WINDOW(win),
  2183. GTK_WIN_POS_CENTER_ON_PARENT);
  2185. gtk_window_set_type_hint(GTK_WINDOW(win),
  2186.  GDK_WINDOW_TYPE_HINT_DIALOG);
  2188. if (!caption.empty())
  2189. gtk_window_set_title(GTK_WINDOW(win), caption.c_str());
  2191. gint response = GTK_RESPONSE_NONE;
  2192. g_signal_connect (win,
  2193.   "response", 
  2194.   G_CALLBACK (response_callback),
  2195.   &response);
  2197. // we should be able to use a gtk_dialog_run(), but it's
  2198. // apparently not written to exist in a world without a higher
  2199. // gtk_main(), so we manage its signal/destruction outselves.
  2200. gtk_widget_show_all (win);
  2201. gtk_main();
  2203. //llinfos << "response: " << response << llendl;
  2204. switch (response)
  2205. {
  2206. case GTK_RESPONSE_OK:     rtn = OSBTN_OK; break;
  2207. case GTK_RESPONSE_YES:    rtn = OSBTN_YES; break;
  2208. case GTK_RESPONSE_NO:     rtn = OSBTN_NO; break;
  2209. case GTK_RESPONSE_APPLY:  rtn = OSBTN_OK; break;
  2210. case GTK_RESPONSE_NONE:
  2211. case GTK_RESPONSE_CANCEL:
  2212. case GTK_RESPONSE_CLOSE:
  2213. case GTK_RESPONSE_DELETE_EVENT:
  2214. default: rtn = OSBTN_CANCEL;
  2215. }
  2216. }
  2217. else
  2218. {
  2219. llinfos << "MSGBOX: " << caption << ": " << text << llendl;
  2220. llinfos << "Skipping dialog because we're in fullscreen mode or GTK is not happy." << llendl;
  2221. rtn = OSBTN_OK;
  2222. }
  2224. if(gWindowImplementation != NULL)
  2225. gWindowImplementation->afterDialog();
  2227. return rtn;
  2228. }
  2230. static void color_changed_callback(GtkWidget *widget,
  2231.    gpointer user_data)
  2232. {
  2233. GtkColorSelection *colorsel = GTK_COLOR_SELECTION(widget);
  2234. GdkColor *colorp = (GdkColor*)user_data;
  2236. gtk_color_selection_get_current_color(colorsel, colorp);
  2237. }
  2240. /*
  2241.         Make the raw keyboard data available - used to poke through to LLQtWebKit so
  2242.         that Qt/Webkit has access to the virtual keycodes etc. that it needs
  2243. */
  2244. LLSD LLWindowSDL::getNativeKeyData()
  2245. {
  2246.         LLSD result = LLSD::emptyMap();
  2248. U32 modifiers = 0; // pretend-native modifiers... oh what a tangled web we weave!
  2250. // we go through so many levels of device abstraction that I can't really guess
  2251. // what a plugin under GDK under Qt under SL under SDL under X11 considers
  2252. // a 'native' modifier mask.  this has been sort of reverse-engineered... they *appear*
  2253. // to match GDK consts, but that may be co-incidence.
  2254. modifiers |= (mKeyModifiers & KMOD_LSHIFT) ? 0x0001 : 0;
  2255. modifiers |= (mKeyModifiers & KMOD_RSHIFT) ? 0x0001 : 0;// munge these into the same shift
  2256. modifiers |= (mKeyModifiers & KMOD_CAPS)   ? 0x0002 : 0;
  2257. modifiers |= (mKeyModifiers & KMOD_LCTRL)  ? 0x0004 : 0;
  2258. modifiers |= (mKeyModifiers & KMOD_RCTRL)  ? 0x0004 : 0;// munge these into the same ctrl
  2259. modifiers |= (mKeyModifiers & KMOD_LALT)   ? 0x0008 : 0;// untested
  2260. modifiers |= (mKeyModifiers & KMOD_RALT)   ? 0x0008 : 0;// untested
  2261. // *todo: test ALTs - I don't have a case for testing these.  Do you?
  2262. // *todo: NUM? - I don't care enough right now (and it's not a GDK modifier).
  2264.         result["scan_code"] = (S32)mKeyScanCode;
  2265.         result["virtual_key"] = (S32)mKeyVirtualKey;
  2266. result["modifiers"] = (S32)modifiers;
  2268.         return result;
  2269. }
  2272. BOOL LLWindowSDL::dialogColorPicker( F32 *r, F32 *g, F32 *b)
  2273. {
  2274. BOOL rtn = FALSE;
  2276. beforeDialog();
  2278. if (ll_try_gtk_init())
  2279. {
  2280. GtkWidget *win = NULL;
  2282. win = gtk_color_selection_dialog_new(NULL);
  2284. # if LL_X11
  2285. // Get GTK to tell the window manager to associate this
  2286. // dialog with our non-GTK SDL window, which should try
  2287. // to keep it on top etc.
  2288. if (mSDL_XWindowID != None)
  2289. {
  2290. gtk_widget_realize(GTK_WIDGET(win)); // so we can get its gdkwin
  2291. GdkWindow *gdkwin = gdk_window_foreign_new(mSDL_XWindowID);
  2292. gdk_window_set_transient_for(GTK_WIDGET(win)->window,
  2293.      gdkwin);
  2294. }
  2295. # endif //LL_X11
  2297. GtkColorSelection *colorsel = GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG(win)->colorsel);
  2299. GdkColor color, orig_color;
  2300. orig_color.pixel = 0;
  2301. orig_color.red = guint16(65535 * *r);
  2302. orig_color.green= guint16(65535 * *g);
  2303. orig_color.blue = guint16(65535 * *b);
  2304. color = orig_color;
  2306. gtk_color_selection_set_previous_color (colorsel, &color);
  2307. gtk_color_selection_set_current_color (colorsel, &color);
  2308. gtk_color_selection_set_has_palette (colorsel, TRUE);
  2309. gtk_color_selection_set_has_opacity_control(colorsel, FALSE);
  2311. gint response = GTK_RESPONSE_NONE;
  2312. g_signal_connect (win,
  2313.   "response", 
  2314.   G_CALLBACK (response_callback),
  2315.   &response);
  2317. g_signal_connect (G_OBJECT (colorsel), "color_changed",
  2318.   G_CALLBACK (color_changed_callback),
  2319.   &color);
  2321. gtk_window_set_modal(GTK_WINDOW(win), TRUE);
  2322. gtk_widget_show_all(win);
  2323. // hide the help button - we don't service it.
  2324. gtk_widget_hide(GTK_COLOR_SELECTION_DIALOG(win)->help_button);
  2325. gtk_main();
  2327. if (response == GTK_RESPONSE_OK &&
  2328.     (orig_color.red != color.red
  2329.      || orig_color.green != color.green
  2330.      || orig_color.blue != color.blue) )
  2331. {
  2332. *r = color.red / 65535.0f;
  2333. *g = color.green / 65535.0f;
  2334. *b = color.blue / 65535.0f;
  2335. rtn = TRUE;
  2336. }
  2337. }
  2339. afterDialog();
  2341. return rtn;
  2342. }
  2343. #else
  2344. S32 OSMessageBoxSDL(const std::string& text, const std::string& caption, U32 type)
  2345. {
  2346. llinfos << "MSGBOX: " << caption << ": " << text << llendl;
  2347. return 0;
  2348. }
  2350. BOOL LLWindowSDL::dialogColorPicker( F32 *r, F32 *g, F32 *b)
  2351. {
  2352. return (FALSE);
  2353. }
  2354. #endif // LL_GTK
  2356. #if LL_LINUX || LL_SOLARIS
  2357. // extracted from spawnWebBrowser for clarity and to eliminate
  2358. //  compiler confusion regarding close(int fd) vs. LLWindow::close()
  2359. void exec_cmd(const std::string& cmd, const std::string& arg)
  2360. {
  2361. char* const argv[] = {(char*)cmd.c_str(), (char*)arg.c_str(), NULL};
  2362. fflush(NULL);
  2363. pid_t pid = fork();
  2364. if (pid == 0)
  2365. { // child
  2366. // disconnect from stdin/stdout/stderr, or child will
  2367. // keep our output pipe undesirably alive if it outlives us.
  2368. close(0);
  2369. close(1);
  2370. close(2);
  2371. // end ourself by running the command
  2372. execv(cmd.c_str(), argv); /* Flawfinder: ignore */
  2373. // if execv returns at all, there was a problem.
  2374. llwarns << "execv failure when trying to start " << cmd << llendl;
  2375. _exit(1); // _exit because we don't want atexit() clean-up!
  2376. } else {
  2377. if (pid > 0)
  2378. {
  2379. // parent - wait for child to die
  2380. int childExitStatus;
  2381. waitpid(pid, &childExitStatus, 0);
  2382. } else {
  2383. llwarns << "fork failure." << llendl;
  2384. }
  2385. }
  2386. }
  2387. #endif
  2389. // Open a URL with the user's default web browser.
  2390. // Must begin with protocol identifier.
  2391. void LLWindowSDL::spawnWebBrowser(const std::string& escaped_url)
  2392. {
  2393. llinfos << "spawn_web_browser: " << escaped_url << llendl;
  2395. #if LL_LINUX || LL_SOLARIS
  2396. # if LL_X11
  2397. if (mSDL_Display)
  2398. {
  2399. maybe_lock_display();
  2400. // Just in case - before forking.
  2401. XSync(mSDL_Display, False);
  2402. maybe_unlock_display();
  2403. }
  2404. # endif // LL_X11
  2406. std::string cmd, arg;
  2407. cmd  = gDirUtilp->getAppRODataDir();
  2408. cmd += gDirUtilp->getDirDelimiter();
  2409. cmd += "etc";
  2410. cmd += gDirUtilp->getDirDelimiter();
  2411. cmd += "launch_url.sh";
  2412. arg = escaped_url;
  2413. exec_cmd(cmd, arg);
  2414. #endif // LL_LINUX || LL_SOLARIS
  2416. llinfos << "spawn_web_browser returning." << llendl;
  2417. }
  2420. void *LLWindowSDL::getPlatformWindow()
  2421. {
  2422. #if LL_GTK && LL_LLMOZLIB_ENABLED
  2423. if (LLWindowSDL::ll_try_gtk_init())
  2424. {
  2425. maybe_lock_display();
  2427. GtkWidget *owin = gtk_window_new(GTK_WINDOW_POPUP);
  2428. // Why a layout widget?  A MozContainer would be ideal, but
  2429. // it involves exposing Mozilla headers to mozlib-using apps.
  2430. // A layout widget with a GtkWindow parent has the desired
  2431. // properties of being plain GTK, having a window, and being
  2432. // derived from a GtkContainer.
  2433. GtkWidget *rtnw = gtk_layout_new(NULL, NULL);
  2434. gtk_container_add(GTK_CONTAINER(owin), rtnw);
  2435. gtk_widget_realize(rtnw);
  2436. GTK_WIDGET_UNSET_FLAGS(GTK_WIDGET(rtnw), GTK_NO_WINDOW);
  2438. maybe_unlock_display();
  2440. return rtnw;
  2441. }
  2442. #endif // LL_GTK && LL_LLMOZLIB_ENABLED
  2443. // Unixoid mozilla really needs GTK.
  2444. return NULL;
  2445. }
  2447. void LLWindowSDL::bringToFront()
  2448. {
  2449. // This is currently used when we are 'launched' to a specific
  2450. // map position externally.
  2451. llinfos << "bringToFront" << llendl;
  2452. #if LL_X11
  2453. if (mSDL_Display && !mFullscreen)
  2454. {
  2455. maybe_lock_display();
  2456. XRaiseWindow(mSDL_Display, mSDL_XWindowID);
  2457. XSync(mSDL_Display, False);
  2458. maybe_unlock_display();
  2459. }
  2460. #endif // LL_X11
  2461. }
  2463. //static
  2464. std::vector<std::string> LLWindowSDL::getDynamicFallbackFontList()
  2465. {
  2466. // Use libfontconfig to find us a nice ordered list of fallback fonts
  2467. // specific to this system.
  2468. std::string final_fallback("/usr/share/fonts/truetype/kochi/kochi-gothic.ttf");
  2469. // Our 'ideal' font properties which define the sorting results.
  2470. // slant=0 means Roman, index=0 means the first face in a font file
  2471. // (the one we actually use), weight=80 means medium weight,
  2472. // spacing=0 means proportional spacing.
  2473. std::string sort_order("slant=0:index=0:weight=80:spacing=0");
  2474. // elide_unicode_coverage removes fonts from the list whose unicode
  2475. // range is covered by fonts earlier in the list.  This usually
  2476. // removes ~90% of the fonts as redundant (which is great because
  2477. // the font list can be huge), but might unnecessarily reduce the
  2478. // renderable range if for some reason our FreeType actually fails
  2479. // to use some of the fonts we want it to.
  2480. const bool elide_unicode_coverage = true;
  2481. std::vector<std::string> rtns;
  2482. FcFontSet *fs = NULL;
  2483. FcPattern *sortpat = NULL;
  2484. int font_count = 0;
  2486. llinfos << "Getting system font list from FontConfig..." << llendl;
  2488. // If the user has a system-wide language preference, then favor
  2489. // fonts from that language group.  This doesn't affect the types
  2490. // of languages that can be displayed, but ensures that their
  2491. // preferred language is rendered from a single consistent font where
  2492. // possible.
  2493. FL_Locale *locale = NULL;
  2494. FL_Success success = FL_FindLocale(&locale, FL_MESSAGES);
  2495. if (success != 0)
  2496. {
  2497. if (success >= 2 && locale->lang) // confident!
  2498. {
  2499. LL_INFOS("AppInit") << "Language " << locale->lang << LL_ENDL;
  2500. LL_INFOS("AppInit") << "Location " << locale->country << LL_ENDL;
  2501. LL_INFOS("AppInit") << "Variant " << locale->variant << LL_ENDL;
  2503. llinfos << "Preferring fonts of language: "
  2504. << locale->lang
  2505. << llendl;
  2506. sort_order = "lang=" + std::string(locale->lang) + ":"
  2507. + sort_order;
  2508. }
  2509. }
  2510. FL_FreeLocale(&locale);
  2512. if (!FcInit())
  2513. {
  2514. llwarns << "FontConfig failed to initialize." << llendl;
  2515. rtns.push_back(final_fallback);
  2516. return rtns;
  2517. }
  2519. sortpat = FcNameParse((FcChar8*) sort_order.c_str());
  2520. if (sortpat)
  2521. {
  2522. // Sort the list of system fonts from most-to-least-desirable.
  2523. fs = FcFontSort(NULL, sortpat, elide_unicode_coverage,
  2524. NULL, NULL);
  2525. FcPatternDestroy(sortpat);
  2526. }
  2528. if (fs)
  2529. {
  2530. // Get the full pathnames to the fonts, where available,
  2531. // which is what we really want.
  2532. int i;
  2533. for (i=0; i<fs->nfont; ++i)
  2534. {
  2535. FcChar8 *filename;
  2536. if (FcResultMatch == FcPatternGetString(fs->fonts[i],
  2537. FC_FILE, 0,
  2538. &filename)
  2539.     && filename)
  2540. {
  2541. rtns.push_back(std::string((const char*)filename));
  2542. ++font_count;
  2543. }
  2544. }
  2545. FcFontSetDestroy (fs);
  2546. }
  2548. lldebugs << "Using font list: " << llendl;
  2549. for (std::vector<std::string>::iterator it = rtns.begin();
  2550.  it != rtns.end();
  2551.  ++it)
  2552. {
  2553. lldebugs << "  file: " << *it << llendl;
  2554. }
  2555. llinfos << "Using " << font_count << " system font(s)." << llendl;
  2557. rtns.push_back(final_fallback);
  2558. return rtns;
  2559. }
  2561. #endif // LL_SDL