Index: uspace/app/appslauncher/doc/doxygroups.h =================================================================== --- uspace/app/appslauncher/doc/doxygroups.h (revision 4bfb5a01e39428a8780576ab646b543a6a873151) +++ uspace/app/appslauncher/doc/doxygroups.h (revision 4bfb5a01e39428a8780576ab646b543a6a873151) @@ -0,0 +1,4 @@ +/** @addtogroup appslauncher appslauncher + * @brief Applications launcher + * @ingroup apps + */ Index: uspace/app/appslauncher/include/button.h =================================================================== --- uspace/app/appslauncher/include/button.h (revision 4bfb5a01e39428a8780576ab646b543a6a873151) +++ uspace/app/appslauncher/include/button.h (revision 4bfb5a01e39428a8780576ab646b543a6a873151) @@ -0,0 +1,192 @@ +/* + * 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. + */ + +#ifndef UI_BUTTON_H +#define UI_BUTTON_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "window.h" + +typedef struct sButton Button; +struct sButton +{ + char* name; + char* text; + + size_t max_length; + + ui_fixed_t *fixed; + ui_pbutton_t *button; + ui_pbutton_flags_t flags; + + gfx_rect_t rect; + + void (*set_text)(Button* w, char* text); + char* (*get_text)(Button* w); + + ui_pbutton_cb_t pbutton_cb; + void (*set_callback)(Button* w, void (*pb_clicked)(ui_pbutton_t *, void *), void* extra); + + void (*update_rect)(Button* w); + void (*set_flags)(Button* w, ui_pbutton_flags_t flags); + void (*update_flags)(Button* w); + void (*paint)(Button* w); + + void (*set_horizontal_align)(Button* w, gfx_halign_t a); + void (*set_vertical_align)(Button* w, gfx_halign_t a); + void (*destroy)(Button* w); +}; + +int init_button(Button* w, const char * name, Window* window); +void button_set_callback(Button* w, void (*pb_clicked)(ui_pbutton_t *, void *), void* extra); +void button_set_text(Button* w, char* text); +char* button_get_text(Button* w); +void button_update_rect(Button* w); +void button_set_flags(Button* w, ui_pbutton_flags_t flags); +void button_update_flags(Button* w); +void button_paint(Button* w); +void button_set_horizontal_align(Button* w, gfx_halign_t a); +void button_set_vertical_align(Button* w, gfx_halign_t a); +void button_destroy(Button* w); + +void button_set_text(Button* w, char* text) +{ + //free(w->text); + size_t szt = str_size(text) + 1; + if ( szt > w->max_length ) + szt = w->max_length; + w->text = malloc(sizeof(char) * szt); + str_cpy(w->text, szt, text); + ui_pbutton_set_caption(w->button, w->text); + ui_pbutton_paint(w->button); +} + +char* button_get_text(Button* w) +{ + return w->text; +} + +void button_update_rect(Button* w) +{ + ui_pbutton_set_rect(w->button, &w->rect); +} + +void button_paint(Button* w) +{ + ui_pbutton_paint(w->button); +} + +void button_set_horizontal_align(Button* w, gfx_halign_t a) +{ + //ui_pbutton_set_halign(w->button, a); +} + +void button_set_vertical_align(Button* w, gfx_halign_t a) +{ + //ui_pbutton_set_valign(w->button, a); +} + +void button_set_callback(Button* w, void (*pb_clicked2)(ui_pbutton_t *, void *), void* extra) +{ + ui_pbutton_cb_t pbutton_cb = { + .clicked = pb_clicked2 + }; + w->pbutton_cb = pbutton_cb; + ui_pbutton_set_cb(w->button, &w->pbutton_cb, extra); +} + +void button_set_flags(Button* w, ui_pbutton_flags_t flags) +{ + w->flags = flags; + ui_pbutton_set_flags(w->button, w->flags); +} + +void button_update_flags(Button* w) +{ + ui_pbutton_set_flags(w->button, w->flags); +} + +void button_destroy(Button* w) +{ + ui_pbutton_destroy(w->button); +} + +int init_button(Button* w, const char * name, Window* window) +{ + w->max_length = 50; + w->text = malloc(sizeof(char) * 7); + str_cpy(w->text, 7, (char*) "Button1"); + + errno_t rc = ui_pbutton_create(window->ui_res, w->text, &w->button); + if (rc != EOK) { + printf("Error creating button.\n"); + return rc; + } + + /*w->rect.p0.x = 15; + w->rect.p0.y = 130; + w->rect.p1.x = 190; + w->rect.p1.y = w->rect.p0.y + 28;*/ + ui_pbutton_set_rect(w->button, &w->rect); + + rc = ui_fixed_add(window->fixed, ui_pbutton_ctl(w->button)); + if (rc != EOK) { + printf("Error adding control to layout.\n"); + return rc; + } + + w->set_text = button_set_text; + w->get_text = button_get_text; + w->update_rect = button_update_rect; + w->set_flags = button_set_flags; + w->update_flags = button_update_flags; + w->paint = button_paint; + + w->set_horizontal_align = button_set_horizontal_align; + w->set_vertical_align = button_set_vertical_align; + + w->set_callback = button_set_callback; + + w->destroy = button_destroy; + + return EOK; +} + +#endif Index: uspace/app/appslauncher/include/control.h =================================================================== --- uspace/app/appslauncher/include/control.h (revision 4bfb5a01e39428a8780576ab646b543a6a873151) +++ uspace/app/appslauncher/include/control.h (revision 4bfb5a01e39428a8780576ab646b543a6a873151) @@ -0,0 +1,37 @@ +/* + * 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. + */ + +#ifndef UI_CONTROL_H +#define UI_CONTROL_H + +struct control +{ + char * name; +}; + +#endif Index: uspace/app/appslauncher/include/label.h =================================================================== --- uspace/app/appslauncher/include/label.h (revision 4bfb5a01e39428a8780576ab646b543a6a873151) +++ uspace/app/appslauncher/include/label.h (revision 4bfb5a01e39428a8780576ab646b543a6a873151) @@ -0,0 +1,161 @@ +/* + * 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. + */ + +#ifndef UI_LABEL_H +#define UI_LABEL_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "window.h" + +typedef struct sLabel Label; +struct sLabel +{ + char* name; + char* text; + + size_t max_length; + + ui_fixed_t *fixed; + ui_label_t *label; + + gfx_rect_t rect; + + void (*set_text)(Label* w, char* text); + char* (*get_text)(Label* w); + + void (*update_rect)(Label* w); + void (*paint)(Label* w); + + void (*set_horizontal_align)(Label* w, gfx_halign_t a); + void (*set_vertical_align)(Label* w, gfx_halign_t a); + void (*destroy)(Label* w); +}; + +int init_label(Label* w, const char * name, Window* window); +void label_set_text(Label* w, char* text); +char* label_get_text(Label* w); +void label_update_rect(Label* w); +void label_paint(Label* w); +void label_set_horizontal_align(Label* w, gfx_halign_t a); +void label_set_vertical_align(Label* w, gfx_halign_t a); +void label_destroy(Label* w); + +void label_set_text(Label* w, char* text) +{ + //free(&w->text); + size_t szt = str_size(text) + 1; + if ( szt > w->max_length ) + szt = w->max_length; + w->text = malloc(sizeof(char) * szt); + str_cpy(w->text, szt, text); + ui_label_set_text(w->label, w->text); + if(true) + ui_label_paint(w->label); +} + +char* label_get_text(Label* w) +{ + return w->text; +} + +void label_update_rect(Label* w) +{ + ui_label_set_rect(w->label, &w->rect); +} + +void label_paint(Label* w) +{ + ui_label_paint(w->label); +} + +void label_set_horizontal_align(Label* w, gfx_halign_t a) +{ + ui_label_set_halign(w->label, a); +} + +void label_set_vertical_align(Label* w, gfx_halign_t a) +{ + ui_label_set_valign(w->label, a); +} + +void label_destroy(Label* w) +{ + ui_label_destroy(w->label); +} + +int init_label(Label* w, const char * name, Window* window) +{ + w->max_length = 50; + w->text = malloc(sizeof(char) * 6); + str_cpy(w->text, 6, (char*) "Label1"); + + errno_t rc = ui_label_create(window->ui_res, w->text, &w->label); + if (rc != EOK) { + printf("Error creating label.\n"); + return rc; + } + + /*w->rect.p0.x = 0; + w->rect.p0.y = 0; + w->rect.p1.x = 0; + w->rect.p1.y = 0;*/ + ui_label_set_rect(w->label, &w->rect); + ui_label_set_halign(w->label, gfx_halign_left); + + rc = ui_fixed_add(window->fixed, ui_label_ctl(w->label)); + if (rc != EOK) { + printf("Error adding control to layout.\n"); + return rc; + } + + w->set_text = label_set_text; + w->get_text = label_get_text; + w->update_rect = label_update_rect; + w->paint = label_paint; + + w->set_horizontal_align = label_set_horizontal_align; + w->set_vertical_align = label_set_vertical_align; + + w->destroy = label_destroy; + + return EOK; +} + +#endif Index: uspace/app/appslauncher/include/vector.h =================================================================== --- uspace/app/appslauncher/include/vector.h (revision 4bfb5a01e39428a8780576ab646b543a6a873151) +++ uspace/app/appslauncher/include/vector.h (revision 4bfb5a01e39428a8780576ab646b543a6a873151) @@ -0,0 +1,78 @@ +/* + * 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. + */ + +/****************************************************************************** + + Vector in c + +*******************************************************************************/ + +#ifndef SJR_VECTOR_H +#define SJR_VECTOR_H + +#include +#include +#define VECTOR_INIT_CAPACITY 2 +#define UNDEFINE -1 +#define SUCCESS 0 +#define VECTOR_INIT(vec) vector vec;\ + vector_init(&vec) + +//Store and track the stored data +typedef struct sVectorList +{ + void** items; + int capacity; + int total; +} sVectorList; + +//structure contain the function pointer +typedef struct sVector vector; +struct sVector +{ + sVectorList vectorList; + //function pointers + int (*Count)(vector*); + int (*Resize)(vector*, int); + int (*Add)(vector*, void*); + int (*Set)(vector*, int, void*); + void* (*Get)(vector*, int); + int (*Delete)(vector*, int); + int (*Clear)(vector*); +}; + +int vector_total(vector* v); +int vector_resize(vector* v, int capacity); +int vector_push_back(vector* v, void* item); +int vector_set(vector* v, int index, void* item); +void* vector_get(vector* v, int index); +int vector_delete(vector* v, int index); +int vector_clear(vector* v); +void vector_init(vector* v); + +#endif Index: uspace/app/appslauncher/include/window.h =================================================================== --- uspace/app/appslauncher/include/window.h (revision 4bfb5a01e39428a8780576ab646b543a6a873151) +++ uspace/app/appslauncher/include/window.h (revision 4bfb5a01e39428a8780576ab646b543a6a873151) @@ -0,0 +1,131 @@ +/* + * 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. + */ + +#ifndef UI_WINDOW_H +#define UI_WINDOW_H + +#include "vector.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static const char *display_spec = UI_DISPLAY_DEFAULT; + +typedef struct sWindow Window; +struct sWindow +{ + vector controls; + char * name; + + ui_t *ui; + ui_resource_t *ui_res; + ui_wnd_params_t params; + ui_window_t *window; + ui_fixed_t *fixed; + + int (*draw)(Window* w); + void (*destroy)(Window* w); +}; + +int draw_window(Window* w); +void destroy_window(Window* w); +int init_window(Window* w, const char * name, const char * caption); + +int draw_window(Window* w) +{ + ui_window_add(w->window, ui_fixed_ctl(w->fixed)); + + errno_t rc = ui_window_paint(w->window); + if (rc != EOK) { + printf("Error painting window.\n"); + return rc; + } + + ui_run(w->ui); + + return EOK; +} + +void destroy_window(Window* w) +{ + ui_window_destroy(w->window); + ui_destroy(w->ui); +} + +int init_window(Window* w, const char * name, const char * caption) +{ + //vector_init(&w->controls); + //w->name = name; + + errno_t rc = ui_create(display_spec, &w->ui); + if (rc != EOK) { + printf("Error creating UI on display %s.\n", display_spec); + return rc; + } + + ui_wnd_params_init(&w->params); + w->params.caption = caption; + w->params.placement = ui_wnd_place_bottom_left; + w->params.rect.p0.x = 0; + w->params.rect.p0.y = 0; + w->params.rect.p1.x = 380; + w->params.rect.p1.y = 450; + w->params.style = ui_wds_frame; + + rc = ui_window_create(w->ui, &w->params, &w->window); + if (rc != EOK) { + printf("Error creating window.\n"); + return rc; + } + + w->ui_res = ui_window_get_res(w->window); + + rc = ui_fixed_create(&w->fixed); + if (rc != EOK) { + printf("Error creating fixed layout.\n"); + return rc; + } + + w->draw = draw_window; + + w->destroy = destroy_window; + + return EOK; +} + +#endif Index: uspace/app/appslauncher/launch.c =================================================================== --- uspace/app/appslauncher/launch.c (revision 4bfb5a01e39428a8780576ab646b543a6a873151) +++ uspace/app/appslauncher/launch.c (revision 4bfb5a01e39428a8780576ab646b543a6a873151) @@ -0,0 +1,104 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include + +static const char *display_spec = UI_DISPLAY_DEFAULT; +int app_launchl(const char *app, ...); + +#define NAME "Apps Menu" + +int app_launchl(const char *app, ...) +{ + errno_t rc; + task_id_t id; + task_wait_t wait; + va_list ap; + const char *arg; + const char **argv; + const char **argp; + int cnt = 0; + int i; + + va_start(ap, app); + do { + arg = va_arg(ap, const char *); + cnt++; + } while (arg != NULL); + va_end(ap); + + argv = calloc(cnt + 4, sizeof(const char *)); + if (argv == NULL) + return -1; + + task_exit_t texit; + int retval; + + argp = argv; + *argp++ = app; + + if (str_cmp(display_spec, UI_DISPLAY_DEFAULT) != 0) { + *argp++ = "-d"; + *argp++ = display_spec; + } + + va_start(ap, app); + do { + arg = va_arg(ap, const char *); + *argp++ = arg; + } while (arg != NULL); + va_end(ap); + + *argp++ = NULL; + + printf("%s: Spawning %s", NAME, app); + for (i = 0; argv[i] != NULL; i++) { + printf(" %s", argv[i]); + } + printf("\n"); + + rc = task_spawnv(&id, &wait, app, argv); + if (rc != EOK) { + printf("%s: Error spawning %s (%s)\n", NAME, app, str_error(rc)); + return -1; + } + + rc = task_wait(&wait, &texit, &retval); + if ((rc != EOK) || (texit != TASK_EXIT_NORMAL)) { + printf("%s: Error retrieving retval from %s (%s)\n", NAME, + app, str_error(rc)); + return -1; + } + + return retval; +} Index: uspace/app/appslauncher/launcher.c =================================================================== --- uspace/app/appslauncher/launcher.c (revision 4bfb5a01e39428a8780576ab646b543a6a873151) +++ uspace/app/appslauncher/launcher.c (revision 4bfb5a01e39428a8780576ab646b543a6a873151) @@ -0,0 +1,249 @@ +/* + * 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 + +#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, ¬epad); + + 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; +} + +/** @} + */ Index: uspace/app/appslauncher/launcher.h =================================================================== --- uspace/app/appslauncher/launcher.h (revision 4bfb5a01e39428a8780576ab646b543a6a873151) +++ uspace/app/appslauncher/launcher.h (revision 4bfb5a01e39428a8780576ab646b543a6a873151) @@ -0,0 +1,65 @@ +/* + * 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 + */ + +#ifndef LAUNCHER_H +#define LAUNCHER_H + +#include +#include +#include +#include +#include +#include +#include + +/** Launcher */ +typedef struct { + ui_t *ui; + ui_window_t *window; + ui_fixed_t *fixed; + ui_image_t *image; + ui_label_t *label; + ui_pbutton_t *pb1; + ui_pbutton_t *pb2; + ui_pbutton_t *pb3; + ui_pbutton_t *pb4; + ui_pbutton_t *pb5; + ui_pbutton_t *pb6; +} launcher_t; + +#endif + +/** @} + */ Index: uspace/app/appslauncher/meson.build =================================================================== --- uspace/app/appslauncher/meson.build (revision 4bfb5a01e39428a8780576ab646b543a6a873151) +++ uspace/app/appslauncher/meson.build (revision 4bfb5a01e39428a8780576ab646b543a6a873151) @@ -0,0 +1,38 @@ +# +# Copyright (c) 2012 Petr Koupy +# 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. +# + +language = 'cpp' +deps = [ 'ui' ] + +incdirs = [ + '../../lib/c/include', +] + +includes += include_directories(incdirs, is_system: true) + +src = [ files('vector.c', 'launch.c', 'launcher.c'), ] Index: uspace/app/appslauncher/vector.c =================================================================== --- uspace/app/appslauncher/vector.c (revision 4bfb5a01e39428a8780576ab646b543a6a873151) +++ uspace/app/appslauncher/vector.c (revision 4bfb5a01e39428a8780576ab646b543a6a873151) @@ -0,0 +1,158 @@ +/* + * 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. + */ + +#include "include/vector.h" + +int vector_total(vector* v) +{ + int totalCount = UNDEFINE; + if (v) + { + totalCount = v->vectorList.total; + } + return totalCount; +} + +int vector_resize(vector* v, int capacity) +{ + int status = UNDEFINE; + if (v) + { + void** items = realloc(v->vectorList.items, sizeof(void*) * capacity); + if (items) + { + v->vectorList.items = items; + v->vectorList.capacity = capacity; + status = SUCCESS; + } + } + return status; +} + +int vector_push_back(vector* v, void* item) +{ + int status = UNDEFINE; + if (v) + { + if (v->vectorList.capacity == v->vectorList.total) + { + status = vector_resize(v, v->vectorList.capacity * 2); + if (status != UNDEFINE) + { + v->vectorList.items[v->vectorList.total++] = item; + } + } + else + { + v->vectorList.items[v->vectorList.total++] = item; + status = SUCCESS; + } + } + return status; +} + +int vector_set(vector* v, int index, void* item) +{ + int status = UNDEFINE; + if (v) + { + if ((index >= 0) && (index < v->vectorList.total)) + { + v->vectorList.items[index] = item; + status = SUCCESS; + } + } + return status; +} + +void* vector_get(vector* v, int index) +{ + void* readData = NULL; + if (v) + { + if ((index >= 0) && (index < v->vectorList.total)) + { + readData = v->vectorList.items[index]; + } + } + return readData; +} + +int vector_delete(vector* v, int index) +{ + int status = UNDEFINE; + int i = 0; + if (v) + { + if ((index < 0) || (index >= v->vectorList.total)) + return status; + v->vectorList.items[index] = NULL; + for (i = index; (i < v->vectorList.total - 1); ++i) + { + v->vectorList.items[i] = v->vectorList.items[i + 1]; + v->vectorList.items[i + 1] = NULL; + } + v->vectorList.total--; + if ((v->vectorList.total > 0) && ((v->vectorList.total) == (v->vectorList.capacity / 4))) + { + vector_resize(v, v->vectorList.capacity / 2); + } + status = SUCCESS; + } + return status; +} + +int vector_clear(vector* v) +{ + int status = UNDEFINE; + if (v) + { + free(v->vectorList.items); + v->vectorList.items = NULL; + status = SUCCESS; + } + return status; +} + +void vector_init(vector* v) +{ + //init function pointers + v->Count = vector_total; + v->Resize = vector_resize; + v->Add = vector_push_back; + v->Set = vector_set; + v->Get = vector_get; + v->Clear = vector_clear; + v->Delete = vector_delete; + //v->Clear = vector_clear; + + //initialize the capacity and allocate the memory + v->vectorList.capacity = VECTOR_INIT_CAPACITY; + v->vectorList.total = 0; + v->vectorList.items = malloc(sizeof(void*) * v->vectorList.capacity); +}