apps/gui/usb_screen.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id: screens.c 23269 2009-10-19 20:06:51Z tomers $
   9  *
  10  * Copyright (C) 2002 Björn Stenberg
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include "action.h"
  23 #include "font.h"
  24 #ifdef HAVE_REMOTE_LCD
  25 #include "lcd-remote.h"
  26 #endif
  27 #include "lang.h"
  28 #include "usb.h"
  29 #if defined(HAVE_USBSTACK)
  30 #include "usb_core.h"
  31 #ifdef USB_ENABLE_HID
  32 #include "usb_keymaps.h"
  33 #endif
  34 #endif
  35 #include "settings.h"
  36 #include "led.h"
  37 #include "appevents.h"
  38
  39 #ifdef HAVE_LCD_BITMAP
  40 #include "bitmaps/usblogo.h"
  41 #endif
  42
  43 #ifdef HAVE_REMOTE_LCD
  44 #include "bitmaps/remote_usblogo.h"
  45 #endif
  46
  47 #if (CONFIG_STORAGE & STORAGE_MMC)
  48 #include "ata_mmc.h"
  49 #endif
  50
  51 #ifdef USB_ENABLE_HID
  52 int usb_keypad_mode;
  53 static bool usb_hid;
  54 #endif
  55
  56 #ifndef SIMULATOR
  57
  58 static int handle_usb_events(void)
  59 {
  60 #if (CONFIG_STORAGE & STORAGE_MMC)
  61     int next_update=0;
  62 #endif /* STORAGE_MMC */
  63
  64     /* Don't return until we get SYS_USB_DISCONNECTED or SYS_TIMEOUT */
  65     while(1)
  66     {
  67         int button;
  68 #ifdef USB_ENABLE_HID
  69         if (usb_hid)
  70         {
  71             button = get_hid_usb_action();
  72
  73             /* On mode change, we need to refresh the screen */
  74             if (button == ACTION_USB_HID_MODE_SWITCH_NEXT ||
  75                     button == ACTION_USB_HID_MODE_SWITCH_PREV)
  76             {
  77                 break;
  78             }
  79         }
  80         else
  81 #endif
  82         {
  83             button = button_get_w_tmo(HZ/2);
  84             /* hid emits the event in get_action */
  85             send_event(GUI_EVENT_ACTIONUPDATE, NULL);
  86         }
  87
  88         switch(button)
  89         {
  90             case SYS_USB_DISCONNECTED:
  91                 usb_acknowledge(SYS_USB_DISCONNECTED_ACK);
  92                 return 1;
  93             case SYS_TIMEOUT:
  94                 break;
  95         }
  96
  97 #if (CONFIG_STORAGE & STORAGE_MMC) /* USB-MMC bridge can report activity */
  98         if(TIME_AFTER(current_tick,next_update))
  99         {
 100             if(usb_inserted()) {
 101                 led(mmc_usb_active(HZ));
 102             }
 103             next_update=current_tick+HZ/2;
 104         }
 105 #endif /* STORAGE_MMC */
 106     }
 107
 108     return 0;
 109 }
 110 #endif
 111
 112 #ifdef USB_NONE
 113 void gui_usb_screen_run(void)
 114 {
 115 }
 116 #else
 117 #define MODE_NAME_LEN 32
 118
 119 struct usb_screen_vps_t
 120 {
 121     struct viewport parent;
 122 #ifdef HAVE_LCD_BITMAP
 123     struct viewport logo;
 124 #ifdef USB_ENABLE_HID
 125     struct viewport title;
 126 #endif
 127 #endif
 128 };
 129
 130 #ifdef HAVE_LCD_BITMAP
 131 static void usb_screen_fix_viewports(struct screen *screen,
 132         struct usb_screen_vps_t *usb_screen_vps)
 133 {
 134     int logo_width, logo_height;
 135     struct viewport *parent = &usb_screen_vps->parent;
 136     struct viewport *logo = &usb_screen_vps->logo;
 137
 138 #ifdef HAVE_REMOTE_LCD
 139     if (screen->screen_type == SCREEN_REMOTE)
 140     {
 141         logo_width = BMPWIDTH_remote_usblogo;
 142         logo_height = BMPHEIGHT_remote_usblogo;
 143     }
 144     else
 145 #endif
 146     {
 147         logo_width = BMPWIDTH_usblogo;
 148         logo_height = BMPHEIGHT_usblogo;
 149     }
 150
 151     viewport_set_defaults(parent, screen->screen_type);
 152     if (parent->width < logo_width || parent->height < logo_height)
 153         viewport_set_fullscreen(parent, screen->screen_type);
 154
 155     *logo = *parent;
 156     logo->x = parent->x + parent->width - logo_width;
 157     logo->y = parent->y + (parent->height - logo_height) / 2;
 158     logo->width = logo_width;
 159     logo->height = logo_height;
 160
 161 #ifdef USB_ENABLE_HID
 162     if (usb_hid)
 163     {
 164         struct viewport *title = &usb_screen_vps->title;
 165         int char_height = font_get(parent->font)->height;
 166         *title = *parent;
 167         title->y = logo->y + logo->height + char_height;
 168         title->height = char_height;
 169         /* try to fit logo and title to parent */
 170         if (parent->y + parent->height < title->y + title->height)
 171         {
 172             logo->y = parent->y;
 173             title->y = parent->y + logo->height;
 174         }
 175     }
 176 #endif
 177 }
 178 #endif
 179
 180 static void usb_screens_draw(struct usb_screen_vps_t *usb_screen_vps_ar)
 181 {
 182     int i;
 183     int usb_bars = VP_SB_ALLSCREENS; /* force statusbars */
 184
 185     lcd_clear_display();
 186 #ifdef HAVE_LCD_REMOTE
 187     lcd_remote_clear_display();
 188 #endif
 189
 190     FOR_NB_SCREENS(i)
 191     {
 192         struct screen *screen = &screens[i];
 193
 194         struct usb_screen_vps_t *usb_screen_vps = &usb_screen_vps_ar[i];
 195         struct viewport *parent = &usb_screen_vps->parent;
 196 #ifdef HAVE_LCD_BITMAP
 197         struct viewport *logo = &usb_screen_vps->logo;
 198 #endif
 199
 200         screen->set_viewport(parent);
 201         screen->backdrop_show(BACKDROP_MAIN);
 202         screen->backlight_on();
 203         screen->clear_viewport();
 204
 205 #ifdef HAVE_LCD_BITMAP
 206         screen->set_viewport(logo);
 207 #ifdef HAVE_REMOTE_LCD
 208         if (i == SCREEN_REMOTE)
 209         {
 210             screen->bitmap(remote_usblogo, 0, 0, logo->width,
 211                 logo->height);
 212         }
 213         else
 214 #endif
 215         {
 216             screen->transparent_bitmap(usblogo, 0, 0, logo->width,
 217                 logo->height);
 218 #ifdef USB_ENABLE_HID
 219             if (usb_hid)
 220             {
 221                 screen->set_viewport(&usb_screen_vps->title);
 222                 usb_screen_vps->title.flags |= VP_FLAG_ALIGN_CENTER;
 223                 screen->puts_scroll(0, 0, str(keypad_mode_name_get()));
 224             }
 225 #endif /* USB_ENABLE_HID */
 226         }
 227         screen->set_viewport(parent);
 228
 229 #else /* HAVE_LCD_BITMAP */
 230         screen->double_height(false);
 231         screen->puts_scroll(0, 0, "[USB Mode]");
 232         status_set_param(false);
 233         status_set_audio(false);
 234         status_set_usb(true);
 235 #endif /* HAVE_LCD_BITMAP */
 236
 237         screen->update_viewport();
 238         screen->set_viewport(NULL);
 239
 240         /* force statusbar by ignoring the setting */
 241         usb_bars |= VP_SB_IGNORE_SETTING(i);
 242     }
 243
 244     viewportmanager_set_statusbar(usb_bars);
 245 }
 246
 247 void gui_usb_screen_run(void)
 248 {
 249     int i;
 250     int old_bars  = viewportmanager_get_statusbar();
 251     struct usb_screen_vps_t usb_screen_vps_ar[NB_SCREENS];
 252 #if defined HAVE_TOUCHSCREEN
 253     enum touchscreen_mode old_mode = touchscreen_get_mode();
 254
 255     /* TODO: Paint buttons on screens OR switch to point mode and use
 256      * touchscreen as a touchpad to move the host's mouse cursor */
 257     touchscreen_set_mode(TOUCHSCREEN_BUTTON);
 258 #endif
 259
 260 #ifndef SIMULATOR
 261     usb_acknowledge(SYS_USB_CONNECTED_ACK);
 262 #endif
 263
 264 #ifdef USB_ENABLE_HID
 265     usb_hid = global_settings.usb_hid;
 266     usb_keypad_mode = global_settings.usb_keypad_mode;
 267 #endif
 268
 269     FOR_NB_SCREENS(i)
 270     {
 271         struct screen *screen = &screens[i];
 272
 273         screen->set_viewport(NULL);
 274 #ifdef HAVE_LCD_BITMAP
 275         usb_screen_fix_viewports(screen, &usb_screen_vps_ar[i]);
 276 #endif
 277     }
 278
 279     while (1)
 280     {
 281         usb_screens_draw(usb_screen_vps_ar);
 282 #ifdef SIMULATOR
 283         if (button_get_w_tmo(HZ/2))
 284             break;
 285         send_event(GUI_EVENT_ACTIONUPDATE, NULL);
 286 #else
 287         if (handle_usb_events())
 288             break;
 289 #endif /* SIMULATOR */
 290     }
 291
 292     FOR_NB_SCREENS(i)
 293     {
 294         const struct viewport* vp = NULL;
 295
 296 #if defined(HAVE_LCD_BITMAP) && defined(USB_ENABLE_HID)
 297         vp = usb_hid ? &usb_screen_vps_ar[i].title : NULL;
 298 #elif !defined(HAVE_LCD_BITMAP)
 299         vp = &usb_screen_vps_ar[i].parent;
 300 #endif
 301         if (vp)
 302             screens[i].scroll_stop(vp);
 303     }
 304 #ifdef USB_ENABLE_HID
 305     if (global_settings.usb_keypad_mode != usb_keypad_mode)
 306     {
 307         global_settings.usb_keypad_mode = usb_keypad_mode;
 308         settings_save();
 309     }
 310 #endif
 311
 312 #ifdef HAVE_TOUCHSCREEN
 313     touchscreen_set_mode(old_mode);
 314 #endif
 315
 316 #ifdef HAVE_LCD_CHARCELLS
 317     status_set_usb(false);
 318 #endif /* HAVE_LCD_CHARCELLS */
 319     FOR_NB_SCREENS(i)
 320     {
 321         screens[i].backlight_on();
 322     }
 323     viewportmanager_set_statusbar(old_bars);
 324     send_event(GUI_EVENT_REFRESH, NULL);
 325
 326 }
 327 #endif /* !defined(USB_NONE) */
 328