source: mainline/uspace/app/appslauncher/launcher.c@ 4bfb5a0

/*
 * Copyright (c) 2023 SimonJRiddix
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @addtogroup launcher
 * @{
 */
/** @file Launcher
 */

#include "include/window.h"
#include "include/label.h"
#include "include/button.h"
#include "include/control.h"

#include <task.h>

#define newVector(name) vector name; vector_init(&name);
#define vector_get(v, pos) v.Get(&v, pos)
#define vector_count(v) v.Count(&v)

typedef struct sApp application;
struct sApp
{
    char* name;
    char* location;
    char** arguments;
};

typedef struct scategory category;
struct scategory
{
        char* name;
        //icon_t icon;
    vector applications;
};

// init application categories vector
vector categories;

// init window ui
Window window;

// extern application launcher code
extern int app_launchl(const char *, ...);

// on tile click
static void pb_clicked(ui_pbutton_t *pbutton, void * args)
{       
        if(app_launchl(((application *) args)->location, NULL) == EOK)
        {
                window.destroy(&window);
                task_kill(task_get_id());
        }
}

int main(int argc, char *argv[])
{
    vector_init(&categories);
    
    /// ACCESSORIES ///
    
    category category_accessory;
    vector_init(&category_accessory.applications);
    category_accessory.name = (char*) "Accessory";
    
    application notepad;
    notepad.name = (char*) "Notepad";
    notepad.location = (char*) "/app/notepad";
    category_accessory.applications.Add(&category_accessory.applications, &notepad);
    
    application calc;
    calc.name = (char*) "Calculator";
    calc.location = (char*) "/app/calculator";
    category_accessory.applications.Add(&category_accessory.applications, &calc);
    
    categories.Add(&categories, &category_accessory);
    
    /// TEST ///
    
    category category_test;
    vector_init(&category_test.applications);
    category_test.name = (char*) "Test";
    
    application ui_demo;
    ui_demo.name = (char*) "UI Demo";
    ui_demo.location = (char*) "/app/uidemo";
    category_test.applications.Add(&category_test.applications, &ui_demo);
    
    application gfx_demo;
    gfx_demo.name = (char*) "GFX Test";
    gfx_demo.location = (char*) "/app/gfxdemo";
    char* gfx_demo_args[1];
    gfx_demo_args[0] = (char*) "ui";
    gfx_demo.arguments = gfx_demo_args;
    category_test.applications.Add(&category_test.applications, &gfx_demo);
    
    categories.Add(&categories, &category_test);
        
    /// SYSTEM ///
    
    category category_system;
    category category_left_menu;
    vector_init(&category_system.applications);
    vector_init(&category_left_menu.applications);
    category_system.name = (char*) "System";
    category_left_menu.name = (char*) "System";
    
    application system_shutdown;
    system_shutdown.name = (char*) "Shutdown";
    system_shutdown.location = (char*) "/app/systemshutdown";
    category_left_menu.applications.Add(&category_left_menu.applications, &system_shutdown);
    
    application system_restart;
    system_restart.name = (char*) "Restart";
    system_restart.location = (char*) "/app/systemrestart";
    category_left_menu.applications.Add(&category_left_menu.applications, &system_restart);
    
    application system_setting;
    system_setting.name = (char*) "Setting";
    system_setting.location = (char*) "/app/setting";
    category_system.applications.Add(&category_system.applications, &system_setting);
    category_left_menu.applications.Add(&category_left_menu.applications, &system_setting);
    
    application sys_terminal;
    sys_terminal.name = (char*) "Terminal";
    sys_terminal.location = (char*) "/app/terminal";
    category_system.applications.Add(&category_system.applications, &sys_terminal);
    category_left_menu.applications.Add(&category_left_menu.applications, &sys_terminal);
    
    categories.Add(&categories, &category_system);
        
        // Create window
        init_window(&window, "window1", "Application Launcher");
        
        // Create small tiles on the left for system actions (shutdown, reboot, terminal...)
        for(int c = 0; c < vector_count(category_left_menu.applications); c++)
        {
                Button button_left;
                //char button_left_name[256];
                //sprintf(button_left_name, "btnl%d", c);
                init_button(&button_left, "button1", &window);
                button_left.rect.p0.x = 10;
                button_left.rect.p0.y = window.params.rect.p1.y - ( (c + 1) * (30 + 10));
                button_left.rect.p1.x = 50;
                button_left.rect.p1.y = button_left.rect.p0.y + 30;
                button_left.update_rect(&button_left);
                application* a = vector_get(category_left_menu.applications, c);
                button_left.set_text(&button_left, a->name);
                button_left.paint(&button_left);
                button_left.set_callback(&button_left, pb_clicked, a);
        }
        
        size_t separators = 0;
        
        int row = 0;
        int col = 0;
        
        // Populate categories and big application tiles
        for(int current_category = 0; current_category < vector_count(categories); current_category++)
        {
                category* cat = vector_get(categories, current_category);
                
                Label label_category;           
                label_category.rect.p0.x = 60;
                label_category.rect.p0.y = (30*row) + ( row * 10 ) + (row * 80) + 40;
                label_category.rect.p1.x = label_category.rect.p0.x + 170;
                label_category.rect.p1.y = label_category.rect.p0.y + 10;
                //char label_category_name[256];
                //sprintf(label_category_name, "lbl%d", current_category);
                init_label(&label_category, "label1", &window); 
                label_category.set_text(&label_category, cat->name);
                label_category.update_rect(&label_category);
                label_category.paint(&label_category);
                
                // Populate big application tiles
                for(int application_in_category = 0; application_in_category < vector_count(cat->applications); application_in_category++)
                {
                        application* app;
                        app = cat->applications.Get(&cat->applications, application_in_category);
                        
                        // if application name is empty, is not an application but a separator
                        if(str_cmp("", app->name) == 0)
                        {
                                separators++;
                        }
                        else
                        {
                                int c_pos = 70 + ( col * 20 ) + ( col * 80 );
                                if((c_pos + 80) > window.params.rect.p1.x)
                                {
                                        col = 0;
                                        c_pos = 70 + ( col * 20 ) + ( col * 80 );
                                        row++;
                                }
                                
                                Button button_application;
                                //char button_application_name[256];
                                //sprintf(button_application_name, "btn%d", (application_in_category+1)*c);
                                init_button(&button_application, "button1", &window);
                                button_application.rect.p0.x = c_pos;
                                button_application.rect.p0.y = 20 + (30*row) + ( row * 10 ) + (row * 80) + 40;
                                button_application.rect.p1.x = button_application.rect.p0.x + 80;
                                button_application.rect.p1.y = button_application.rect.p0.y + 80;
                                button_application.update_rect(&button_application);
                                button_application.set_text(&button_application, app->name);
                                button_application.set_callback(&button_application, pb_clicked, app);
                                
                                col++;
                        }
                }
                
                row++;
                col = 0;
        }

        window.draw(&window);
        
        window.destroy(&window);
        
        return 0;
}

/** @}
 */