[vrfileman] / src / fs.cc

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <string>
#include <map>
#include <algorithm>
#include <unistd.h>
#include <dirent.h>
#include <sys/stat.h>
#include "fs.h"
#include "icon.h"
#include "gmath/gmath.h"
#include "opengl.h"
#include "app.h"
#include "drawtext.h"

static IconRenderer *iconrend;

static std::map<std::string, FSNode*> node_cache;
static FSNode *cur_node;
static int start_child;

static dtx_font *fat_font;
#define FAT_FONT_SZ     32


bool init_fs(const char *path)
{
        iconrend = new ShapesIcons;
        if(!iconrend->init()) {
                return false;
        }

        if(!(fat_font = dtx_open_font("data/fat.font", FAT_FONT_SZ))) {
                fprintf(stderr, "failed to open font file data/fat.font\n");
                return false;
        }

        cur_node = get_fsnode(path);
        cur_node->expand();
        return true;
}

void cleanup_fs()
{
        std::map<std::string, FSNode*>::iterator it = node_cache.begin();
        while(it != node_cache.end()) {
                FSNode *node = it++->second;
                delete node;
        }
        node_cache.clear();
        delete iconrend;
}

static Vec3 icon_pos(int row, int col, int ncols, float row_spacing, float radius)
{
        float angle = 2.0 * M_PI * (float)col / (float)ncols;
        float x = sin(angle) * radius;
        float z = -cos(angle) * radius;
        float y = (float)row * row_spacing;
        return Vec3(x, y, z);
}

static float icon_angle(int col, int ncols, float max_angle = 0.0f)
{
        if(max_angle > 0) {
                return max_angle * ((float)col / (float)(ncols - 1) - 0.5);
        }
        return 2.0 * M_PI * (float)col / (float)ncols;
}

void draw_fs()
{
        static const float row_spacing = 2.0;
        static const float radius = 0.6;
        static const float umax = 0.42;
        static const float max_icon_angle = M_PI * 2.0 * umax;

        int max_ncols = std::max<int>(1, umax * 16);

        Mat4 base_xform;
        base_xform.rotate(time_sec, 0, 0);
        base_xform.rotate(0, 0, time_sec * 0.5);
        base_xform.translate(0, 1.65, 0);

        glUseProgram(0);
        glDisable(GL_TEXTURE_2D);

        int nchildren = (int)cur_node->children.size();
        int ncols = std::min(cur_node->nfiles, max_ncols);

        int first = start_child % ncols;
        int col = 0, row = 0;

        for(int i=0; i<nchildren; i++) {
                int idx = (i + first) % nchildren;
                FSNode *node = cur_node->children[idx];

                if(node->type == FSTYPE_DIR) {
                        continue;
                }

                float angle = icon_angle(col, ncols, max_icon_angle);

                Mat4 xform = base_xform;
                xform.translate(0, row * row_spacing, -radius);
                xform.rotate_y(angle);

                glPushMatrix();
                glMultMatrixf(xform[0]);
                iconrend->draw(node);
                glPopMatrix();

                glPushMatrix();
                xform = Mat4::identity;
                xform.translate(-dtx_string_width(node->path.get_name()) / 2.0, 0, 0);
                xform.scale(0.001);
                xform.translate(0, 1.54 + row * row_spacing, -radius);
                xform.rotate_y(angle);
                glMultMatrixf(xform[0]);

                dtx_string(node->path.get_name());
                glPopMatrix();

                if(++col >= ncols) {
                        col = 0;
                        ++row;
                }
        }
}

FSNode *get_fsnode(const char *path)
{
        char *abspath = make_abs_path(path);

        FSNode *node = node_cache[abspath];
        if(!node) {
                node = new FSNode;
                node->path = path;

                struct stat st;
                if(stat(node->path, &st) == -1) {
                        fprintf(stderr, "failed to stat: %s\n", node->path.get_path());
                        delete node;
                        return 0;
                }
                node->size = st.st_size;

                switch(st.st_mode & S_IFMT) {
                case S_IFREG:
                        node->type = FSTYPE_FILE;
                        break;

                case S_IFDIR:
                        node->type = FSTYPE_DIR;
                        break;

                case S_IFBLK:
                case S_IFCHR:
                        node->type = FSTYPE_DEV;
                        break;

                default:
                        node->type = FSTYPE_UNKNOWN;
                }
                node_cache[abspath] = node;
        }

        return node;
}

FSNode *get_fsnode(const char *dir, const char *name)
{
        if(!dir) {
                return get_fsnode(name);
        }
        if(!name || *name == '/') {
                return 0;
        }

        int len = strlen(dir) + 1 + strlen(name);
        char *buf = new char[len + 1];
        sprintf(buf, "%s/%s", dir, name);
        FSNode *res = get_fsnode(buf);
        delete [] buf;
        return res;
}

// ---- FSNode implementation ----
FSNode::FSNode()
{
        type = FSTYPE_UNKNOWN;
        size = 0;
        parent = 0;
        nfiles = ndirs = 0;
}

bool FSNode::expand()
{
        if(type != FSTYPE_DIR) {
                return false;
        }

        DIR *dir = opendir(path);
        if(!dir) {
                fprintf(stderr, "failed to open dir: %s: %s\n", path.get_path(), strerror(errno));
                return false;
        }

        struct dirent *dent;
        while((dent = readdir(dir))) {
                if(strcmp(dent->d_name, ".") == 0 || strcmp(dent->d_name, "..") == 0) {
                        continue;
                }

                FSNode *node = get_fsnode(path, dent->d_name);
                if(!node) continue;

                children.push_back(node);
                switch(node->type) {
                case FSTYPE_FILE:
                        ++nfiles;
                        break;
                case FSTYPE_DIR:
                        ++ndirs;
                default:
                        break;
                }
        }
        printf("expanded %d children\n", (int)children.size());

        parent = get_fsnode(path.get_parent());
        return true;
}