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

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

游戏引擎

开发平台：

C++ Builder

llfilepicker.cpp：源码内容
  1. /** 
  2.  * @file llfilepicker.cpp
  3.  * @brief OS-specific file picker
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "llviewerprecompiledheaders.h"
  35. #include "llfilepicker.h"
  36. #include "llworld.h"
  37. #include "llviewerwindow.h"
  38. #include "llkeyboard.h"
  39. #include "lldir.h"
  40. #include "llframetimer.h"
  41. #include "lltrans.h"
  42. #include "llwindow.h" // beforeDialog()
  44. #if LL_SDL
  45. #include "llwindowsdl.h" // for some X/GTK utils to help with filepickers
  46. #endif // LL_SDL
  48. //
  49. // Globals
  50. //
  52. LLFilePicker LLFilePicker::sInstance;
  54. #if LL_WINDOWS
  55. #define SOUND_FILTER L"Sounds (*.wav)*.wav"
  56. #define IMAGE_FILTER L"Images (*.tga; *.bmp; *.jpg; *.jpeg; *.png)*.tga;*.bmp;*.jpg;*.jpeg;*.png"
  57. #define ANIM_FILTER L"Animations (*.bvh)*.bvh"
  58. #ifdef _CORY_TESTING
  59. #define GEOMETRY_FILTER L"SL Geometry (*.slg)*.slg"
  60. #endif
  61. #define XML_FILTER L"XML files (*.xml)*.xml"
  62. #define SLOBJECT_FILTER L"Objects (*.slobject)*.slobject"
  63. #define RAW_FILTER L"RAW files (*.raw)*.raw"
  64. #endif
  66. //
  67. // Implementation
  68. //
  69. LLFilePicker::LLFilePicker()
  70. : mCurrentFile(0),
  71.   mLocked(false)
  73. {
  74. reset();
  76. #if LL_WINDOWS
  77. mOFN.lStructSize = sizeof(OPENFILENAMEW);
  78. mOFN.hwndOwner = NULL;  // Set later
  79. mOFN.hInstance = NULL;
  80. mOFN.lpstrCustomFilter = NULL;
  81. mOFN.nMaxCustFilter = 0;
  82. mOFN.lpstrFile = NULL; // set in open and close
  83. mOFN.nMaxFile = LL_MAX_PATH;
  84. mOFN.lpstrFileTitle = NULL;
  85. mOFN.nMaxFileTitle = 0;
  86. mOFN.lpstrInitialDir = NULL;
  87. mOFN.lpstrTitle = NULL;
  88. mOFN.Flags = 0; // set in open and close
  89. mOFN.nFileOffset = 0;
  90. mOFN.nFileExtension = 0;
  91. mOFN.lpstrDefExt = NULL;
  92. mOFN.lCustData = 0L;
  93. mOFN.lpfnHook = NULL;
  94. mOFN.lpTemplateName = NULL;
  95. mFilesW[0] = '';
  96. #endif
  98. #if LL_DARWIN
  99. memset(&mNavOptions, 0, sizeof(mNavOptions));
  100. OSStatus error = NavGetDefaultDialogCreationOptions(&mNavOptions);
  101. if (error == noErr)
  102. {
  103. mNavOptions.modality = kWindowModalityAppModal;
  104. }
  105. #endif
  106. }
  108. LLFilePicker::~LLFilePicker()
  109. {
  110. // nothing
  111. }
  114. const std::string LLFilePicker::getFirstFile()
  115. {
  116. mCurrentFile = 0;
  117. return getNextFile();
  118. }
  120. const std::string LLFilePicker::getNextFile()
  121. {
  122. if (mCurrentFile >= getFileCount())
  123. {
  124. mLocked = false;
  125. return std::string();
  126. }
  127. else
  128. {
  129. return mFiles[mCurrentFile++];
  130. }
  131. }
  133. const std::string LLFilePicker::getCurFile()
  134. {
  135. if (mCurrentFile >= getFileCount())
  136. {
  137. mLocked = false;
  138. return std::string();
  139. }
  140. else
  141. {
  142. return mFiles[mCurrentFile];
  143. }
  144. }
  146. void LLFilePicker::reset()
  147. {
  148. mLocked = false;
  149. mFiles.clear();
  150. mCurrentFile = 0;
  151. }
  153. #if LL_WINDOWS
  155. BOOL LLFilePicker::setupFilter(ELoadFilter filter)
  156. {
  157. BOOL res = TRUE;
  158. switch (filter)
  159. {
  160. case FFLOAD_ALL:
  161. mOFN.lpstrFilter = L"All Files (*.*)*.*" 
  162. SOUND_FILTER 
  163. IMAGE_FILTER 
  164. ANIM_FILTER 
  165. L"";
  166. break;
  167. case FFLOAD_WAV:
  168. mOFN.lpstrFilter = SOUND_FILTER 
  169. L"";
  170. break;
  171. case FFLOAD_IMAGE:
  172. mOFN.lpstrFilter = IMAGE_FILTER 
  173. L"";
  174. break;
  175. case FFLOAD_ANIM:
  176. mOFN.lpstrFilter = ANIM_FILTER 
  177. L"";
  178. break;
  179. #ifdef _CORY_TESTING
  180. case FFLOAD_GEOMETRY:
  181. mOFN.lpstrFilter = GEOMETRY_FILTER 
  182. L"";
  183. break;
  184. #endif
  185. case FFLOAD_XML:
  186. mOFN.lpstrFilter = XML_FILTER 
  187. L"";
  188. break;
  189. case FFLOAD_SLOBJECT:
  190. mOFN.lpstrFilter = SLOBJECT_FILTER 
  191. L"";
  192. break;
  193. case FFLOAD_RAW:
  194. mOFN.lpstrFilter = RAW_FILTER 
  195. L"";
  196. break;
  197. default:
  198. res = FALSE;
  199. break;
  200. }
  201. return res;
  202. }
  204. BOOL LLFilePicker::getOpenFile(ELoadFilter filter)
  205. {
  206. if( mLocked )
  207. {
  208. return FALSE;
  209. }
  210. BOOL success = FALSE;
  212. // don't provide default file selection
  213. mFilesW[0] = '';
  215. mOFN.hwndOwner = (HWND)gViewerWindow->getPlatformWindow();
  216. mOFN.lpstrFile = mFilesW;
  217. mOFN.nMaxFile = SINGLE_FILENAME_BUFFER_SIZE;
  218. mOFN.Flags = OFN_HIDEREADONLY | OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR ;
  219. mOFN.nFilterIndex = 1;
  221. setupFilter(filter);
  223. // Modal, so pause agent
  224. send_agent_pause();
  226. reset();
  228. // NOTA BENE: hitting the file dialog triggers a window focus event, destroying the selection manager!!
  229. success = GetOpenFileName(&mOFN);
  230. if (success)
  231. {
  232. std::string filename = utf16str_to_utf8str(llutf16string(mFilesW));
  233. mFiles.push_back(filename);
  234. }
  235. send_agent_resume();
  237. // Account for the fact that the app has been stalled.
  238. LLFrameTimer::updateFrameTime();
  239. return success;
  240. }
  242. BOOL LLFilePicker::getMultipleOpenFiles(ELoadFilter filter)
  243. {
  244. if( mLocked )
  245. {
  246. return FALSE;
  247. }
  248. BOOL success = FALSE;
  250. // don't provide default file selection
  251. mFilesW[0] = '';
  253. mOFN.hwndOwner = (HWND)gViewerWindow->getPlatformWindow();
  254. mOFN.lpstrFile = mFilesW;
  255. mOFN.nFilterIndex = 1;
  256. mOFN.nMaxFile = FILENAME_BUFFER_SIZE;
  257. mOFN.Flags = OFN_HIDEREADONLY | OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR |
  258. OFN_EXPLORER | OFN_ALLOWMULTISELECT;
  260. setupFilter(filter);
  262. reset();
  264. // Modal, so pause agent
  265. send_agent_pause();
  266. // NOTA BENE: hitting the file dialog triggers a window focus event, destroying the selection manager!!
  267. success = GetOpenFileName(&mOFN); // pauses until ok or cancel.
  268. if( success )
  269. {
  270. // The getopenfilename api doesn't tell us if we got more than
  271. // one file, so we have to test manually by checking string
  272. // lengths.
  273. if( wcslen(mOFN.lpstrFile) > mOFN.nFileOffset ) /*Flawfinder: ignore*/
  274. {
  275. std::string filename = utf16str_to_utf8str(llutf16string(mFilesW));
  276. mFiles.push_back(filename);
  277. }
  278. else
  279. {
  280. mLocked = true;
  281. WCHAR* tptrw = mFilesW;
  282. std::string dirname;
  283. while(1)
  284. {
  285. if (*tptrw == 0 && *(tptrw+1) == 0) // double ''
  286. break;
  287. if (*tptrw == 0)
  288. tptrw++; // shouldn't happen?
  289. std::string filename = utf16str_to_utf8str(llutf16string(tptrw));
  290. if (dirname.empty())
  291. dirname = filename + "\";
  292. else
  293. mFiles.push_back(dirname + filename);
  294. tptrw += filename.size();
  295. }
  296. }
  297. }
  298. send_agent_resume();
  300. // Account for the fact that the app has been stalled.
  301. LLFrameTimer::updateFrameTime();
  302. return success;
  303. }
  305. BOOL LLFilePicker::getSaveFile(ESaveFilter filter, const std::string& filename)
  306. {
  307. if( mLocked )
  308. {
  309. return FALSE;
  310. }
  311. BOOL success = FALSE;
  313. mOFN.lpstrFile = mFilesW;
  314. if (!filename.empty())
  315. {
  316. llutf16string tstring = utf8str_to_utf16str(filename);
  317. wcsncpy(mFilesW, tstring.c_str(), FILENAME_BUFFER_SIZE); } /*Flawfinder: ignore*/
  318. else
  319. {
  320. mFilesW[0] = '';
  321. }
  322. mOFN.hwndOwner = (HWND)gViewerWindow->getPlatformWindow();
  324. switch( filter )
  325. {
  326. case FFSAVE_ALL:
  327. mOFN.lpstrDefExt = NULL;
  328. mOFN.lpstrFilter =
  329. L"All Files (*.*)*.*" 
  330. L"WAV Sounds (*.wav)*.wav" 
  331. L"Targa, Bitmap Images (*.tga; *.bmp)*.tga;*.bmp" 
  332. L"";
  333. break;
  334. case FFSAVE_WAV:
  335. if (filename.empty())
  336. {
  337. wcsncpy( mFilesW,L"untitled.wav", FILENAME_BUFFER_SIZE); /*Flawfinder: ignore*/
  338. }
  339. mOFN.lpstrDefExt = L"wav";
  340. mOFN.lpstrFilter =
  341. L"WAV Sounds (*.wav)*.wav" 
  342. L"";
  343. break;
  344. case FFSAVE_TGA:
  345. if (filename.empty())
  346. {
  347. wcsncpy( mFilesW,L"untitled.tga", FILENAME_BUFFER_SIZE); /*Flawfinder: ignore*/
  348. }
  349. mOFN.lpstrDefExt = L"tga";
  350. mOFN.lpstrFilter =
  351. L"Targa Images (*.tga)*.tga" 
  352. L"";
  353. break;
  354. case FFSAVE_BMP:
  355. if (filename.empty())
  356. {
  357. wcsncpy( mFilesW,L"untitled.bmp", FILENAME_BUFFER_SIZE); /*Flawfinder: ignore*/
  358. }
  359. mOFN.lpstrDefExt = L"bmp";
  360. mOFN.lpstrFilter =
  361. L"Bitmap Images (*.bmp)*.bmp" 
  362. L"";
  363. break;
  364. case FFSAVE_PNG:
  365. if (filename.empty())
  366. {
  367. wcsncpy( mFilesW,L"untitled.png", FILENAME_BUFFER_SIZE); /*Flawfinder: ignore*/
  368. }
  369. mOFN.lpstrDefExt = L"png";
  370. mOFN.lpstrFilter =
  371. L"PNG Images (*.png)*.png" 
  372. L"";
  373. break;
  374. case FFSAVE_JPEG:
  375. if (filename.empty())
  376. {
  377. wcsncpy( mFilesW,L"untitled.jpeg", FILENAME_BUFFER_SIZE); /*Flawfinder: ignore*/
  378. }
  379. mOFN.lpstrDefExt = L"jpeg";
  380. mOFN.lpstrFilter =
  381. L"JPEG Images (*.jpeg)*.jpeg" 
  382. L"";
  383. break;
  384. case FFSAVE_AVI:
  385. if (filename.empty())
  386. {
  387. wcsncpy( mFilesW,L"untitled.avi", FILENAME_BUFFER_SIZE); /*Flawfinder: ignore*/
  388. }
  389. mOFN.lpstrDefExt = L"avi";
  390. mOFN.lpstrFilter =
  391. L"AVI Movie File (*.avi)*.avi" 
  392. L"";
  393. break;
  394. case FFSAVE_ANIM:
  395. if (filename.empty())
  396. {
  397. wcsncpy( mFilesW,L"untitled.xaf", FILENAME_BUFFER_SIZE); /*Flawfinder: ignore*/
  398. }
  399. mOFN.lpstrDefExt = L"xaf";
  400. mOFN.lpstrFilter =
  401. L"XAF Anim File (*.xaf)*.xaf" 
  402. L"";
  403. break;
  404. #ifdef _CORY_TESTING
  405. case FFSAVE_GEOMETRY:
  406. if (filename.empty())
  407. {
  408. wcsncpy( mFilesW,L"untitled.slg", FILENAME_BUFFER_SIZE); /*Flawfinder: ignore*/
  409. }
  410. mOFN.lpstrDefExt = L"slg";
  411. mOFN.lpstrFilter =
  412. L"SLG SL Geometry File (*.slg)*.slg" 
  413. L"";
  414. break;
  415. #endif
  416. case FFSAVE_XML:
  417. if (filename.empty())
  418. {
  419. wcsncpy( mFilesW,L"untitled.xml", FILENAME_BUFFER_SIZE); /*Flawfinder: ignore*/
  420. }
  422. mOFN.lpstrDefExt = L"xml";
  423. mOFN.lpstrFilter =
  424. L"XML File (*.xml)*.xml" 
  425. L"";
  426. break;
  427. case FFSAVE_COLLADA:
  428. if (filename.empty())
  429. {
  430. wcsncpy( mFilesW,L"untitled.collada", FILENAME_BUFFER_SIZE); /*Flawfinder: ignore*/
  431. }
  432. mOFN.lpstrDefExt = L"collada";
  433. mOFN.lpstrFilter =
  434. L"COLLADA File (*.collada)*.collada" 
  435. L"";
  436. break;
  437. case FFSAVE_RAW:
  438. if (filename.empty())
  439. {
  440. wcsncpy( mFilesW,L"untitled.raw", FILENAME_BUFFER_SIZE); /*Flawfinder: ignore*/
  441. }
  442. mOFN.lpstrDefExt = L"raw";
  443. mOFN.lpstrFilter = RAW_FILTER 
  444. L"";
  445. break;
  446. case FFSAVE_J2C:
  447. if (filename.empty())
  448. {
  449. wcsncpy( mFilesW,L"untitled.j2c", FILENAME_BUFFER_SIZE);
  450. }
  451. mOFN.lpstrDefExt = L"j2c";
  452. mOFN.lpstrFilter =
  453. L"Compressed Images (*.j2c)*.j2c" 
  454. L"";
  455. break;
  456. default:
  457. return FALSE;
  458. }
  460.  
  461. mOFN.nMaxFile = SINGLE_FILENAME_BUFFER_SIZE;
  462. mOFN.Flags = OFN_OVERWRITEPROMPT | OFN_NOCHANGEDIR | OFN_PATHMUSTEXIST;
  464. reset();
  466. // Modal, so pause agent
  467. send_agent_pause();
  468. {
  469. // NOTA BENE: hitting the file dialog triggers a window focus event, destroying the selection manager!!
  470. success = GetSaveFileName(&mOFN);
  471. if (success)
  472. {
  473. std::string filename = utf16str_to_utf8str(llutf16string(mFilesW));
  474. mFiles.push_back(filename);
  475. }
  476. gKeyboard->resetKeys();
  477. }
  478. send_agent_resume();
  480. // Account for the fact that the app has been stalled.
  481. LLFrameTimer::updateFrameTime();
  482. return success;
  483. }
  485. #elif LL_DARWIN
  487. Boolean LLFilePicker::navOpenFilterProc(AEDesc *theItem, void *info, void *callBackUD, NavFilterModes filterMode)
  488. {
  489. Boolean result = true;
  490. ELoadFilter filter = *((ELoadFilter*) callBackUD);
  491. OSStatus error = noErr;
  493. if (filterMode == kNavFilteringBrowserList && filter != FFLOAD_ALL && (theItem->descriptorType == typeFSRef || theItem->descriptorType == typeFSS))
  494. {
  495. // navInfo is only valid for typeFSRef and typeFSS
  496. NavFileOrFolderInfo *navInfo = (NavFileOrFolderInfo*) info;
  497. if (!navInfo->isFolder)
  498. {
  499. AEDesc desc;
  500. error = AECoerceDesc(theItem, typeFSRef, &desc);
  501. if (error == noErr)
  502. {
  503. FSRef fileRef;
  504. error = AEGetDescData(&desc, &fileRef, sizeof(fileRef));
  505. if (error == noErr)
  506. {
  507. LSItemInfoRecord fileInfo;
  508. error = LSCopyItemInfoForRef(&fileRef, kLSRequestExtension | kLSRequestTypeCreator, &fileInfo);
  509. if (error == noErr)
  510. {
  511. if (filter == FFLOAD_IMAGE)
  512. {
  513. if (fileInfo.filetype != 'JPEG' && fileInfo.filetype != 'JPG ' && 
  514. fileInfo.filetype != 'BMP ' && fileInfo.filetype != 'TGA ' &&
  515. fileInfo.filetype != 'BMPf' && fileInfo.filetype != 'TPIC' &&
  516. fileInfo.filetype != 'PNG ' &&
  517. (fileInfo.extension && (CFStringCompare(fileInfo.extension, CFSTR("jpeg"), kCFCompareCaseInsensitive) != kCFCompareEqualTo &&
  518. CFStringCompare(fileInfo.extension, CFSTR("jpg"), kCFCompareCaseInsensitive) != kCFCompareEqualTo &&
  519. CFStringCompare(fileInfo.extension, CFSTR("bmp"), kCFCompareCaseInsensitive) != kCFCompareEqualTo &&
  520. CFStringCompare(fileInfo.extension, CFSTR("tga"), kCFCompareCaseInsensitive) != kCFCompareEqualTo &&
  521. CFStringCompare(fileInfo.extension, CFSTR("png"), kCFCompareCaseInsensitive) != kCFCompareEqualTo))
  522. )
  523. {
  524. result = false;
  525. }
  526. }
  527. else if (filter == FFLOAD_WAV)
  528. {
  529. if (fileInfo.filetype != 'WAVE' && fileInfo.filetype != 'WAV ' && 
  530. (fileInfo.extension && (CFStringCompare(fileInfo.extension, CFSTR("wave"), kCFCompareCaseInsensitive) != kCFCompareEqualTo && 
  531. CFStringCompare(fileInfo.extension, CFSTR("wav"), kCFCompareCaseInsensitive) != kCFCompareEqualTo))
  532. )
  533. {
  534. result = false;
  535. }
  536. }
  537. else if (filter == FFLOAD_ANIM)
  538. {
  539. if (fileInfo.filetype != 'BVH ' && 
  540. (fileInfo.extension && (CFStringCompare(fileInfo.extension, CFSTR("bvh"), kCFCompareCaseInsensitive) != kCFCompareEqualTo))
  541. )
  542. {
  543. result = false;
  544. }
  545. }
  546. #ifdef _CORY_TESTING
  547. else if (filter == FFLOAD_GEOMETRY)
  548. {
  549. if (fileInfo.filetype != 'SLG ' && 
  550. (fileInfo.extension && (CFStringCompare(fileInfo.extension, CFSTR("slg"), kCFCompareCaseInsensitive) != kCFCompareEqualTo))
  551. )
  552. {
  553. result = false;
  554. }
  555. }
  556. #endif
  557. else if (filter == FFLOAD_SLOBJECT)
  558. {
  559. llwarns << "*** navOpenFilterProc: FFLOAD_SLOBJECT NOT IMPLEMENTED ***" << llendl;
  560. }
  561. else if (filter == FFLOAD_RAW)
  562. {
  563. if (fileInfo.filetype != '????' && 
  564. (fileInfo.extension && (CFStringCompare(fileInfo.extension, CFSTR("raw"), kCFCompareCaseInsensitive) != kCFCompareEqualTo))
  565. )
  566. {
  567. result = false;
  568. }
  569. }
  571. if (fileInfo.extension)
  572. {
  573. CFRelease(fileInfo.extension);
  574. }
  575. }
  576. }
  577. AEDisposeDesc(&desc);
  578. }
  579. }
  580. }
  581. return result;
  582. }
  584. OSStatus LLFilePicker::doNavChooseDialog(ELoadFilter filter)
  585. {
  586. OSStatus error = noErr;
  587. NavDialogRef navRef = NULL;
  588. NavReplyRecord navReply;
  590. memset(&navReply, 0, sizeof(navReply));
  592. // NOTE: we are passing the address of a local variable here.  
  593. //   This is fine, because the object this call creates will exist for less than the lifetime of this function.
  594. //   (It is destroyed by NavDialogDispose() below.)
  595. error = NavCreateChooseFileDialog(&mNavOptions, NULL, NULL, NULL, navOpenFilterProc, (void*)(&filter), &navRef);
  597. gViewerWindow->mWindow->beforeDialog();
  599. if (error == noErr)
  600. error = NavDialogRun(navRef);
  602. gViewerWindow->mWindow->afterDialog();
  604. if (error == noErr)
  605. error = NavDialogGetReply(navRef, &navReply);
  607. if (navRef)
  608. NavDialogDispose(navRef);
  610. if (error == noErr && navReply.validRecord)
  611. {
  612. SInt32 count = 0;
  613. SInt32 index;
  615. // AE indexes are 1 based...
  616. error = AECountItems(&navReply.selection, &count);
  617. for (index = 1; index <= count; index++)
  618. {
  619. FSRef fsRef;
  620. AEKeyword theAEKeyword;
  621. DescType typeCode;
  622. Size actualSize = 0;
  623. char path[MAX_PATH]; /*Flawfinder: ignore*/
  625. memset(&fsRef, 0, sizeof(fsRef));
  626. error = AEGetNthPtr(&navReply.selection, index, typeFSRef, &theAEKeyword, &typeCode, &fsRef, sizeof(fsRef), &actualSize);
  628. if (error == noErr)
  629. error = FSRefMakePath(&fsRef, (UInt8*) path, sizeof(path));
  631. if (error == noErr)
  632. mFiles.push_back(std::string(path));
  633. }
  634. }
  636. return error;
  637. }
  639. OSStatus LLFilePicker::doNavSaveDialog(ESaveFilter filter, const std::string& filename)
  640. {
  641. OSStatus error = noErr;
  642. NavDialogRef navRef = NULL;
  643. NavReplyRecord navReply;
  645. memset(&navReply, 0, sizeof(navReply));
  647. // Setup the type, creator, and extension
  648. OSType type, creator;
  649. CFStringRef extension = NULL;
  650. switch (filter)
  651. {
  652. case FFSAVE_WAV:
  653. type = 'WAVE';
  654. creator = 'TVOD';
  655. extension = CFSTR(".wav");
  656. break;
  658. case FFSAVE_TGA:
  659. type = 'TPIC';
  660. creator = 'prvw';
  661. extension = CFSTR(".tga");
  662. break;
  664. case FFSAVE_BMP:
  665. type = 'BMPf';
  666. creator = 'prvw';
  667. extension = CFSTR(".bmp");
  668. break;
  669. case FFSAVE_JPEG:
  670. type = 'JPEG';
  671. creator = 'prvw';
  672. extension = CFSTR(".jpeg");
  673. break;
  674. case FFSAVE_PNG:
  675. type = 'PNG ';
  676. creator = 'prvw';
  677. extension = CFSTR(".png");
  678. break;
  679. case FFSAVE_AVI:
  680. type = '????';
  681. creator = '????';
  682. extension = CFSTR(".mov");
  683. break;
  685. case FFSAVE_ANIM:
  686. type = '????';
  687. creator = '????';
  688. extension = CFSTR(".xaf");
  689. break;
  691. #ifdef _CORY_TESTING
  692. case FFSAVE_GEOMETRY:
  693. type = '????';
  694. creator = '????';
  695. extension = CFSTR(".slg");
  696. break;
  697. #endif
  698. case FFSAVE_RAW:
  699. type = '????';
  700. creator = '????';
  701. extension = CFSTR(".raw");
  702. break;
  704. case FFSAVE_J2C:
  705. type = '????';
  706. creator = 'prvw';
  707. extension = CFSTR(".j2c");
  708. break;
  710. case FFSAVE_ALL:
  711. default:
  712. type = '????';
  713. creator = '????';
  714. extension = CFSTR("");
  715. break;
  716. }
  718. // Create the dialog
  719. error = NavCreatePutFileDialog(&mNavOptions, type, creator, NULL, NULL, &navRef);
  720. if (error == noErr)
  721. {
  722. CFStringRef nameString = NULL;
  723. bool hasExtension = true;
  725. // Create a CFString of the initial file name
  726. if (!filename.empty())
  727. nameString = CFStringCreateWithCString(NULL, filename.c_str(), kCFStringEncodingUTF8);
  728. else
  729. nameString = CFSTR("Untitled");
  731. // Add the extension if one was not provided
  732. if (nameString && !CFStringHasSuffix(nameString, extension))
  733. {
  734. CFStringRef tempString = nameString;
  735. hasExtension = false;
  736. nameString = CFStringCreateWithFormat(NULL, NULL, CFSTR("%@%@"), tempString, extension);
  737. CFRelease(tempString);
  738. }
  740. // Set the name in the dialog
  741. if (nameString)
  742. {
  743. error = NavDialogSetSaveFileName(navRef, nameString);
  744. CFRelease(nameString);
  745. }
  746. else
  747. {
  748. error = paramErr;
  749. }
  750. }
  752. gViewerWindow->mWindow->beforeDialog();
  754. // Run the dialog
  755. if (error == noErr)
  756. error = NavDialogRun(navRef);
  758. gViewerWindow->mWindow->afterDialog();
  760. if (error == noErr)
  761. error = NavDialogGetReply(navRef, &navReply);
  763. if (navRef)
  764. NavDialogDispose(navRef);
  766. if (error == noErr && navReply.validRecord)
  767. {
  768. SInt32 count = 0;
  770. // AE indexes are 1 based...
  771. error = AECountItems(&navReply.selection, &count);
  772. if (count > 0)
  773. {
  774. // Get the FSRef to the containing folder
  775. FSRef fsRef;
  776. AEKeyword theAEKeyword;
  777. DescType typeCode;
  778. Size actualSize = 0;
  780. memset(&fsRef, 0, sizeof(fsRef));
  781. error = AEGetNthPtr(&navReply.selection, 1, typeFSRef, &theAEKeyword, &typeCode, &fsRef, sizeof(fsRef), &actualSize);
  783. if (error == noErr)
  784. {
  785. char path[PATH_MAX]; /*Flawfinder: ignore*/
  786. char newFileName[SINGLE_FILENAME_BUFFER_SIZE]; /*Flawfinder: ignore*/
  788. error = FSRefMakePath(&fsRef, (UInt8*)path, PATH_MAX);
  789. if (error == noErr)
  790. {
  791. if (CFStringGetCString(navReply.saveFileName, newFileName, sizeof(newFileName), kCFStringEncodingUTF8))
  792. {
  793. mFiles.push_back(std::string(path) + "/" +  std::string(newFileName));
  794. }
  795. else
  796. {
  797. error = paramErr;
  798. }
  799. }
  800. else
  801. {
  802. error = paramErr;
  803. }
  804. }
  805. }
  806. }
  808. return error;
  809. }
  811. BOOL LLFilePicker::getOpenFile(ELoadFilter filter)
  812. {
  813. if( mLocked )
  814. return FALSE;
  816. BOOL success = FALSE;
  818. OSStatus error = noErr;
  820. reset();
  822. mNavOptions.optionFlags &= ~kNavAllowMultipleFiles;
  824. if(filter == FFLOAD_ALL) // allow application bundles etc. to be traversed; important for DEV-16869, but generally useful
  825. {
  826. // mNavOptions.optionFlags |= kNavAllowOpenPackages;
  827. mNavOptions.optionFlags |= kNavSupportPackages;
  828. }
  830. // Modal, so pause agent
  831. send_agent_pause();
  832. {
  833. error = doNavChooseDialog(filter);
  834. }
  835. send_agent_resume();
  836. if (error == noErr)
  837. {
  838. if (getFileCount())
  839. success = true;
  840. }
  842. // Account for the fact that the app has been stalled.
  843. LLFrameTimer::updateFrameTime();
  844. return success;
  845. }
  847. BOOL LLFilePicker::getMultipleOpenFiles(ELoadFilter filter)
  848. {
  849. if( mLocked )
  850. return FALSE;
  852. BOOL success = FALSE;
  854. OSStatus error = noErr;
  856. reset();
  858. mNavOptions.optionFlags |= kNavAllowMultipleFiles;
  859. // Modal, so pause agent
  860. send_agent_pause();
  861. {
  862. error = doNavChooseDialog(filter);
  863. }
  864. send_agent_resume();
  865. if (error == noErr)
  866. {
  867. if (getFileCount())
  868. success = true;
  869. if (getFileCount() > 1)
  870. mLocked = true;
  871. }
  873. // Account for the fact that the app has been stalled.
  874. LLFrameTimer::updateFrameTime();
  875. return success;
  876. }
  878. BOOL LLFilePicker::getSaveFile(ESaveFilter filter, const std::string& filename)
  879. {
  880. if( mLocked )
  881. return FALSE;
  882. BOOL success = FALSE;
  883. OSStatus error = noErr;
  885. reset();
  887. mNavOptions.optionFlags &= ~kNavAllowMultipleFiles;
  889. // Modal, so pause agent
  890. send_agent_pause();
  891. {
  892. error = doNavSaveDialog(filter, filename);
  893. }
  894. send_agent_resume();
  895. if (error == noErr)
  896. {
  897. if (getFileCount())
  898. success = true;
  899. }
  901. // Account for the fact that the app has been stalled.
  902. LLFrameTimer::updateFrameTime();
  903. return success;
  904. }
  906. #elif LL_LINUX || LL_SOLARIS
  908. # if LL_GTK
  910. // static
  911. void LLFilePicker::add_to_selectedfiles(gpointer data, gpointer user_data)
  912. {
  913. // We need to run g_filename_to_utf8 in the user's locale
  914. std::string saved_locale(setlocale(LC_ALL, NULL));
  915. setlocale(LC_ALL, "");
  917. LLFilePicker* picker = (LLFilePicker*) user_data;
  918. GError *error = NULL;
  919. gchar* filename_utf8 = g_filename_to_utf8((gchar*)data,
  920.   -1, NULL, NULL, &error);
  921. if (error)
  922. {
  923. // *FIXME.
  924. // This condition should really be notified to the user, e.g.
  925. // through a message box.  Just logging it is inappropriate.
  927. // g_filename_display_name is ideal, but >= glib 2.6, so:
  928. // a hand-rolled hacky makeASCII which disallows control chars
  929. std::string display_name;
  930. for (const gchar *str = (const gchar *)data; *str; str++)
  931. {
  932. display_name += (char)((*str >= 0x20 && *str <= 0x7E) ? *str : '?');
  933. }
  934. llwarns << "g_filename_to_utf8 failed on "" << display_name << "": " << error->message << llendl;
  935. }
  937. if (filename_utf8)
  938. {
  939. picker->mFiles.push_back(std::string(filename_utf8));
  940. lldebugs << "ADDED FILE " << filename_utf8 << llendl;
  941. g_free(filename_utf8);
  942. }
  944. setlocale(LC_ALL, saved_locale.c_str());
  945. }
  947. // static
  948. void LLFilePicker::chooser_responder(GtkWidget *widget, gint response, gpointer user_data)
  949. {
  950. LLFilePicker* picker = (LLFilePicker*)user_data;
  952. lldebugs << "GTK DIALOG RESPONSE " << response << llendl;
  954. if (response == GTK_RESPONSE_ACCEPT)
  955. {
  956. GSList *file_list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(widget));
  957. g_slist_foreach(file_list, (GFunc)add_to_selectedfiles, user_data);
  958. g_slist_foreach(file_list, (GFunc)g_free, NULL);
  959. g_slist_free (file_list);
  960. }
  962. // set the default path for this usage context.
  963. picker->mContextToPathMap[picker->mCurContextName] =
  964. gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(widget));
  966. gtk_widget_destroy(widget);
  967. gtk_main_quit();
  968. }
  971. GtkWindow* LLFilePicker::buildFilePicker(bool is_save, bool is_folder, std::string context)
  972. {
  973. if (LLWindowSDL::ll_try_gtk_init())
  974. {
  975. GtkWidget *win = NULL;
  976. GtkFileChooserAction pickertype =
  977. is_save?
  978. (is_folder?
  979.  GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER :
  980.  GTK_FILE_CHOOSER_ACTION_SAVE) :
  981. (is_folder?
  982.  GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER :
  983.  GTK_FILE_CHOOSER_ACTION_OPEN);
  985. win = gtk_file_chooser_dialog_new(NULL, NULL,
  986.   pickertype,
  987.   GTK_STOCK_CANCEL,
  988.    GTK_RESPONSE_CANCEL,
  989.   is_folder ?
  990.   GTK_STOCK_APPLY :
  991.   (is_save ? 
  992.    GTK_STOCK_SAVE :
  993.    GTK_STOCK_OPEN),
  994.    GTK_RESPONSE_ACCEPT,
  995.   (gchar *)NULL);
  996. mCurContextName = context;
  998. // get the default path for this usage context if it's been
  999. // seen before.
  1000. std::map<std::string,std::string>::iterator
  1001. this_path = mContextToPathMap.find(context);
  1002. if (this_path != mContextToPathMap.end())
  1003. {
  1004. gtk_file_chooser_set_current_folder
  1005. (GTK_FILE_CHOOSER(win),
  1006.  this_path->second.c_str());
  1007. }
  1009. #  if LL_X11
  1010. // Make GTK tell the window manager to associate this
  1011. // dialog with our non-GTK raw X11 window, which should try
  1012. // to keep it on top etc.
  1013. Window XWindowID = LLWindowSDL::get_SDL_XWindowID();
  1014. if (None != XWindowID)
  1015. {
  1016. gtk_widget_realize(GTK_WIDGET(win)); // so we can get its gdkwin
  1017. GdkWindow *gdkwin = gdk_window_foreign_new(XWindowID);
  1018. gdk_window_set_transient_for(GTK_WIDGET(win)->window,
  1019.      gdkwin);
  1020. }
  1021. else
  1022. {
  1023. llwarns << "Hmm, couldn't get xwid to use for transient." << llendl;
  1024. }
  1025. #  endif //LL_X11
  1027. g_signal_connect (GTK_FILE_CHOOSER(win),
  1028.   "response",
  1029.   G_CALLBACK(LLFilePicker::chooser_responder),
  1030.   this);
  1032. gtk_window_set_modal(GTK_WINDOW(win), TRUE);
  1034. /* GTK 2.6: if (is_folder)
  1035. gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(win),
  1036. TRUE); */
  1038. return GTK_WINDOW(win);
  1039. }
  1040. else
  1041. {
  1042. return NULL;
  1043. }
  1044. }
  1046. static void add_common_filters_to_gtkchooser(GtkFileFilter *gfilter,
  1047.      GtkWindow *picker,
  1048.      std::string filtername)
  1049. {
  1050. gtk_file_filter_set_name(gfilter, filtername.c_str());
  1051. gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(picker),
  1052.     gfilter);
  1053. GtkFileFilter *allfilter = gtk_file_filter_new();
  1054. gtk_file_filter_add_pattern(allfilter, "*");
  1055. gtk_file_filter_set_name(allfilter, LLTrans::getString("all_files").c_str());
  1056. gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(picker), allfilter);
  1057. gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(picker), gfilter);
  1058. }
  1060. static std::string add_simple_pattern_filter_to_gtkchooser(GtkWindow *picker,
  1061.    std::string pattern,
  1062.    std::string filtername)
  1063. {
  1064. GtkFileFilter *gfilter = gtk_file_filter_new();
  1065. gtk_file_filter_add_pattern(gfilter, pattern.c_str());
  1066. add_common_filters_to_gtkchooser(gfilter, picker, filtername);
  1067. return filtername;
  1068. }
  1070. static std::string add_simple_mime_filter_to_gtkchooser(GtkWindow *picker,
  1071. std::string mime,
  1072. std::string filtername)
  1073. {
  1074. GtkFileFilter *gfilter = gtk_file_filter_new();
  1075. gtk_file_filter_add_mime_type(gfilter, mime.c_str());
  1076. add_common_filters_to_gtkchooser(gfilter, picker, filtername);
  1077. return filtername;
  1078. }
  1080. static std::string add_wav_filter_to_gtkchooser(GtkWindow *picker)
  1081. {
  1082. return add_simple_mime_filter_to_gtkchooser(picker,  "audio/x-wav",
  1083.     LLTrans::getString("sound_files") + " (*.wav)");
  1084. }
  1086. static std::string add_bvh_filter_to_gtkchooser(GtkWindow *picker)
  1087. {
  1088. return add_simple_pattern_filter_to_gtkchooser(picker,  "*.bvh",
  1089.        LLTrans::getString("animation_files") + " (*.bvh)");
  1090. }
  1092. static std::string add_imageload_filter_to_gtkchooser(GtkWindow *picker)
  1093. {
  1094. GtkFileFilter *gfilter = gtk_file_filter_new();
  1095. gtk_file_filter_add_pattern(gfilter, "*.tga");
  1096. gtk_file_filter_add_mime_type(gfilter, "image/jpeg");
  1097. gtk_file_filter_add_mime_type(gfilter, "image/png");
  1098. gtk_file_filter_add_mime_type(gfilter, "image/bmp");
  1099. std::string filtername = LLTrans::getString("image_files") + " (*.tga; *.bmp; *.jpg; *.png)";
  1100. add_common_filters_to_gtkchooser(gfilter, picker, filtername);
  1101. return filtername;
  1102. }
  1105. BOOL LLFilePicker::getSaveFile( ESaveFilter filter, const std::string& filename )
  1106. {
  1107. BOOL rtn = FALSE;
  1109. gViewerWindow->mWindow->beforeDialog();
  1111. reset();
  1113. GtkWindow* picker = buildFilePicker(true, false, "savefile");
  1115. if (picker)
  1116. {
  1117. std::string suggest_name = "untitled";
  1118. std::string suggest_ext = "";
  1119. std::string caption = LLTrans::getString("save_file_verb") + " ";
  1120. switch (filter)
  1121. {
  1122. case FFSAVE_WAV:
  1123. caption += add_wav_filter_to_gtkchooser(picker);
  1124. suggest_ext = ".wav";
  1125. break;
  1126. case FFSAVE_TGA:
  1127. caption += add_simple_pattern_filter_to_gtkchooser
  1128. (picker, "*.tga", LLTrans::getString("targa_image_files") + " (*.tga)");
  1129. suggest_ext = ".tga";
  1130. break;
  1131. case FFSAVE_BMP:
  1132. caption += add_simple_mime_filter_to_gtkchooser
  1133. (picker, "image/bmp", LLTrans::getString("bitmap_image_files") + " (*.bmp)");
  1134. suggest_ext = ".bmp";
  1135. break;
  1136. case FFSAVE_AVI:
  1137. caption += add_simple_mime_filter_to_gtkchooser
  1138. (picker, "video/x-msvideo",
  1139.  LLTrans::getString("avi_movie_file") + " (*.avi)");
  1140. suggest_ext = ".avi";
  1141. break;
  1142. case FFSAVE_ANIM:
  1143. caption += add_simple_pattern_filter_to_gtkchooser
  1144. (picker, "*.xaf", LLTrans::getString("xaf_animation_file") + " (*.xaf)");
  1145. suggest_ext = ".xaf";
  1146. break;
  1147. case FFSAVE_XML:
  1148. caption += add_simple_pattern_filter_to_gtkchooser
  1149. (picker, "*.xml", LLTrans::getString("xml_file") + " (*.xml)");
  1150. suggest_ext = ".xml";
  1151. break;
  1152. case FFSAVE_RAW:
  1153. caption += add_simple_pattern_filter_to_gtkchooser
  1154. (picker, "*.raw", LLTrans::getString("raw_file") + " (*.raw)");
  1155. suggest_ext = ".raw";
  1156. break;
  1157. case FFSAVE_J2C:
  1158. caption += add_simple_mime_filter_to_gtkchooser
  1159. (picker, "images/jp2",
  1160.  LLTrans::getString("compressed_image_files") + " (*.j2c)");
  1161. suggest_ext = ".j2c";
  1162. break;
  1163. default:;
  1164. break;
  1165. }
  1167. gtk_window_set_title(GTK_WINDOW(picker), caption.c_str());
  1169. if (filename.empty())
  1170. {
  1171. suggest_name += suggest_ext;
  1173. gtk_file_chooser_set_current_name
  1174. (GTK_FILE_CHOOSER(picker),
  1175.  suggest_name.c_str());
  1176. }
  1177. else
  1178. {
  1179. gtk_file_chooser_set_current_name
  1180. (GTK_FILE_CHOOSER(picker), filename.c_str());
  1181. }
  1183. gtk_widget_show_all(GTK_WIDGET(picker));
  1184. gtk_main();
  1186. rtn = (getFileCount() == 1);
  1187. }
  1189. gViewerWindow->mWindow->afterDialog();
  1191. return rtn;
  1192. }
  1194. BOOL LLFilePicker::getOpenFile( ELoadFilter filter )
  1195. {
  1196. BOOL rtn = FALSE;
  1198. gViewerWindow->mWindow->beforeDialog();
  1200. reset();
  1202. GtkWindow* picker = buildFilePicker(false, false, "openfile");
  1204. if (picker)
  1205. {
  1206. std::string caption = LLTrans::getString("load_file_verb") + " ";
  1207. std::string filtername = "";
  1208. switch (filter)
  1209. {
  1210. case FFLOAD_WAV:
  1211. filtername = add_wav_filter_to_gtkchooser(picker);
  1212. break;
  1213. case FFLOAD_ANIM:
  1214. filtername = add_bvh_filter_to_gtkchooser(picker);
  1215. break;
  1216. case FFLOAD_IMAGE:
  1217. filtername = add_imageload_filter_to_gtkchooser(picker);
  1218. break;
  1219. default:;
  1220. break;
  1221. }
  1223. caption += filtername;
  1225. gtk_window_set_title(GTK_WINDOW(picker), caption.c_str());
  1227. gtk_widget_show_all(GTK_WIDGET(picker));
  1228. gtk_main();
  1230. rtn = (getFileCount() == 1);
  1231. }
  1233. gViewerWindow->mWindow->afterDialog();
  1235. return rtn;
  1236. }
  1238. BOOL LLFilePicker::getMultipleOpenFiles( ELoadFilter filter )
  1239. {
  1240. BOOL rtn = FALSE;
  1242. gViewerWindow->mWindow->beforeDialog();
  1244. reset();
  1246. GtkWindow* picker = buildFilePicker(false, false, "openfile");
  1248. if (picker)
  1249. {
  1250. gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER(picker),
  1251.       TRUE);
  1253. gtk_window_set_title(GTK_WINDOW(picker), LLTrans::getString("load_files").c_str());
  1255. gtk_widget_show_all(GTK_WIDGET(picker));
  1256. gtk_main();
  1257. rtn = !mFiles.empty();
  1258. }
  1260. gViewerWindow->mWindow->afterDialog();
  1262. return rtn;
  1263. }
  1265. # else // LL_GTK
  1267. // Hacky stubs designed to facilitate fake getSaveFile and getOpenFile with
  1268. // static results, when we don't have a real filepicker.
  1270. BOOL LLFilePicker::getSaveFile( ESaveFilter filter, const std::string& filename )
  1271. {
  1272. reset();
  1274. llinfos << "getSaveFile suggested filename is [" << filename
  1275. << "]" << llendl;
  1276. if (!filename.empty())
  1277. {
  1278. mFiles.push_back(gDirUtilp->getLindenUserDir() + gDirUtilp->getDirDelimiter() + filename);
  1279. return TRUE;
  1280. }
  1281. return FALSE;
  1282. }
  1284. BOOL LLFilePicker::getOpenFile( ELoadFilter filter )
  1285. {
  1286. reset();
  1288. // HACK: Static filenames for 'open' until we implement filepicker
  1289. std::string filename = gDirUtilp->getLindenUserDir() + gDirUtilp->getDirDelimiter() + "upload";
  1290. switch (filter)
  1291. {
  1292. case FFLOAD_WAV: filename += ".wav"; break;
  1293. case FFLOAD_IMAGE: filename += ".tga"; break;
  1294. case FFLOAD_ANIM: filename += ".bvh"; break;
  1295. default: break;
  1296. }
  1297. mFiles.push_back(filename);
  1298. llinfos << "getOpenFile: Will try to open file: " << hackyfilename << llendl;
  1299. return TRUE;
  1300. }
  1302. BOOL LLFilePicker::getMultipleOpenFiles( ELoadFilter filter )
  1303. {
  1304. reset();
  1305. return FALSE;
  1306. }
  1308. #endif // LL_GTK
  1310. #else // not implemented
  1312. BOOL LLFilePicker::getSaveFile( ESaveFilter filter, const std::string& filename )
  1313. {
  1314. reset();
  1315. return FALSE;
  1316. }
  1318. BOOL LLFilePicker::getOpenFile( ELoadFilter filter )
  1319. {
  1320. reset();
  1321. return FALSE;
  1322. }
  1324. BOOL LLFilePicker::getMultipleOpenFiles( ELoadFilter filter )
  1325. {
  1326. reset();
  1327. return FALSE;
  1328. }
  1330. #endif