src/add-ons/accelerants/nvidia_gpgpu/Cursor.c

   1 /*
   2         Copyright 1999, Be Incorporated.   All Rights Reserved.
   3         This file may be used under the terms of the Be Sample Code License.
   4
   5         Other authors:
   6         Mark Watson,
   7         Rudolf Cornelissen 4/2003-6/2008
   8 */
   9
  10 #define MODULE_BIT 0x20000000
  11
  12 #include "acc_std.h"
  13
  14 status_t SET_CURSOR_SHAPE(uint16 width, uint16 height, uint16 hot_x, uint16 hot_y, uint8 *andMask, uint8 *xorMask)
  15 {
  16         LOG(4,("SET_CURSOR_SHAPE: width %d, height %d, hot_x %d, hot_y %d\n",
  17                 width, height, hot_x, hot_y));
  18
  19         if ((width != 16) || (height != 16))
  20         {
  21                 return B_ERROR;
  22         }
  23         else if ((hot_x >= width) || (hot_y >= height))
  24         {
  25                 return B_ERROR;
  26         }
  27         else
  28         {
  29                 head1_cursor_define(andMask,xorMask);
  30                 if ((si->dm.flags & DUALHEAD_BITS) != DUALHEAD_OFF)
  31                         head2_cursor_define(andMask,xorMask);
  32
  33                 /* Update cursor variables appropriately. */
  34                 si->cursor.width = width;
  35                 si->cursor.height = height;
  36                 si->cursor.hot_x = hot_x;
  37                 si->cursor.hot_y = hot_y;
  38         }
  39
  40         return B_OK;
  41 }
  42
  43 /* Move the cursor to the specified position on the desktop, taking account of virtual/dual issues */
  44 void MOVE_CURSOR(uint16 x, uint16 y)
  45 {
  46         uint16 hds = si->dm.h_display_start;    /* the current horizontal starting pixel */
  47         uint16 vds = si->dm.v_display_start;    /* the current vertical starting line */
  48         uint16 h_adjust;
  49
  50         /* clamp cursor to display */
  51         if (x >= si->dm.virtual_width) x = si->dm.virtual_width - 1;
  52         if (y >= si->dm.virtual_height) y = si->dm.virtual_height - 1;
  53
  54         /* store, for our info */
  55         si->cursor.x = x;
  56         si->cursor.y = y;
  57
  58         /* setting up minimum amount to scroll not needed:
  59          * Nvidia cards can always do pixelprecise panning on both heads */
  60         h_adjust = 0x00;
  61
  62         /* adjust h/v_display_start to move cursor onto screen */
  63         switch (si->dm.flags & DUALHEAD_BITS)
  64         {
  65         case DUALHEAD_ON:
  66         case DUALHEAD_SWITCH:
  67                 if (x >= ((si->dm.timing.h_display * 2) + hds))
  68                 {
  69                         hds = ((x - (si->dm.timing.h_display * 2)) + 1 + h_adjust) & ~h_adjust;
  70                         /* make sure we stay within the display! */
  71                         if ((hds + (si->dm.timing.h_display * 2)) > si->dm.virtual_width)
  72                                 hds -= (h_adjust + 1);
  73                 }
  74                 else if (x < hds)
  75                         hds = x & ~h_adjust;
  76                 break;
  77         default:
  78                 if (x >= (si->dm.timing.h_display + hds))
  79                 {
  80                         hds = ((x - si->dm.timing.h_display) + 1 + h_adjust) & ~h_adjust;
  81                         /* make sure we stay within the display! */
  82                         if ((hds + si->dm.timing.h_display) > si->dm.virtual_width)
  83                                 hds -= (h_adjust + 1);
  84                 }
  85                 else if (x < hds)
  86                         hds = x & ~h_adjust;
  87                 break;
  88         }
  89
  90         if (y >= (si->dm.timing.v_display + vds))
  91                 vds = y - si->dm.timing.v_display + 1;
  92         else if (y < vds)
  93                 vds = y;
  94
  95         /* reposition the desktop _and_ the overlay on the display if required */
  96         if ((hds!=si->dm.h_display_start) || (vds!=si->dm.v_display_start))
  97         {
  98                 MOVE_DISPLAY(hds,vds);
  99         }
 100
 101         /* put cursor in correct physical position, so stay onscreen (rel. to CRTC) */
 102         if (x > (hds + si->cursor.hot_x)) x -= (hds + si->cursor.hot_x);
 103         else x = 0;
 104         if (y > (vds + si->cursor.hot_y)) y -= (vds + si->cursor.hot_y);
 105         else y = 0;
 106
 107         /* position the cursor on the display */
 108         switch (si->dm.flags & DUALHEAD_BITS)
 109         {
 110         case DUALHEAD_CLONE:
 111                 head1_cursor_position(x,y);
 112                 head2_cursor_position(x,y);
 113                 break;
 114         case DUALHEAD_ON:
 115         case DUALHEAD_SWITCH:
 116                 if (x < si->dm.timing.h_display)
 117                 {
 118                         if (si->cursor.dh_right)
 119                         {
 120                                 LOG(4,("MOVE_CURSOR: now on left side\n"));
 121                                 head2_cursor_hide();
 122                                 head1_cursor_show();
 123                                 si->cursor.dh_right = false;
 124                         }
 125                         head1_cursor_position(x, y);
 126                 }
 127                 else
 128                 {
 129                         if (!si->cursor.dh_right)
 130                         {
 131                                 LOG(4,("MOVE_CURSOR: now on right side\n"));
 132                                 head1_cursor_hide();
 133                                 head2_cursor_show();
 134                                 si->cursor.dh_right = true;
 135                         }
 136                         head2_cursor_position((x - si->dm.timing.h_display), y);
 137                 }
 138                 break;
 139         default: /* singlehead mode */
 140                 head1_cursor_position(x,y);
 141                 break;
 142         }
 143 }
 144
 145 void SHOW_CURSOR(bool is_visible)
 146 {
 147         /* record for our info */
 148         si->cursor.is_visible = is_visible;
 149
 150         switch (si->dm.flags & DUALHEAD_BITS)
 151         {
 152         case DUALHEAD_CLONE:
 153                 if (is_visible)
 154                 {
 155                         head1_cursor_show();
 156                         head2_cursor_show();
 157                 }
 158                 else
 159                 {
 160                         head1_cursor_hide();
 161                         head2_cursor_hide();
 162                 }
 163                 break;
 164         case DUALHEAD_ON:
 165         case DUALHEAD_SWITCH:
 166                 if (is_visible)
 167                 {
 168                         if (!si->cursor.dh_right)
 169                         {
 170                                 head1_cursor_show();
 171                         }
 172                         else
 173                         {
 174                                 head2_cursor_show();
 175                         }
 176                 }
 177                 else
 178                 {
 179                         head1_cursor_hide();
 180                         head2_cursor_hide();
 181                 }
 182                 break;
 183         default: /* singlehead mode */
 184                 if (is_visible)
 185                 {
 186                         head1_cursor_show();
 187                 }
 188                 else
 189                 {
 190                         head1_cursor_hide();
 191                 }
 192                 break;
 193         }
 194 }