guifuncs.c

linux下的任天堂模拟器代码。供大家参考。

    else
    {
      return;
    }
  }

  if ((list[(size_t)*list] = malloc(strlen(p)+1)))
  {
    strcpy(list[(size_t)*list], p);
    list[0]++;
    list[(size_t)*list] = 0;
  }
  *reallist = list;
}

//Make sure ZRomPath contains a full absolute directory name before calling
void populate_lists(unsigned int lists, bool snes_ext_match)
{
  DIR *dir;

  if ((lists&LIST_DN) && (strlen(ZRomPath) > ROOT_LEN))
  {
    add_list(&d_names, "..");
  }

  if ((dir = opendir(ZRomPath)))
  {
    struct stat stat_buffer;
    struct dirent *entry;

    while ((entry = readdir(dir)))
    {
      if ((*entry->d_name != '.') && !stat_dir(ZRomPath, entry->d_name, &stat_buffer))
      {
        if (S_ISDIR(stat_buffer.st_mode))
        {
          if (lists&LIST_DN)
          {
            add_list(&d_names, entry->d_name);
          }
        }
        else if (!snes_ext_match || snes_extension_match(entry->d_name))
        {
          if (_USE_LFN && (lists&LIST_LFN))
          {
            add_list(&lf_names, entry->d_name);
          }

          if (lists&LIST_IN)
          {
            char namebuffer[22];
            add_list(&i_names, get_rom_name(entry->d_name, namebuffer, &stat_buffer));
          }

#ifdef __MSDOS__
          if (lists&LIST_ETN)
          {
            if (!_USE_LFN) //_USE_LFN won't be true when running under pure DOS
            {
              add_list(&et_names, entry->d_name);
            }
            else
            {
              char *sfn = realpath_sfn_dir(ZRomPath, entry->d_name, 0);
              if (sfn)
              {
                add_list(&et_names, basename(sfn));
                free(sfn);
              }
              else
              {
                char sfn[13];
                _lfn_gen_short_fname(entry->d_name, sfn);
                add_list(&et_names, sfn);
              }
            }
          }
#endif
        }
      }
    }
    closedir(dir);
  }

  if (lists&LIST_DN)
  {
#ifndef __UNIXSDL__
    unsigned int drives = GetLogicalDrives(), i = 0;
#endif

    if (d_names)
    {
      unsigned int offset = (d_names[2][0] == '.') ? 3 : 2;
      sort((intptr_t *)d_names, offset, (size_t)(*d_names), swapdirs);
    }

#ifndef __UNIXSDL__
    while (i < 26)
    {
      if (drives&BIT(i))
      {
        char drive[] = { '[', 'A', ':', ']', 0 };
        drive[1] = 'A'+i;
        add_list(&d_names, drive);
      }
      i++;
    }
#endif
  }

  if ((lists&LIST_IN) && i_names)
  {
    sort((intptr_t *)i_names, 2, (size_t)(*i_names), swapfiles);
  }
  else if ((lists&LIST_LFN) && lf_names)
  {
    sort((intptr_t *)lf_names, 2, (size_t)(*lf_names), swapfiles);
  }
  else if ((lists&LIST_ETN) && et_names)
  {
    sort((intptr_t *)et_names, 2, (size_t)(*et_names), swapfiles);
  }
}

static void memswap(void *p1, void *p2, size_t p2len)
{
  char *ptr1 = (char *)p1;
  char *ptr2 = (char *)p2;

  const size_t p1len = ptr2 - ptr1;
  unsigned char byte;
  while (p2len--)
  {
    byte = *ptr2++;
    memmove(ptr1+1, ptr1, p1len);
    *ptr1++ = byte;
  }
}

extern unsigned char GUIwinptr, GUIcmenupos, GUIpmenupos;
extern unsigned char GUIwinorder[], GUIwinactiv[], pressed[];

extern char GUIPrevMenuData[];

void powercycle(bool, bool);

void GUIloadfilename(char *filename)
{
  char *p = strdupcat(ZRomPath, filename);
  if (p)
  {
    if (init_rom_path(p)) { powercycle(false, true); }
    free(p);
  }
  if (GUIwinptr) { GUIcmenupos = GUIpmenupos; }
}

void loadquickfname(const unsigned char slot)
{
  if (prevloaddnamel[1+slot*512]) // replace with better test
  {
    strcpy(ZRomPath, (char *)prevloaddnamel+1+slot*512);
    strcatslash(ZRomPath);
    strcpy(ZCartName, (char *)prevloadfnamel+slot*512);

    if (!access_dir(ZRomPath, ZCartName, R_OK))
    {
      if (slot || !prevlfreeze)
      {
        // move menuitem to top
        memswap(prevloadiname,prevloadiname+slot*28,28);
        memswap(prevloadfnamel,prevloadfnamel+slot*512,512);
        memswap(prevloaddnamel,prevloaddnamel+slot*512,512);
      }

      GUIloadfilename(ZCartName);
    }
  }
}

