ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/BasiliskII/src/SDL/video_sdl.cpp
(Generate patch)

Comparing BasiliskII/src/SDL/video_sdl.cpp (file contents):
Revision 1.33 by gbeauche, 2007-06-14T14:45:54Z vs.
Revision 1.40 by asvitkine, 2011-12-28T21:35:42Z

# Line 1 | Line 1
1   /*
2   *  video_sdl.cpp - Video/graphics emulation, SDL specific stuff
3   *
4 < *  Basilisk II (C) 1997-2005 Christian Bauer
4 > *  Basilisk II (C) 1997-2008 Christian Bauer
5   *
6   *  This program is free software; you can redistribute it and/or modify
7   *  it under the terms of the GNU General Public License as published by
# Line 136 | Line 136 | static SDL_Cursor *sdl_cursor;                                         // C
136   static volatile bool cursor_changed = false;            // Flag: cursor changed, redraw_func must update the cursor
137   static SDL_Color sdl_palette[256];                                      // Color palette to be used as CLUT and gamma table
138   static bool sdl_palette_changed = false;                        // Flag: Palette changed, redraw thread must set new colors
139 < static const int sdl_eventmask = SDL_MOUSEBUTTONDOWNMASK | SDL_MOUSEBUTTONUPMASK | SDL_MOUSEMOTIONMASK | SDL_KEYUPMASK | SDL_KEYDOWNMASK | SDL_VIDEOEXPOSEMASK | SDL_QUITMASK;
139 > static const int sdl_eventmask = SDL_MOUSEEVENTMASK | SDL_KEYEVENTMASK | SDL_VIDEOEXPOSEMASK | SDL_QUITMASK | SDL_ACTIVEEVENTMASK;
140  
141   // Mutex to protect SDL events
142   static SDL_mutex *sdl_events_lock = NULL;
# Line 625 | Line 625 | public:
625   class driver_window;
626   static void update_display_window_vosf(driver_window *drv);
627   static void update_display_dynamic(int ticker, driver_window *drv);
628 < static void update_display_static(driver_window *drv);
628 > static void update_display_static(driver_base *drv);
629  
630   class driver_window : public driver_base {
631          friend void update_display_window_vosf(driver_window *drv);
632          friend void update_display_dynamic(int ticker, driver_window *drv);
633 <        friend void update_display_static(driver_window *drv);
633 >        friend void update_display_static(driver_base *drv);
634  
635   public:
636          driver_window(SDL_monitor_desc &monitor);
# Line 1238 | Line 1238 | bool VideoInit(bool classic)
1238                                  continue;
1239                          if (w == 512 && h == 384)
1240                                  continue;
1241 – #ifdef ENABLE_VOSF
1241                          for (int d = VIDEO_DEPTH_1BIT; d <= default_depth; d++)
1242                                  add_mode(display_type, w, h, video_modes[i].resolution_id, TrivialBytesPerRow(w, (video_depth)d), d);
1244 – #else
1245 –                        add_mode(display_type, w, h, video_modes[i].resolution_id, TrivialBytesPerRow(w, (video_depth)default_depth), default_depth);
1246 – #endif
1243                  }
1244          }
1245  
# Line 1543 | Line 1539 | void SDL_monitor_desc::switch_to_current
1539   #ifdef SHEEPSHAVER
1540   bool video_can_change_cursor(void)
1541   {
1542 <        return (display_type == DISPLAY_WINDOW);
1542 >        static char driver[] = "Quartz?";
1543 >        static int quartzok = -1;
1544 >
1545 >        if (display_type != DISPLAY_WINDOW)
1546 >                return false;
1547 >
1548 >        if (quartzok < 0) {
1549 >                if (SDL_VideoDriverName(driver, sizeof driver) == NULL || strncmp(driver, "Quartz", sizeof driver))
1550 >                        quartzok = true;
1551 >                else {
1552 >                        // Quartz driver bug prevents cursor changing in SDL 1.2.11 to 1.2.13.
1553 >                        const SDL_version *vp = SDL_Linked_Version();
1554 >                        int version = SDL_VERSIONNUM(vp->major, vp->minor, vp->patch);
1555 >                        quartzok = (version <= SDL_VERSIONNUM(1, 2, 10) || version >= SDL_VERSIONNUM(1, 2, 14));
1556 >                }
1557 >        }
1558 >
1559 >        return quartzok;
1560   }
1561   #endif
1562  
# Line 1754 | Line 1767 | static void handle_events(void)
1767                          // Mouse button
1768                          case SDL_MOUSEBUTTONDOWN: {
1769                                  unsigned int button = event.button.button;
1770 <                                if (button < 4)
1771 <                                        ADBMouseDown(button - 1);
1770 >                                if (button == SDL_BUTTON_LEFT)
1771 >                                        ADBMouseDown(0);
1772 >                                else if (button == SDL_BUTTON_RIGHT)
1773 >                                        ADBMouseDown(1);
1774 >                                else if (button == SDL_BUTTON_MIDDLE)
1775 >                                        ADBMouseDown(2);
1776                                  else if (button < 6) {  // Wheel mouse
1777                                          if (mouse_wheel_mode == 0) {
1778                                                  int key = (button == 5) ? 0x79 : 0x74;  // Page up/down
# Line 1773 | Line 1790 | static void handle_events(void)
1790                          }
1791                          case SDL_MOUSEBUTTONUP: {
1792                                  unsigned int button = event.button.button;
1793 <                                if (button < 4)
1794 <                                        ADBMouseUp(button - 1);
1793 >                                if (button == SDL_BUTTON_LEFT)
1794 >                                        ADBMouseUp(0);
1795 >                                else if (button == SDL_BUTTON_RIGHT)
1796 >                                        ADBMouseUp(1);
1797 >                                else if (button == SDL_BUTTON_MIDDLE)
1798 >                                        ADBMouseUp(2);
1799                                  break;
1800                          }
1801  
# Line 1858 | Line 1879 | static void handle_events(void)
1879                                  ADBKeyDown(0x7f);       // Power key
1880                                  ADBKeyUp(0x7f);
1881                                  break;
1882 +
1883 +                        // Application activate/deactivate; consume the event but otherwise ignore it
1884 +                        case SDL_ACTIVEEVENT:
1885 +                                break;
1886                          }
1887                  }
1888          }
# Line 1869 | Line 1894 | static void handle_events(void)
1894   */
1895  
1896   // Static display update (fixed frame rate, but incremental)
1897 < static void update_display_static(driver_window *drv)
1897 > static void update_display_static(driver_base *drv)
1898   {
1899          // Incremental update code
1900          int wide = 0, high = 0, x1, x2, y1, y2, i, j;
# Line 1958 | Line 1983 | static void update_display_static(driver
1983  
1984                  } else {
1985                          const int bytes_per_pixel = VIDEO_MODE_ROW_BYTES / VIDEO_MODE_X;
1986 +                        const int dst_bytes_per_row = drv->s->pitch;
1987  
1988                          x1 = VIDEO_MODE_X;
1989                          for (j=y1; j<=y2; j++) {
# Line 1998 | Line 2024 | static void update_display_static(driver
2024                                  // Blit to screen surface
2025                                  for (j=y1; j<=y2; j++) {
2026                                          i = j * bytes_per_row + x1 * bytes_per_pixel;
2027 +                                        int dst_i = j * dst_bytes_per_row + x1 * bytes_per_pixel;
2028                                          memcpy(the_buffer_copy + i, the_buffer + i, bytes_per_pixel * wide);
2029 <                                        Screen_blit((uint8 *)drv->s->pixels + i, the_buffer + i, bytes_per_pixel * wide);
2029 >                                        Screen_blit((uint8 *)drv->s->pixels + dst_i, the_buffer + i, bytes_per_pixel * wide);
2030                                  }
2031  
2032                                  // Unlock surface, if required
# Line 2015 | Line 2042 | static void update_display_static(driver
2042  
2043   // Static display update (fixed frame rate, bounding boxes based)
2044   // XXX use NQD bounding boxes to help detect dirty areas?
2045 < static void update_display_static_bbox(driver_window *drv)
2045 > static void update_display_static_bbox(driver_base *drv)
2046   {
2047          const VIDEO_MODE &mode = drv->mode;
2048  
# Line 2033 | Line 2060 | static void update_display_static_bbox(d
2060          // Update the surface from Mac screen
2061          const int bytes_per_row = VIDEO_MODE_ROW_BYTES;
2062          const int bytes_per_pixel = bytes_per_row / VIDEO_MODE_X;
2063 +        const int dst_bytes_per_row = drv->s->pitch;
2064          int x, y;
2065          for (y = 0; y < VIDEO_MODE_Y; y += N_PIXELS) {
2066                  int h = N_PIXELS;
# Line 2047 | Line 2075 | static void update_display_static_bbox(d
2075                          bool dirty = false;
2076                          for (int j = y; j < (y + h); j++) {
2077                                  const int yb = j * bytes_per_row;
2078 +                                const int dst_yb = j * dst_bytes_per_row;
2079                                  if (memcmp(&the_buffer[yb + xb], &the_buffer_copy[yb + xb], xs) != 0) {
2080                                          memcpy(&the_buffer_copy[yb + xb], &the_buffer[yb + xb], xs);
2081 <                                        Screen_blit((uint8 *)drv->s->pixels + yb + xb, the_buffer + yb + xb, xs);
2081 >                                        Screen_blit((uint8 *)drv->s->pixels + dst_yb + xb, the_buffer + yb + xb, xs);
2082                                          dirty = true;
2083                                  }
2084                          }
# Line 2113 | Line 2142 | static inline void handle_palette_change
2142          UNLOCK_PALETTE;
2143   }
2144  
2145 + static void video_refresh_window_static(void);
2146 +
2147   static void video_refresh_dga(void)
2148   {
2149          // Quit DGA mode if requested
2150          possibly_quit_dga_mode();
2151 +        video_refresh_window_static();
2152   }
2153  
2154   #ifdef ENABLE_VOSF
# Line 2168 | Line 2200 | static void video_refresh_window_static(
2200                  tick_counter = 0;
2201                  const VIDEO_MODE &mode = drv->mode;
2202                  if ((int)VIDEO_MODE_DEPTH >= VIDEO_DEPTH_8BIT)
2203 <                        update_display_static_bbox(static_cast<driver_window *>(drv));
2203 >                        update_display_static_bbox(drv);
2204                  else
2205 <                        update_display_static(static_cast<driver_window *>(drv));
2205 >                        update_display_static(drv);
2206          }
2207   }
2208  
# Line 2216 | Line 2248 | static inline void do_video_refresh(void
2248                  SDL_FreeCursor(sdl_cursor);
2249                  sdl_cursor = SDL_CreateCursor(MacCursor + 4, MacCursor + 36, 16, 16, MacCursor[2], MacCursor[3]);
2250                  if (sdl_cursor) {
2251 +                        SDL_ShowCursor(private_data == NULL || private_data->cursorVisible);
2252                          SDL_SetCursor(sdl_cursor);
2253   #ifdef WIN32
2254                          // XXX Windows apparently needs an extra mouse event to
# Line 2295 | Line 2328 | static int redraw_func(void *arg)
2328   #ifdef SHEEPSHAVER
2329   void video_set_dirty_area(int x, int y, int w, int h)
2330   {
2331 + #ifdef ENABLE_VOSF
2332          const VIDEO_MODE &mode = drv->mode;
2333          const int screen_width = VIDEO_MODE_X;
2334          const int screen_height = VIDEO_MODE_Y;
2335          const int bytes_per_row = VIDEO_MODE_ROW_BYTES;
2336  
2303 – #ifdef ENABLE_VOSF
2337          if (use_vosf) {
2338                  vosf_set_dirty_area(x, y, w, h, screen_width, screen_height, bytes_per_row);
2339                  return;

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines