API tools faq
paste
Guest User

Untitled

a guest
Jun 19th, 2018
80
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 23.23 KB | None | 0 0
raw download clone embed print report
  1. /////////////gui_gamegrid.h
  2.  
  3. #ifndef _GUIGAMEGRID_H_
  4. #define _GUIGAMEGRID_H_
  5.  
  6. #include "gui.h"
  7. #include "../disc.h"
  8. /*
  9. class GameBrowserList {
  10. public:
  11. GameBrowserList(int size) {
  12. name = new char * [size];
  13.  
  14. for (int i = 0; i < size; i++)
  15. {
  16. name[i] = new char[50];
  17. }
  18. length = size;
  19. };
  20. ~GameBrowserList(){
  21. for (int i = 0; i < length; i++)
  22. {
  23. delete [] name[i];
  24. }
  25. delete [] name;
  26. };
  27.  
  28. public:
  29. int length;
  30. char ** name;
  31. };
  32. */
  33.  
  34. class GuiGameGrid : public GuiElement
  35. {
  36. public:
  37. GuiGameGrid(int w, int h, struct discHdr * l, int gameCnt, const char *themePath, const u8 *imagebg, int selected = 0, int offset = 0);
  38. ~GuiGameGrid();
  39. int FindMenuItem(int c, int d);
  40. int GetClickedOption();
  41. int GetSelectedOption();
  42. void ResetState();
  43. void SetFocus(int f);
  44. void Draw();
  45. void Update(GuiTrigger * t);
  46. int GetOffset();
  47. void Reload(struct discHdr * l, int count);
  48. //GuiText * optionVal[PAGESIZE];
  49. protected:
  50. int selectedItem;
  51. int listOffset;
  52. int scrollbaron;
  53. int pagesize;
  54.  
  55. struct discHdr * gameList;
  56. int gameCnt;
  57.  
  58. int * gameIndex;
  59. GuiButton ** game;
  60. GuiText ** gameTxt;
  61. GuiImage ** gameBg;
  62. GuiImage ** coverImg;
  63. GuiImageData ** cover;
  64.  
  65. GuiButton * arrowUpBtn;
  66. GuiButton * arrowDownBtn;
  67. GuiButton * scrollbarBoxBtn;
  68.  
  69. GuiImage * bgGameImg;
  70. GuiImage * scrollbarImg;
  71. GuiImage * arrowDownImg;
  72. GuiImage * arrowDownOverImg;
  73. GuiImage * ttarrowUpImg;
  74. GuiImage * ttarrowDownImg;
  75. GuiImage * arrowUpImg;
  76. GuiImage * arrowUpOverImg;
  77. GuiImage * scrollbarBoxImg;
  78. GuiImage * scrollbarBoxOverImg;
  79.  
  80. GuiText * ttarrowDownTxt;
  81. GuiText * ttarrowUpTxt;
  82.  
  83. GuiImageData * bgGames;
  84. GuiImageData * bgGamesEntry;
  85. GuiImageData * scrollbar;
  86. GuiImageData * arrowDown;
  87. GuiImageData * arrowDownOver;
  88. GuiImageData * ttarrow;
  89. GuiImageData * arrowUp;
  90. GuiImageData * arrowUpOver;
  91. GuiImageData * scrollbarBox;
  92. GuiImageData * scrollbarBoxOver;
  93.  
  94. GuiSound * btnSoundOver;
  95. GuiSound * btnSoundClick;
  96. GuiTrigger * trigA;
  97. GuiTrigger * trigHeldA;
  98. };
  99. #endif
  100.  
  101. ////////////////////////////////gui_gamegrid.cpp
  102.  
  103. /****************************************************************************
  104. * libwiigui
  105. *
  106. * gui_gamebrowser.cpp
  107. *
  108. * GUI class definitions
  109. ***************************************************************************/
  110.  
  111. #include "gui.h"
  112. #include "../wpad.h"
  113.  
  114. #include <unistd.h>
  115. #include "gui_gamegrid.h"
  116. #include "../cfg.h"
  117.  
  118. #include <string.h>
  119. #include <sstream>
  120.  
  121. #define GAMESELECTSIZE 30
  122. extern const int vol;
  123. //int txtscroll = 0;
  124. u16 changed = 0;
  125. int tooMuch;
  126. int topPic = 4;
  127. int goLeft=0,goRight=0,mover=0,difference=0;
  128. /**
  129. * Constructor for the GuiGameGrid class.
  130. */
  131. GuiGameGrid::GuiGameGrid(int w, int h, struct discHdr * l, int gameCnt, const char *themePath, const u8 *imagebg, int selected, int offset)
  132. {
  133. width = 640;
  134. height = 480;
  135. this->gameCnt = gameCnt;
  136. gameList = l;
  137. pagesize = 7;
  138. scrollbaron = (gameCnt > pagesize) ? 1 : 0;
  139. selectable = true;
  140. listOffset = (offset == 0) ? this->FindMenuItem(-1, 1) : offset;
  141. selectedItem = selected - offset;
  142. focus = 1; // allow focus
  143. char imgPath[100];
  144. tooMuch=(gameCnt-(gameCnt%12));
  145.  
  146. trigA = new GuiTrigger;
  147. trigA->SetSimpleTrigger(-1, WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A, PAD_BUTTON_A);
  148. trigHeldA = new GuiTrigger;
  149. trigHeldA->SetHeldTrigger(-1, WPAD_BUTTON_A, PAD_BUTTON_A);
  150. btnSoundClick = new GuiSound(button_click_pcm, button_click_pcm_size, SOUND_PCM, vol);
  151.  
  152. snprintf(imgPath, sizeof(imgPath), "%sbg_options.png", themePath);
  153. bgGames = new GuiImageData(imgPath, imagebg);
  154.  
  155. bgGameImg = new GuiImage(bgGames);
  156. bgGameImg->SetParent(this);
  157. bgGameImg->SetAlignment(ALIGN_LEFT, ALIGN_MIDDLE);
  158.  
  159. snprintf(imgPath, sizeof(imgPath), "%sbg_options_entry.png", themePath);
  160. bgGamesEntry = new GuiImageData(imgPath, bg_options_entry_png);
  161. if (scrollbaron == 1) {
  162. snprintf(imgPath, sizeof(imgPath), "%sscrollbar.png", themePath);
  163. scrollbar = new GuiImageData(imgPath, scrollbar_png);
  164. scrollbarImg = new GuiImage(scrollbar);
  165. scrollbarImg->SetParent(this);
  166. scrollbarImg->SetAlignment(ALIGN_RIGHT, ALIGN_TOP);
  167. scrollbarImg->SetPosition(0, 4);
  168.  
  169. snprintf(imgPath, sizeof(imgPath), "%sscrollbar_arrowdown.png", themePath);
  170. arrowDown = new GuiImageData(imgPath, scrollbar_arrowdown_png);
  171. arrowDownImg = new GuiImage(arrowDown);
  172. arrowDownOver = new GuiImageData(imgPath, scrollbar_arrowdown_png);
  173. arrowDownOverImg = new GuiImage(arrowDownOver);
  174. snprintf(imgPath, sizeof(imgPath), "%sscrollbar_arrowup.png", themePath);
  175. arrowUp = new GuiImageData(imgPath, scrollbar_arrowup_png);
  176. arrowUpImg = new GuiImage(arrowUp);
  177. arrowUpOver = new GuiImageData(imgPath, scrollbar_arrowup_png);
  178. arrowUpOverImg = new GuiImage(arrowUpOver);
  179. snprintf(imgPath, sizeof(imgPath), "%sscrollbar_box.png", themePath);
  180. scrollbarBox = new GuiImageData(imgPath, scrollbar_box_png);
  181. scrollbarBoxImg = new GuiImage(scrollbarBox);
  182. scrollbarBoxOver = new GuiImageData(imgPath, scrollbar_box_png);
  183. scrollbarBoxOverImg = new GuiImage(scrollbarBoxOver);
  184.  
  185. arrowUpBtn = new GuiButton(arrowUpImg->GetWidth(), arrowUpImg->GetHeight());
  186. arrowUpBtn->SetParent(this);
  187. arrowUpBtn->SetImage(arrowUpImg);
  188. arrowUpBtn->SetImageOver(arrowUpOverImg);
  189. arrowUpBtn->SetImageHold(arrowUpOverImg);
  190. arrowUpBtn->SetAlignment(ALIGN_CENTRE, ALIGN_TOP);
  191. arrowUpBtn->SetPosition(width/2-18+7,-18);
  192. arrowUpBtn->SetSelectable(false);
  193. arrowUpBtn->SetTrigger(trigA);
  194. arrowUpBtn->SetEffectOnOver(EFFECT_SCALE, 50, 130);
  195. arrowUpBtn->SetSoundClick(btnSoundClick);
  196.  
  197. arrowDownBtn = new GuiButton(arrowDownImg->GetWidth(), arrowDownImg->GetHeight());
  198. arrowDownBtn->SetParent(this);
  199. arrowDownBtn->SetImage(arrowDownImg);
  200. arrowDownBtn->SetImageOver(arrowDownOverImg);
  201. arrowDownBtn->SetImageHold(arrowDownOverImg);
  202. arrowDownBtn->SetAlignment(ALIGN_CENTRE, ALIGN_BOTTOM);
  203. arrowDownBtn->SetPosition(width/2-18+7,18);
  204. arrowDownBtn->SetSelectable(false);
  205. arrowDownBtn->SetTrigger(trigA);
  206. arrowDownBtn->SetEffectOnOver(EFFECT_SCALE, 50, 130);
  207. arrowDownBtn->SetSoundClick(btnSoundClick);
  208.  
  209. scrollbarBoxBtn = new GuiButton(scrollbarBoxImg->GetWidth(), scrollbarBoxImg->GetHeight());
  210. scrollbarBoxBtn->SetParent(this);
  211. scrollbarBoxBtn->SetImage(scrollbarBoxImg);
  212. scrollbarBoxBtn->SetImageOver(scrollbarBoxOverImg);
  213. scrollbarBoxBtn->SetImageHold(scrollbarBoxOverImg);
  214. scrollbarBoxBtn->SetAlignment(ALIGN_CENTRE, ALIGN_TOP);
  215. scrollbarBoxBtn->SetSelectable(false);
  216. scrollbarBoxBtn->SetEffectOnOver(EFFECT_SCALE, 50, 120);
  217. scrollbarBoxBtn->SetMinY(0);
  218. scrollbarBoxBtn->SetMaxY(height-30);
  219. scrollbarBoxBtn->SetHoldable(true);
  220. scrollbarBoxBtn->SetTrigger(trigHeldA);
  221. }
  222.  
  223. gameIndex = new int[pagesize];
  224. game = new GuiButton * [pagesize];
  225. gameTxt = new GuiText * [pagesize];
  226. gameBg = new GuiImage * [pagesize];
  227. coverImg = new GuiImage * [pagesize];
  228. cover = new GuiImageData * [pagesize];
  229.  
  230. //char buffer[THEME.maxcharacters + 4];
  231. char ID[4];
  232. char IDfull[7];
  233.  
  234. for(int i=0; i < pagesize; i++)
  235. {
  236. /*if (strlen(get_title(&gameList[i])) < (u32)(THEME.maxcharacters + 3))
  237. {
  238. sprintf(buffer, "%s", get_title(&gameList[i]));
  239. }
  240. else
  241. {
  242. sprintf(buffer, get_title(&gameList[i]), THEME.maxcharacters);
  243. buffer[THEME.maxcharacters] = '\0';
  244. strncat(buffer, "...", 3);
  245. }
  246. */////////////////////////////////////////////////
  247.  
  248. struct discHdr *header = &gameList[i];
  249. snprintf (ID,sizeof(ID),"%c%c%c", header->id[0], header->id[1], header->id[2]);
  250. snprintf (IDfull,sizeof(IDfull),"%c%c%c%c%c%c", header->id[0], header->id[1], header->id[2],header->id[3], header->id[4], header->id[5]);
  251.  
  252. snprintf(imgPath, sizeof(imgPath), "%s%s.png", CFG.covers_path, IDfull);
  253. cover[i] = new GuiImageData(imgPath,0); //load short id
  254. if (!cover[i]->GetImage()) //if could not load the short id image
  255. {
  256. delete cover[i];
  257. snprintf(imgPath, sizeof(imgPath), "%s%s.png", CFG.covers_path, ID);
  258. cover[i] = new GuiImageData(imgPath, 0); //load full id image
  259. if (!cover[i]->GetImage())
  260. {
  261. delete cover[i];
  262. snprintf(imgPath, sizeof(imgPath), "%snoimage.png", CFG.covers_path);
  263. cover[i] = new GuiImageData(imgPath, nocover_png); //load no image
  264. }
  265. }
  266.  
  267. coverImg[i] = new GuiImage(cover[i]);
  268. coverImg[i]->SetWidescreen(CFG.widescreen);
  269. coverImg[i]->SetScale(0.8);
  270. coverImg[i]->SetAngle(-30+(i*10));
  271. game[i] = new GuiButton(122,244);
  272. game[i]->SetParent(this);
  273. game[i]->SetAlignment(ALIGN_CENTRE,ALIGN_MIDDLE);
  274. game[i]->SetImage(coverImg[i]);
  275. game[i]->SetPosition(5,GAMESELECTSIZE*i+4);
  276. if (i==0)game[i]->SetPosition(-290,20);
  277. if (i==1)game[i]->SetPosition(-200,-45);
  278. if (i==2)game[i]->SetPosition(-100,-85);
  279. if (i==3)game[i]->SetPosition(0,-100);
  280. if (i==4)game[i]->SetPosition(100,-80);
  281. if (i==5)game[i]->SetPosition(200,-40);
  282. if (i==6)game[i]->SetPosition(290,20);
  283. coverImg[i]->SetPosition(-20,0);
  284. game[i]->SetRumble(false);
  285. game[i]->SetTrigger(trigA);
  286. game[i]->SetSoundClick(btnSoundClick);
  287. }
  288. }
  289.  
  290. /**
  291. * Destructor for the GuiGameGrid class.
  292. */
  293. //GuiGameGrid::~GuiGameGrid()
  294. GuiGameGrid::~GuiGameGrid()
  295. {
  296. if (scrollbaron == 1) {
  297. delete arrowUpBtn;
  298. delete arrowDownBtn;
  299. delete scrollbarBoxBtn;
  300. delete scrollbarImg;
  301. delete arrowDownImg;
  302. delete arrowDownOverImg;
  303. delete arrowUpImg;
  304. delete arrowUpOverImg;
  305. delete scrollbarBoxImg;
  306. delete scrollbarBoxOverImg;
  307. delete scrollbar;
  308. delete arrowDown;
  309. delete arrowDownOver;
  310. delete arrowUp;
  311. delete arrowUpOver;
  312. delete scrollbarBox;
  313. delete scrollbarBoxOver;
  314. }
  315. delete bgGameImg;
  316. delete bgGames;
  317. delete bgGamesEntry;
  318.  
  319. delete trigA;
  320. delete btnSoundClick;
  321.  
  322. // delete optionBg;
  323. for(int i=0; i<pagesize; i++)
  324. {
  325. //delete gameTxt[i];
  326. //delete gameBg[i];
  327. delete game[i];
  328. delete coverImg[i];
  329. delete cover[i];
  330. }
  331. delete [] gameIndex;
  332. delete [] game;
  333. delete [] gameTxt;
  334. delete [] gameBg;
  335. }
  336.  
  337. void GuiGameGrid::SetFocus(int f)
  338. {
  339. LOCK(this);
  340. focus = f;
  341.  
  342. for(int i=0; i<pagesize; i++)
  343. game[i]->ResetState();
  344.  
  345. if(f == 1)
  346. game[selectedItem]->SetState(STATE_SELECTED);
  347. }
  348.  
  349. void GuiGameGrid::ResetState()
  350. {
  351. LOCK(this);
  352. if(state != STATE_DISABLED)
  353. {
  354. state = STATE_DEFAULT;
  355. stateChan = -1;
  356. }
  357.  
  358. for(int i=0; i<pagesize; i++)
  359. {
  360. game[i]->ResetState();
  361. }
  362. }
  363.  
  364. int GuiGameGrid::GetOffset()
  365. {
  366. return changed;
  367. }
  368. int GuiGameGrid::GetClickedOption()
  369. {
  370. int found = -1;
  371. for(int i=0; i<pagesize; i++)
  372. {
  373. if(game[i]->GetState() == STATE_CLICKED)
  374. {
  375. game[i]->SetState(STATE_SELECTED);
  376. found = changed+i;
  377. break;
  378. }
  379. }
  380. return found;
  381. }
  382.  
  383. int GuiGameGrid::GetSelectedOption()
  384. {
  385. int found = -1;
  386. for(int i=0; i<pagesize; i++)
  387. {
  388. if(game[i]->GetState() == STATE_SELECTED)
  389. {
  390. game[i]->SetState(STATE_SELECTED);
  391. found = changed+i;
  392. break;
  393. }
  394. }
  395. return found;
  396. }
  397.  
  398. /****************************************************************************
  399. * FindMenuItem
  400. *
  401. * Help function to find the next visible menu item on the list
  402. ***************************************************************************/
  403.  
  404. int GuiGameGrid::FindMenuItem(int currentItem, int direction)
  405. {
  406. int nextItem = currentItem + direction;
  407.  
  408. if(nextItem < 0 || nextItem >= gameCnt)
  409. return -1;
  410.  
  411. if(strlen(get_title(&gameList[nextItem])) > 0)
  412. return nextItem;
  413. else
  414. return FindMenuItem(nextItem, direction);
  415. }
  416.  
  417. /**
  418. * Draw the button on screen
  419. */
  420. void GuiGameGrid::Draw()
  421. {
  422. LOCK(this);
  423. if(!this->IsVisible())
  424. return;
  425.  
  426. bgGameImg->Draw();
  427.  
  428. int next = listOffset;
  429.  
  430. for(int i=0; i<pagesize; i++)
  431. {
  432. if(next >= 0)
  433. {
  434. game[i]->Draw();
  435. next = this->FindMenuItem(next, 1);
  436. }
  437. else
  438. break;
  439. }
  440.  
  441. if(scrollbaron == 1) {
  442. scrollbarImg->Draw();
  443. arrowUpBtn->Draw();
  444. arrowDownBtn->Draw();
  445. scrollbarBoxBtn->Draw();
  446. }
  447. this->UpdateEffects();
  448. }
  449.  
  450. void GuiGameGrid::Update(GuiTrigger * t)
  451. {
  452. LOCK(this);
  453. if(state == STATE_DISABLED || !t)
  454. return;
  455.  
  456. int next, prev;
  457. static int position2;
  458. if (changed>gameCnt)changed=tooMuch;
  459. if (topPic>7)topPic=0;
  460.  
  461.  
  462. // scrolldelay affects how fast the list scrolls
  463. // when the arrows are clicked
  464. float scrolldelay = 3.5;
  465.  
  466. if (scrollbaron == 1) {
  467. // update the location of the scroll box based on the position in the option list
  468. arrowUpBtn->Update(t);
  469. arrowDownBtn->Update(t);
  470. scrollbarBoxBtn->Update(t);
  471. }
  472.  
  473. next = listOffset;
  474. //char buffer[THEME.maxcharacters + 4];
  475. char ID[4];
  476. char IDfull[7];
  477. char imgPath[100];
  478.  
  479. for(int i=0; i<pagesize; i++)
  480. {
  481. if(next >= 0)
  482. {
  483. if(game[i]->GetState() == STATE_DISABLED)
  484. {
  485. game[i]->SetVisible(true);
  486. game[i]->SetState(STATE_DEFAULT);
  487. }
  488.  
  489.  
  490. /*if (strlen(get_title(&gameList[next])) < (u32)(THEME.maxcharacters + 3))
  491. {
  492. sprintf(buffer, "%s", get_title(&gameList[next]));
  493. }
  494. else
  495. {
  496. sprintf(buffer, get_title(&gameList[next]), THEME.maxcharacters);
  497. buffer[THEME.maxcharacters] = '\0';
  498. strncat(buffer, "...", 3);
  499. }
  500.  
  501. gameTxt[i]->SetText(buffer);
  502. gameTxt[i]->SetPosition(24, 0);*/
  503.  
  504. gameIndex[i] = next;
  505. next = this->FindMenuItem(next, 1);
  506. }
  507. else
  508. {
  509. game[i]->SetVisible(false);
  510. game[i]->SetState(STATE_DISABLED);
  511. }
  512.  
  513. if(focus)
  514. {
  515. if(i != selectedItem && game[i]->GetState() == STATE_SELECTED)
  516. game[i]->ResetState();
  517. else if(i == selectedItem && game[i]->GetState() == STATE_DEFAULT)
  518. game[selectedItem]->SetState(STATE_SELECTED, t->chan);
  519. }
  520.  
  521. game[i]->Update(t);
  522.  
  523. if(game[i]->GetState() == STATE_SELECTED)
  524. {
  525. selectedItem = i;
  526. }
  527. }
  528.  
  529. // pad/joystick navigation
  530. if(!focus)
  531. return; // skip navigation
  532.  
  533. if (scrollbaron == 1) {
  534.  
  535. if (t->Down() ||
  536. arrowDownBtn->GetState() == STATE_CLICKED || ////////////////////////////////////////////down
  537. arrowDownBtn->GetState() == STATE_HELD)
  538. {
  539.  
  540. //changed += pagesize;
  541.  
  542.  
  543.  
  544. for(int i=0; i<pagesize; i++)
  545. { difference=topPic;
  546.  
  547. while (mover<10){
  548. mover++;
  549. if ((difference-4)>0)difference=(topPic+7-4);
  550. if (i==(difference-4)){
  551. game[i]->SetPosition((-290+(9*mover)),(20-(6.5*mover)));
  552. coverImg[i]->SetAngle(-30+(mover*i));}
  553.  
  554. if ((difference-2)>0)difference=(topPic+7-2);
  555. if (i==1)game[i]->SetPosition(-200,-45);
  556. if (i==2)game[i]->SetPosition(-100,-85);
  557. if (i==3)game[i]->SetPosition(0,-100);
  558. if (i==4)game[i]->SetPosition(100,-80);
  559. if (i==5)game[i]->SetPosition(200,-40);
  560. if (i==6)game[i]->SetPosition(290,20);
  561. }
  562. if (mover==10){mover=0;topPic--;}
  563.  
  564. if (changed<gameCnt){
  565. if (i<tooMuch){
  566. struct discHdr *header = &gameList[i+changed];
  567. snprintf (ID,sizeof(ID),"%c%c%c", header->id[0], header->id[1], header->id[2]);
  568. snprintf (IDfull,sizeof(IDfull),"%c%c%c%c%c%c", header->id[0], header->id[1], header->id[2],header->id[3], header->id[4], header->id[5]);
  569.  
  570. snprintf(imgPath, sizeof(imgPath), "%s%s.png", CFG.covers_path, IDfull);
  571. cover[i] = new GuiImageData(imgPath,0); //load short id
  572. if (!cover[i]->GetImage()) //if could not load the short id image
  573. {
  574. delete cover[i];
  575. snprintf(imgPath, sizeof(imgPath), "%s%s.png", CFG.covers_path, ID);
  576. cover[i] = new GuiImageData(imgPath, 0); //load full id image
  577. if (!cover[i]->GetImage())
  578. {
  579. delete cover[i];
  580. snprintf(imgPath, sizeof(imgPath), "%snoimage.png", CFG.covers_path);
  581. cover[i] = new GuiImageData(imgPath, nocover_png); //load no image
  582. }
  583. }
  584.  
  585. //coverImg[i] = new GuiImage(cover[i]);
  586. //coverImg[i]->SetWidescreen(CFG.widescreen);
  587. //coverImg[i]->SetScale(0.5);
  588. //game[i]->SetImage(coverImg[i]);
  589. //game[i]->SetEffect(EFFECT_SLIDE_LEFT | EFFECT_SLIDE_IN, 150);
  590. }
  591. //else { delete game[i];
  592. // delete coverImg[i];
  593. //delete cover[i];}
  594. }
  595. //usleep(500000);
  596.  
  597. }
  598.  
  599. //game[i] = new GuiButton(coverImg[i]->GetWidth(),coverImg[i]->GetHeight());
  600. //game[i]->SetParent(this);
  601. //game[i]->SetImage(coverImg[i]);
  602. //game[i]->SetPosition(5,GAMESELECTSIZE*i+4);
  603. //game[i]->SetRumble(false);
  604. //game[i]->SetTrigger(trigA);
  605. //game[i]->SetSoundClick(btnSoundClick);
  606. ////////////////////////////////////////////////////
  607.  
  608.  
  609.  
  610. /*next = this->FindMenuItem(gameIndex[selectedItem], 1);
  611.  
  612. if(next >= 0)
  613. {
  614. if(selectedItem == pagesize-1)
  615. {
  616. // move list down by 1
  617. listOffset = this->FindMenuItem(listOffset, 1);
  618. }
  619. else if(game[selectedItem+1]->IsVisible())
  620. {
  621. game[selectedItem]->ResetState();
  622. game[selectedItem+1]->SetState(STATE_SELECTED, t->chan);
  623. selectedItem++;
  624. }
  625. scrollbarBoxBtn->Draw();
  626. usleep(10000 * scrolldelay);
  627.  
  628.  
  629. }*/WPAD_ScanPads();
  630. u8 cnt, buttons = NULL;
  631. /* Get pressed buttons */
  632. for (cnt = 0; cnt < 4; cnt++)
  633. buttons |= WPAD_ButtonsHeld(cnt);
  634. if (buttons == WPAD_BUTTON_A) {
  635.  
  636. } else {
  637. arrowDownBtn->ResetState();
  638.  
  639. }
  640.  
  641. }
  642. else if(t->Up() ||
  643. arrowUpBtn->GetState() == STATE_CLICKED || ////////////////////////////////////////////up
  644. arrowUpBtn->GetState() == STATE_HELD)
  645. {changed -= pagesize;
  646. if (changed<11)changed=0;
  647.  
  648.  
  649.  
  650.  
  651. for(int i=0; i<pagesize; i++)
  652. {
  653. game[i]->SetEffect(EFFECT_SLIDE_LEFT | EFFECT_SLIDE_OUT, 50);
  654.  
  655. //usleep(500000);
  656.  
  657. if (changed<gameCnt){
  658.  
  659. struct discHdr *header = &gameList[i+changed];
  660. snprintf (ID,sizeof(ID),"%c%c%c", header->id[0], header->id[1], header->id[2]);
  661. snprintf (IDfull,sizeof(IDfull),"%c%c%c%c%c%c", header->id[0], header->id[1], header->id[2],header->id[3], header->id[4], header->id[5]);
  662.  
  663. snprintf(imgPath, sizeof(imgPath), "%s%s.png", CFG.covers_path, IDfull);
  664. cover[i] = new GuiImageData(imgPath,0); //load short id
  665. if (!cover[i]->GetImage()) //if could not load the short id image
  666. {
  667. delete cover[i];
  668. snprintf(imgPath, sizeof(imgPath), "%s%s.png", CFG.covers_path, ID);
  669. cover[i] = new GuiImageData(imgPath, 0); //load full id image
  670. if (!cover[i]->GetImage())
  671. {
  672. delete cover[i];
  673. snprintf(imgPath, sizeof(imgPath), "%snoimage.png", CFG.covers_path);
  674. cover[i] = new GuiImageData(imgPath, nocover_png); //load no image
  675. }
  676. }
  677.  
  678. coverImg[i] = new GuiImage(cover[i]);
  679. coverImg[i]->SetWidescreen(CFG.widescreen);
  680. coverImg[i]->SetScale(0.5);
  681. game[i]->SetImage(coverImg[i]);
  682. game[i]->SetEffect(EFFECT_SLIDE_LEFT | EFFECT_SLIDE_IN, 50);}
  683. //usleep(500000);
  684.  
  685. }
  686. //prev = this->FindMenuItem(gameIndex[selectedItem], -1);
  687.  
  688. if(prev >= 0)
  689. /*{
  690. if(selectedItem == 0)
  691. {
  692. // move list up by 1
  693. listOffset = prev;
  694. }
  695. else
  696. {
  697. game[selectedItem]->ResetState();
  698. game[selectedItem-1]->SetState(STATE_SELECTED, t->chan);
  699. selectedItem--;
  700. }
  701. scrollbarBoxBtn->Draw();
  702. usleep(10000 * scrolldelay);
  703.  
  704.  
  705. }*/
  706.  
  707. WPAD_ScanPads();
  708. u8 cnt, buttons = NULL;
  709. /* Get pressed buttons */
  710. for (cnt = 0; cnt < 4; cnt++)
  711. buttons |= WPAD_ButtonsHeld(cnt);
  712. if (buttons == WPAD_BUTTON_A) {
  713.  
  714. } else {
  715. arrowUpBtn->ResetState();
  716.  
  717. }
  718. }
  719.  
  720. WPAD_ScanPads();
  721. u8 cnt, buttons = NULL;/////////////////////////////////////////////////////scroll by holding B and tilt wiimote
  722. int position1 = 0;
  723.  
  724.  
  725. position1 = t->wpad.ir.y;
  726.  
  727. if (position2 == 0 && position1 > 0) {
  728. position2 = position1;
  729. }
  730.  
  731. for (cnt = 0; cnt < 4; cnt++)
  732. buttons |= WPAD_ButtonsHeld(cnt);
  733.  
  734. if (buttons == WPAD_BUTTON_B && position1 > 0) {
  735. scrollbarBoxBtn->ScrollIsOn(1);
  736. if (position2 > position1) {
  737.  
  738. prev = this->FindMenuItem(gameIndex[selectedItem], -1);
  739.  
  740. if(prev >= 0)
  741. {
  742. if(selectedItem == 0)
  743. {
  744. // move list up by 1
  745. listOffset = prev;
  746. }
  747. else
  748. {
  749. game[selectedItem]->ResetState();
  750. game[selectedItem-1]->SetState(STATE_SELECTED, t->chan);
  751. selectedItem--;
  752. }
  753. scrollbarBoxBtn->Draw();
  754. usleep(10000 * scrolldelay);
  755.  
  756.  
  757. }
  758.  
  759. } else if (position2 < position1) {
  760.  
  761.  
  762. next = this->FindMenuItem(gameIndex[selectedItem], 1);
  763.  
  764. if(next >= 0)
  765. {
  766. if(selectedItem == pagesize-1)
  767. {
  768. // move list down by 1
  769. listOffset = this->FindMenuItem(listOffset, 1);
  770. }
  771. else if(game[selectedItem+1]->IsVisible())
  772. {
  773. game[selectedItem]->ResetState();
  774. game[selectedItem+1]->SetState(STATE_SELECTED, t->chan);
  775. selectedItem++;
  776. }
  777. scrollbarBoxBtn->Draw();
  778. usleep(10000 * scrolldelay);
  779.  
  780.  
  781. }
  782. }
  783.  
  784. } else if (!buttons) {
  785. scrollbarBoxBtn->ScrollIsOn(0);
  786. position2 = 0;
  787. }
  788.  
  789. if(scrollbarBoxBtn->GetState() == STATE_HELD &&/////////////////////allow dragging of scrollbar box
  790. scrollbarBoxBtn->GetStateChan() == t->chan &&
  791. t->wpad.ir.valid && gameCnt > pagesize)
  792. {
  793. scrollbarBoxBtn->SetPosition(width/2-18+7,0);
  794. //int position = t->wpad.ir.y - 50 - scrollbarBoxBtn->GetTop();
  795. int position = t->wpad.ir.y - 32 - scrollbarBoxBtn->GetTop();
  796.  
  797. //listOffset = (position * gameCnt)/237 - selectedItem;
  798. listOffset = (position * gameCnt)/(25.2 * pagesize) - selectedItem;
  799.  
  800. if(listOffset <= 0)
  801. {
  802. listOffset = 0;
  803. selectedItem = 0;
  804. }
  805. else if(listOffset+pagesize >= gameCnt)
  806. {
  807. listOffset = gameCnt - pagesize;
  808. selectedItem = pagesize-1;
  809. }
  810.  
  811. }
  812. //int positionbar = 237*(listOffset + selectedItem) / gameCnt;
  813. int positionbar = (25.2 * pagesize)*(listOffset + selectedItem) / gameCnt;
  814.  
  815. if(positionbar > (24 * pagesize))//if(positionbar > 216)
  816. positionbar = (24 * pagesize);//positionbar = 216;
  817. scrollbarBoxBtn->SetPosition(width/2-18+7, positionbar+8);
  818.  
  819.  
  820. if(t->Right())/////////////////////////////////////////////////////skip pagesize # of games if right is pressed
  821. {
  822. if(listOffset < gameCnt && gameCnt > pagesize)
  823. {
  824. listOffset =listOffset+ pagesize;
  825. if(listOffset+pagesize >= gameCnt)
  826. listOffset = gameCnt-pagesize;
  827. }
  828. }
  829. else if(t->Left())
  830. {
  831. if(listOffset > 0)
  832. {
  833. listOffset =listOffset- pagesize;
  834. if(listOffset < 0)
  835. listOffset = 0;
  836. }
  837. }
  838.  
  839. }/* else {
  840.  
  841.  
  842. if(t->Down())/////////////////////////////////////////////////////if there isn't a scrollbar and down is pressed
  843. {
  844. next = this->FindMenuItem(gameIndex[selectedItem], 1);
  845.  
  846. if(next >= 0)
  847. {
  848. if(selectedItem == pagesize-1)
  849. {
  850. // move list down by 1
  851. listOffset = this->FindMenuItem(listOffset, 1);
  852. }
  853. else if(game[selectedItem+1]->IsVisible())
  854. {
  855. game[selectedItem]->ResetState();
  856. game[selectedItem+1]->SetState(STATE_SELECTED, t->chan);
  857. selectedItem++;
  858. }
  859. }
  860. }
  861. else if(t->Up())///////////////////////////////////////////////////up
  862. {
  863. prev = this->FindMenuItem(gameIndex[selectedItem], -1);
  864.  
  865. if(prev >= 0)
  866. {
  867. if(selectedItem == 0)
  868. {
  869. // move list up by 1
  870. listOffset = prev;
  871. }
  872. else
  873. {
  874. game[selectedItem]->ResetState();
  875. game[selectedItem-1]->SetState(STATE_SELECTED, t->chan);
  876. selectedItem--;
  877. }
  878. }
  879. }
  880. }*/
  881.  
  882. if(updateCB)
  883. updateCB(this);
  884. }
  885.  
  886. void GuiGameGrid::Reload(struct discHdr * l, int count)
  887. {
  888. LOCK(this);
  889. gameList = l;
  890. gameCnt = count;
  891. scrollbaron = (gameCnt > pagesize) ? 1 : 0;
  892. selectedItem = 0;
  893. listOffset = 0;
  894.  
  895. for(int i=0; i<pagesize; i++)
  896. game[i]->ResetState();
  897. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!