void GUIQuickLoadUpdate()
{
  size_t entry_size, copy_num, i = 10;
  char *src;

  memcpy(GUIPrevMenuData+347, (prevlfreeze) ? " ON " : " OFF", 4);

  src = (char *)prevloadiname;
  entry_size = 28;
  copy_num = 28; //full window width

  while (i--)
  {
    char *p_src = src + i*entry_size;
    char *p_dest = GUIPrevMenuData+3 + i*32;
    size_t srclen = strlen(p_src);

    if (srclen >= copy_num)
    {
      strncpy(p_dest, p_src, copy_num);
      if (srclen > copy_num) { memset(p_dest+25, '.', 3); }
    }
    else
    {
      strncpy(p_dest, p_src, srclen);
      memset(p_dest+srclen, ' ', 28-srclen);
    }
  }
}


int GUIcurrentviewloc; //current file position
int GUIcurrentcursloc; //current cursor position (GUI)
int GUIcurrentdirviewloc; //current directory position
int GUIcurrentdircursloc; //current dir position (GUI)
int GUIdirentries;
int GUIfileentries;

void free_all_file_lists()
{
  free_list(&d_names);
  free_list(&i_names);
  free_list(&lf_names);
  free_list(&et_names);
}

void GetLoadData()
{
  GUIcurrentviewloc = GUIcurrentcursloc = GUIcurrentdirviewloc = GUIcurrentdircursloc = 0;

  free_all_file_lists();

  switch (GUIloadfntype)
  {
    case 0: //LFN
      populate_lists(LIST_DN|LIST_ETN|LIST_LFN, !showallext);
      selected_names = lf_names ? lf_names : et_names;
      break;
    case 1: //IN
      populate_lists(LIST_DN|LIST_MAIN|LIST_IN, !showallext);
      selected_names = i_names;
      break;
    default:
      populate_lists(LIST_DN|LIST_MAIN, !showallext);
      selected_names = main_names;
      break;
  }
  selected_names += 2;
  GUIfileentries = main_names ? ((unsigned int)(*main_names))-2 : 0;
  GUIdirentries = d_names ? ((unsigned int)(*d_names))-2 : 0;
}

unsigned int GUIcurrentfilewin;
unsigned int GUIdirStartLoc;

void GUILoadData()
{
  char *nameptr;

  GUICBHold = 0;
  if (GUIcurrentfilewin) // directories
  {
    nameptr = d_names[GUIcurrentdircursloc+2];

    strcatslash(ZRomPath);
    #ifndef __UNIXSDL__
    if ((strlen(nameptr) == 4) && (nameptr[2] == ':')) // MS drives are stored as '[?:]',
    { // so we can't use quick string catenation to browse through
      strncpy(ZRomPath, nameptr+1, 2);
      ZRomPath[2] = '\\';
      ZRomPath[3] = 0;
    }
    else
    #endif
    {
      if (!strcmp(nameptr, ".."))
      {
        strdirname(ZRomPath);
      }
      else
      {
        strcat(ZRomPath, nameptr);
      }
      strcatslash(ZRomPath);
    }

    GetLoadData();
  }
  else // files
  {
    nameptr = main_names[GUIcurrentcursloc+2];

    strcpy(ZCartName, nameptr);

    if (!prevlfreeze)
    {
      int i = 0;
      bool dupfound = false;
      bool modheader = true;

      while (!dupfound && i<10)
      {
        dupfound = (!fnamencmp(nameptr, (char *)prevloadfnamel+i*512, 512) && (!fnamencmp(ZRomPath, (char *)prevloaddnamel+i*512+1, 512)));
        if(dupfound && modheader)
        {
          strncpy((char *)prevloadiname+i*28, selected_names[GUIcurrentcursloc], 28);
          prevloadiname[i*28+27] = 0;
          modheader = false;
        }
        i++;
      }
      i--;

      if (!dupfound)
      {
        strncpy((char *)prevloadiname+9*28, selected_names[GUIcurrentcursloc], 28);
        prevloadiname[9*28+27] = 0;
        strcpy((char *)prevloaddnamel+9*512+1, ZRomPath);
        strcpy((char *)prevloadfnamel+9*512, ZCartName);
      }

      loadquickfname(i);
    }
    else
    {
      GUIloadfilename(ZCartName);
    }

    GUIwinactiv[1] = 0; // close load dialog
    GUIwinorder[--GUIwinptr] = 0;
  }
}

extern char GUILoadTextA[];
extern unsigned char GUILoadPos;

void GUILoadManualDir()
{

  if (*GUILoadTextA)
  {
    char path_buff[PATH_SIZE];
    bool realpath_success;

    if ((GUILoadPos > ROOT_LEN) && (GUILoadTextA[GUILoadPos-1] == DIR_SLASH_C))
    {
      GUILoadTextA[GUILoadPos-1] = 0;
    }

    realpath_success = (int)realpath_dir(ZRomPath, GUILoadTextA, path_buff);
    if (realpath_success)
    {
      struct stat stat_buffer;
      if (!stat(path_buff, &stat_buffer))
      {
        if (S_ISDIR(stat_buffer.st_mode))
        {
          strcpy(ZRomPath, path_buff);
          strcatslash(ZRomPath);
          GetLoadData();
        }
        else
        {
          if (init_rom_path(path_buff)) { powercycle(false, true); }
        }
        return;
      }
    }
  }

  GUILoadData();