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.6 by gbeauche, 2004-06-24T22:38:42Z vs.
Revision 1.10 by gbeauche, 2004-06-29T21:50:22Z

# Line 99 | Line 99 | static volatile bool redraw_thread_cance
99   static SDL_Thread *redraw_thread = NULL;                        // Redraw thread
100  
101   #ifdef ENABLE_VOSF
102 < static bool use_vosf = true;                                            // Flag: VOSF enabled
102 > static bool use_vosf = false;                                           // Flag: VOSF enabled
103   #else
104   static const bool use_vosf = false;                                     // VOSF not possible
105   #endif
# Line 260 | Line 260 | static void ErrorAlert(int error)
260   {
261          ErrorAlert(GetString(error));
262   }
263 +
264 + // Display warning alert
265 + static void WarningAlert(int warning)
266 + {
267 +        WarningAlert(GetString(warning));
268 + }
269   #endif
270  
271  
# Line 407 | Line 413 | static void add_mode(int type, int width
413          VIDEO_MODE_Y = height;
414          VIDEO_MODE_RESOLUTION = resolution_id;
415          VIDEO_MODE_ROW_BYTES = bytes_per_row;
416 <        VIDEO_MODE_DEPTH = depth;
416 >        VIDEO_MODE_DEPTH = (video_depth)depth;
417          VideoModes.push_back(mode);
418   }
419  
# Line 581 | Line 587 | void driver_base::update_palette(void)
587   {
588          const VIDEO_MODE &mode = monitor.get_current_mode();
589  
590 <        if (VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT)
590 >        if ((int)VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT)
591                  SDL_SetPalette(s, SDL_PHYSPAL, sdl_palette, 0, 256);
592   }
593  
# Line 612 | Line 618 | driver_window::driver_window(SDL_monitor
618          ADBSetRelMouseMode(mouse_grabbed);
619  
620          // Create surface
621 <        int depth = (VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT ? 8 : screen_depth);
621 >        int depth = ((int)VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT ? 8 : screen_depth);
622          if ((s = SDL_SetVideoMode(width, height, depth, SDL_HWSURFACE)) == NULL)
623                  return;
624  
# Line 624 | Line 630 | driver_window::driver_window(SDL_monitor
630          the_buffer = (uint8 *)vm_acquire(the_buffer_size);
631          the_buffer_copy = (uint8 *)malloc(the_buffer_size);
632          D(bug("the_buffer = %p, the_buffer_copy = %p, the_host_buffer = %p\n", the_buffer, the_buffer_copy, the_host_buffer));
627 – #else
628 –        // Allocate memory for frame buffer
629 –        the_buffer_size = (aligned_height + 2) * s->pitch;
630 –        the_buffer_copy = (uint8 *)calloc(1, the_buffer_size);
631 –        the_buffer = (uint8 *)calloc(1, the_buffer_size);
632 –        D(bug("the_buffer = %p, the_buffer_copy = %p\n", the_buffer, the_buffer_copy));
633 – #endif
633  
634 +        // Check whether we can initialize the VOSF subsystem and it's profitable
635 +        if (!video_vosf_init(m)) {
636 +                WarningAlert(STR_VOSF_INIT_ERR);
637 +                use_vosf = false;
638 +        }
639 +        else if (!video_vosf_profitable()) {
640 +                video_vosf_exit();
641 +                printf("VOSF acceleration is not profitable on this platform, disabling it\n");
642 +                use_vosf = false;
643 +        }
644 +        if (!use_vosf) {
645 +                free(the_buffer_copy);
646 +                vm_release(the_buffer, the_buffer_size);
647 +                the_host_buffer = NULL;
648 +        }
649 + #endif
650 +        if (!use_vosf) {
651 +                // Allocate memory for frame buffer
652 +                the_buffer_size = (aligned_height + 2) * s->pitch;
653 +                the_buffer_copy = (uint8 *)calloc(1, the_buffer_size);
654 +                the_buffer = (uint8 *)calloc(1, the_buffer_size);
655 +                D(bug("the_buffer = %p, the_buffer_copy = %p\n", the_buffer, the_buffer_copy));
656 +        }
657 +        
658   #ifdef SHEEPSHAVER
659          // Create cursor
660          if ((sdl_cursor = SDL_CreateCursor(MacCursor + 4, MacCursor + 36, 16, 16, 0, 0)) != NULL) {
# Line 764 | Line 787 | static void keycode_init(void)
787  
788                          if (video_driver_found) {
789                                  // Skip aliases
790 <                                static const char alias_str[] = "alias";
791 <                                if (strncmp(line, alias_str, sizeof(alias_str) - 1) == 0)
790 >                                static const char sdl_str[] = "sdl";
791 >                                if (strncmp(line, sdl_str, sizeof(sdl_str) - 1) == 0)
792                                          continue;
793  
794                                  // Read keycode
# Line 776 | Line 799 | static void keycode_init(void)
799                                          break;
800                          } else {
801                                  // Search for SDL video driver string
802 <                                static const char alias_sdl_str[] = "alias SDL";
803 <                                if (strncmp(line, alias_sdl_str, sizeof(alias_sdl_str) - 1) == 0) {
804 <                                        char *p = line + sizeof(alias_sdl_str);
802 >                                static const char sdl_str[] = "sdl";
803 >                                if (strncmp(line, sdl_str, sizeof(sdl_str) - 1) == 0) {
804 >                                        char *p = line + sizeof(sdl_str);
805                                          if (strstr(video_driver, p) == video_driver)
806                                                  video_driver_found = true;
807                                  }
# Line 823 | Line 846 | bool SDL_monitor_desc::video_open(void)
846                  return false;
847          }
848  
826 – #ifdef ENABLE_VOSF
827 –        if (use_vosf) {
828 –                // Initialize the VOSF system
829 –                if (!video_vosf_init(*this)) {
830 –                        ErrorAlert(STR_VOSF_INIT_ERR);
831 –                return false;
832 –                }
833 –        }
834 – #endif
835 –        
849          // Initialize VideoRefresh function
850          VideoRefreshInit();
851  
# Line 1134 | Line 1147 | void SDL_monitor_desc::set_palette(uint8
1147          const VIDEO_MODE &mode = get_current_mode();
1148  
1149          // FIXME: how can we handle the gamma ramp?
1150 <        if (VIDEO_MODE_DEPTH > VIDEO_DEPTH_8BIT)
1150 >        if ((int)VIDEO_MODE_DEPTH > VIDEO_DEPTH_8BIT)
1151                  return;
1152  
1153          LOCK_PALETTE;
# Line 1159 | Line 1172 | void SDL_monitor_desc::set_palette(uint8
1172                  }
1173  
1174   #ifdef ENABLE_VOSF
1175 <                // We have to redraw everything because the interpretation of pixel values changed
1176 <                LOCK_VOSF;
1177 <                PFLAG_SET_ALL;
1178 <                UNLOCK_VOSF;
1179 <                memset(the_buffer_copy, 0, VIDEO_MODE_ROW_BYTES * VIDEO_MODE_Y);
1175 >                if (use_vosf) {
1176 >                        // We have to redraw everything because the interpretation of pixel values changed
1177 >                        LOCK_VOSF;
1178 >                        PFLAG_SET_ALL;
1179 >                        UNLOCK_VOSF;
1180 >                        memset(the_buffer_copy, 0, VIDEO_MODE_ROW_BYTES * VIDEO_MODE_Y);
1181 >                }
1182   #endif
1183          }
1184  
# Line 1614 | Line 1629 | void VideoInstallAccel(void)
1629  
1630  
1631   /*
1632 < *  Translate key event to Mac keycode, returns -1 if no keycode was found
1618 < *  and -2 if the key was recognized as a hotkey
1632 > *  Keyboard-related utilify functions
1633   */
1634  
1635 + static bool is_modifier_key(SDL_KeyboardEvent const & e)
1636 + {
1637 +        switch (e.keysym.sym) {
1638 +        case SDLK_NUMLOCK:
1639 +        case SDLK_CAPSLOCK:
1640 +        case SDLK_SCROLLOCK:
1641 +        case SDLK_RSHIFT:
1642 +        case SDLK_LSHIFT:
1643 +        case SDLK_RCTRL:
1644 +        case SDLK_LCTRL:
1645 +        case SDLK_RALT:
1646 +        case SDLK_LALT:
1647 +        case SDLK_RMETA:
1648 +        case SDLK_LMETA:
1649 +        case SDLK_LSUPER:
1650 +        case SDLK_RSUPER:
1651 +        case SDLK_MODE:
1652 +        case SDLK_COMPOSE:
1653 +                return true;
1654 +        }
1655 +        return false;
1656 + }
1657 +
1658   static bool is_ctrl_down(SDL_keysym const & ks)
1659   {
1660          return ctrl_down || (ks.mod & KMOD_CTRL);
1661   }
1662  
1663 +
1664 + /*
1665 + *  Translate key event to Mac keycode, returns -1 if no keycode was found
1666 + *  and -2 if the key was recognized as a hotkey
1667 + */
1668 +
1669   static int kc_decode(SDL_keysym const & ks, bool key_down)
1670   {
1671          switch (ks.sym) {
# Line 1692 | Line 1735 | static int kc_decode(SDL_keysym const &
1735          case SDLK_RCTRL: return 0x36;
1736          case SDLK_LSHIFT: return 0x38;
1737          case SDLK_RSHIFT: return 0x38;
1738 + #if (defined(__APPLE__) && defined(__MACH__))
1739 +        case SDLK_LALT: return 0x3a;
1740 +        case SDLK_RALT: return 0x3a;
1741 +        case SDLK_LMETA: return 0x37;
1742 +        case SDLK_RMETA: return 0x37;
1743 + #else
1744          case SDLK_LALT: return 0x37;
1745          case SDLK_RALT: return 0x37;
1746          case SDLK_LMETA: return 0x3a;
1747          case SDLK_RMETA: return 0x3a;
1748 + #endif
1749          case SDLK_MENU: return 0x32;
1750          case SDLK_CAPSLOCK: return 0x39;
1751          case SDLK_NUMLOCK: return 0x47;
# Line 1802 | Line 1852 | static void handle_events(void)
1852                          // Keyboard
1853                          case SDL_KEYDOWN: {
1854                                  int code = -1;
1855 <                                if (use_keycodes) {
1855 >                                if (use_keycodes && !is_modifier_key(event.key)) {
1856                                          if (event2keycode(event.key, true) != -2)       // This is called to process the hotkeys
1857                                                  code = keycode_table[event.key.keysym.scancode & 0xff];
1858                                  } else
# Line 1830 | Line 1880 | static void handle_events(void)
1880                          }
1881                          case SDL_KEYUP: {
1882                                  int code = -1;
1883 <                                if (use_keycodes) {
1883 >                                if (use_keycodes && !is_modifier_key(event.key)) {
1884                                          if (event2keycode(event.key, false) != -2)      // This is called to process the hotkeys
1885                                                  code = keycode_table[event.key.keysym.scancode & 0xff];
1886                                  } else
1887                                          code = event2keycode(event.key, false);
1888 <                                if (code >= 0 && code != 0x39) {        // Don't propagate Caps Lock releases
1889 <                                        ADBKeyUp(code);
1888 >                                if (code >= 0) {
1889 >                                        if (code == 0x39) {     // Caps Lock released
1890 >                                                if (caps_on) {
1891 >                                                        ADBKeyUp(code);
1892 >                                                        caps_on = false;
1893 >                                                } else {
1894 >                                                        ADBKeyDown(code);
1895 >                                                        caps_on = true;
1896 >                                                }
1897 >                                        } else
1898 >                                                ADBKeyUp(code);
1899                                          if (code == 0x36)
1900                                                  ctrl_down = false;
1901                                  }
# Line 1903 | Line 1962 | static void update_display_static(driver
1962  
1963          // Check for first column from left and first column from right that have changed
1964          if (high) {
1965 <                if (VIDEO_MODE_DEPTH < VIDEO_DEPTH_8BIT) {
1965 >                if ((int)VIDEO_MODE_DEPTH < VIDEO_DEPTH_8BIT) {
1966                          const int src_bytes_per_row = bytes_per_row;
1967                          const int dst_bytes_per_row = drv->s->pitch;
1968                          const int pixels_per_byte = VIDEO_MODE_X / src_bytes_per_row;

Diff Legend

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