scrollbar_public.c

操作系统SunOS 4.1.3版本的源码

	    sb->attrs_modified = TRUE;
            break;

         case SCROLL_TO_GRID:
            if (*argv++)
	       sb->use_grid = TRUE;
            else
	       sb->use_grid = FALSE;
	    sb->attrs_modified = TRUE;
            break;

         case SCROLL_GAP:
            sb->gap = (int) *argv++;
	    sb->attrs_modified = TRUE;
            break;

	 case SCROLL_PAGE_BUTTONS:
            if (*argv++)
	       sb->buttons = TRUE;
            else
	       sb->buttons = FALSE;
	    sb->attrs_modified = TRUE;
	    break;

	 case SCROLL_PAGE_BUTTON_LENGTH:
	    sb->button_length = (unsigned) *argv++;
	    sb->saved_button_length = sb->button_length;
	    sb->attrs_modified = TRUE;
	    break;

	 case SCROLL_LINE_HEIGHT:
	    sb->line_height = (unsigned) *argv++;
	    break;

	 case SCROLL_MARK:
	    sb->undo_mark = (long unsigned) *argv++;
	    break;

	 case SCROLL_ADVANCED_MODE:
            if (*argv++)
	       sb->advanced_mode = TRUE;
            else
	       sb->advanced_mode = FALSE;
	    break;

	 case SCROLL_VIEW_START:
	    if ((sb->view_start = (unsigned) *argv++) < 0)
	       sb->view_start = 0;
	    break;

	 case SCROLL_VIEW_LENGTH:
	    sb->view_length = (unsigned) *argv++;
	    break;

	 case SCROLL_OBJECT_LENGTH:
	    if ((sb->object_length = (unsigned) *argv++) <= 0)
	       sb->object_length = SCROLLBAR_INVALID_LENGTH;
	    break;

	 case SCROLL_REPEAT_TIME:
	    sb->delay = (long unsigned) *argv++;
	    break;

	 case SCROLL_PAINT_BUTTONS_PROC:
	    sb->paint_buttons_proc = (int (*)()) (LINT_CAST(*argv++));
	    if (!sb->paint_buttons_proc)
	       sb->paint_buttons_proc = scrollbar_paint_buttons;
	    break;

         case SCROLL_REQUEST_OFFSET:
	    sb->request_offset = (long unsigned) *argv++;
	    break;

         case SCROLL_REQUEST_MOTION:
	    sb->request_motion = (Scroll_motion) *argv++;
	    break;

         case SCROLL_END_POINT_AREA:
	    sb->end_point_area = (long unsigned) *argv++;
	    break;

	 case HELP_DATA:
	    sb->help_data = *argv++;
	    break;

	 default:
	    argv = attr_skip(attr, argv);
      }
   }   

   /* set thickness to the appropriate dimension */
   if (thickness_set) {
      if (!sb->horizontal)
	 sb->rect.r_width = thickness;
      else
	 sb->rect.r_height = thickness;
   }

   /* if the notify client has been set, and is not null, get the  */
   /* windowfd for the client and compute new scrollbar rect.      */
   if (client_set && sb->notify_client) {
      sb->client_windowfd = win_get_fd(sb->notify_client);
      if (sb->rect_fixed) {
      /*
       *  If user only set one of the dimension, then default the other.
       */
         Rect   temp_sb_rect;
         if (sb->horizontal) {
            if (sb->rect.r_width == 0) {
               (void)win_getsize(sb->client_windowfd, &temp_sb_rect);
               sb->rect.r_width = temp_sb_rect.r_width;
               }
	 } else {
	    if (sb->rect.r_height == 0) {
	       (void)win_getsize(sb->client_windowfd, &temp_sb_rect);
	       sb->rect.r_height = temp_sb_rect.r_height;
               }
	 }
      } else {
         (void)win_getsize(sb->client_windowfd, &sb->rect);
	 if (sb->horizontal)
	    sb->rect.r_height = defaults_thickness;
	 else
	    sb->rect.r_width  = defaults_thickness;

      }
   }

   /* gravity adjustments... */
   /* if direction is set for first time, use user's preferred gravity */
   if (sb->direction_not_yet_set && direction_set && sb->gravity_not_yet_set) {
      defaults_gravity           = sb->horizontal ? 
				  defaults_h_gravity : defaults_v_gravity;
      sb->gravity               = defaults_gravity;
      sb->gravity_not_yet_set   = FALSE;
      sb->direction_not_yet_set = FALSE;
   }
   if ((sb->pixwin || client_set) && sb->gravity_not_yet_set == FALSE) {
      (void)win_getsize(sb->client_windowfd,&rect);
      if (sb->gravity == SCROLL_MAX) {
	 if (sb->horizontal) {
	    sb->rect.r_top = rect.r_top + rect.r_height - sb->rect.r_height;
	    if (!active_cursor_set)
	       sb->active_cursor = &scrollbar_h_south_active_cursor ;
	 } else {
	    sb->rect.r_left = rect.r_left + rect.r_width - sb->rect.r_width;
	    if (!active_cursor_set)
	       sb->active_cursor = &scrollbar_v_east_active_cursor ;
	 }
      } else {
	 if (sb->horizontal) {
	    sb->rect.r_top = rect.r_top;
	    if (!active_cursor_set)
	       sb->active_cursor = &scrollbar_h_north_active_cursor ;
	 } else {
	    sb->rect.r_left = rect.r_left;
	    if (!active_cursor_set)
	       sb->active_cursor = &scrollbar_v_west_active_cursor ;
	 }
      }
   }

   /* fix the region to reflect the current client and rect. */
   if (client_set || rect_set)
      scrollbar_fix_region(sb);

   /* find out if bubble modified */
   (void)scrollbar_compute_bubble_rect(sb, &new_bubble);
   if (!rect_equal(&new_bubble, &old_bubble)) 
      sb->bubble_modified = TRUE;

   /* page button stuff... */
   /* if bar is too short to show both buttons, default to no buttons. */
   /* if user requests buttons and bar is too short for both, make button */
   /* cover the whole bar by default. */
   sb_major_axis = sb->horizontal ? sb->rect.r_width : sb->rect.r_height;
   sb_is_tiny = sb_major_axis <= (2 * sb->saved_button_length);
   if (!sb->buttons)
      sb->button_length = 0;
   else
      sb->button_length = sb_is_tiny ? sb_major_axis : sb->saved_button_length;
   sb->one_button_case = (sb->buttons && sb_is_tiny);

   /* set the cursors if direction set */
   if (direction_set) {
      if (!forward_cursor_set)
	 sb->forward_cursor = (!sb->horizontal) ? 
			       &scrollbar_up_cursor : 
			       &scrollbar_left_cursor;
      if (!backward_cursor_set)
	 sb->backward_cursor = (!sb->horizontal) ? 
			       &scrollbar_down_cursor : 
			       &scrollbar_right_cursor;
      if (!absolute_cursor_set)
	 sb->absolute_cursor = (!sb->horizontal) ? 
			       &scrollbar_thumbv_cursor : 
			       &scrollbar_thumbh_cursor;
   }
}

/**************************************************************************/
/* scrollbar_fix_region                                                   */
/* If a region exists, close it, and unregister the scrollbar as a notify */
/* client.  Then, if the scrollbar has a client, open a region on the     */
/* client's pixwin reflecting the scrollbar's current rect.               */
/**************************************************************************/
#ifdef notdef
static
scrollbar_fix_region(sb) 
scrollbar_handle sb;
{
   struct pixwin *client_pw;

   /* if a region has been opened, close it and unregister sb. */
   if (sb->pixwin) {
      (void)pw_close(sb->pixwin);
      sb->pixwin = 0;
      (void)win_unregister(sb);  
   }

   /* if there is a client, open a region reflecting the current rect */
   if (sb->notify_client) {
      /*####ACG: pw_open => pw_open_sb */
      if (!(client_pw  = (struct pixwin *)pw_open_sb(sb->client_windowfd)))
          return;
      sb->pixwin = pw_region(client_pw, sb->rect.r_left, sb->rect.r_top,
			     sb->rect.r_width, sb->rect.r_height);
      (void)win_register(sb, sb->pixwin, scrollbar_event, scrollbar_destroy, 0);  
   }
}
#endif

static
scrollbar_fix_region(sb)
    scrollbar_handle sb;
{
    struct pixwin *client_pw;

    if (sb->notify_client) {
	if (sb->pixwin) {
	    (void)pw_set_region_rect(sb->pixwin, &sb->rect, TRUE);
	} else {
	    /*####ACG: pw_open => pw_open_sb */
            if (!(client_pw = (struct pixwin *)pw_open_sb(sb->client_windowfd)))
	        return;
	    sb->pixwin = pw_region(client_pw,
				   sb->rect.r_left,
				   sb->rect.r_top,
 				   sb->rect.r_width,
				   sb->rect.r_height);
	    (void)pw_close(client_pw);

	    if (pr_get_plane_group(sb->pixwin->pw_pixrect) == PIXPG_24BIT_COLOR)
		pw_use_color24(sb->pixwin);

	    (void)win_register((Notify_client)(LINT_CAST(sb)), sb->pixwin,
		         scrollbar_event, (Notify_value (*) ())(LINT_CAST(
			 scrollbar_destroy)), 0);
	}
    } else {
	if (sb->pixwin) {
	    (void)pw_close(sb->pixwin);
	    sb->pixwin = 0;
	    (void)win_unregister((Notify_client)(LINT_CAST(sb)));
	}
    }
}
/**************************************************************************/
/* scrollbar_get                                                          */
/**************************************************************************/

caddr_t
scrollbar_get(sb_client, attr)
Scrollbar sb_client;
Scrollbar_attribute attr;
{
   scrollbar_handle sb;

   sb = (scrollbar_handle)(LINT_CAST(sb_client));
   if (!sb)
      return (caddr_t) 0;

/* Return default values via special generic sb for boundary layout. */
   if (sb == (scrollbar_handle) SCROLLBAR) {
      switch (attr) {
         case SCROLL_THICKNESS:
         case SCROLL_WIDTH:
	    return (caddr_t)
	       defaults_get_integer_check("/Scrollbar/Thickness",
			   SCROLL_DEFAULT_WIDTH, 0, 200, (int *)NULL); 
         default:
	    return (caddr_t) 0;
      }
   }

   switch (attr) {

      case SCROLL_NOTIFY_CLIENT:
	 return (caddr_t) sb->notify_client; 

      case SCROLL_OBJECT:
	 return (caddr_t) sb->object; 

      case SCROLL_PIXWIN:
	 return (caddr_t) sb->pixwin; 

      case SCROLL_PLACEMENT:
	 return (caddr_t) sb->gravity;

      case SCROLL_RECT:
	 return (caddr_t) &sb->rect; 

      case SCROLL_TOP:
	 return (caddr_t) sb->rect.r_top; 

      case SCROLL_LEFT:
	 return (caddr_t) sb->rect.r_left; 

      case SCROLL_WIDTH:
	 return (caddr_t) sb->rect.r_width; 

      case SCROLL_HEIGHT:
	 return (caddr_t) sb->rect.r_height; 

      case SCROLL_THICKNESS:
	 if (!sb->horizontal)
	    return (caddr_t) sb->rect.r_width; 
         else
	    return (caddr_t) sb->rect.r_height; 

      case SCROLL_BUBBLE_MARGIN:
	 return (caddr_t) sb->bubble_margin; 

      case SCROLL_BUBBLE_COLOR:
	 if (sb->bubble_grey)
	    return (caddr_t) SCROLL_GREY;
         else
	    return (caddr_t) SCROLL_BLACK;

      case SCROLL_BAR_COLOR:
	 if (sb->bar_grey)
	    return (caddr_t) SCROLL_GREY;
         else
	    return (caddr_t) SCROLL_WHITE;

      case SCROLL_BORDER:
	 return (caddr_t) sb->border;

      case SCROLL_PAGE_BUTTONS:
	 return (caddr_t) sb->buttons; 

      case SCROLL_PAGE_BUTTON_LENGTH:
	 return (caddr_t) sb->button_length; 

      case SCROLL_BAR_DISPLAY_LEVEL:
	 return (caddr_t) sb->bar_display_level;

      case SCROLL_BUBBLE_DISPLAY_LEVEL:
	 return (caddr_t) sb->bar_display_level;

      case SCROLL_DIRECTION:
	 if (!sb->horizontal)
	    return (caddr_t) SCROLL_VERTICAL; 
         else
	    return (caddr_t) SCROLL_HORIZONTAL; 

      case SCROLL_FORWARD_CURSOR:
	 return (caddr_t) sb->forward_cursor;

      case SCROLL_BACKWARD_CURSOR:
	 return (caddr_t) sb->backward_cursor;

      case SCROLL_ABSOLUTE_CURSOR:
	 return (caddr_t) sb->absolute_cursor;

      case SCROLL_ACTIVE_CURSOR:
	 return (caddr_t) sb->active_cursor;

      case SCROLL_NORMALIZE:
	 if (sb->normalize)
	    return (caddr_t) TRUE; 
         else
	    return (caddr_t) FALSE; 

      case SCROLL_MARGIN:
	 return (caddr_t) sb->normalize_margin;

      case SCROLL_LINE_HEIGHT:
	 return (caddr_t) sb->line_height;

      case SCROLL_TO_GRID:
	 if (sb->use_grid)
	    return (caddr_t) TRUE; 
         else
	    return (caddr_t) FALSE; 

      case SCROLL_GAP:
	 if (sb->gap==SCROLLBAR_INVALID_LENGTH)
	    return (caddr_t) sb->normalize_margin;
	 else
	    return (caddr_t) sb->gap;

     case SCROLL_MARK:
	 return (caddr_t) sb->undo_mark;

      case SCROLL_ADVANCED_MODE:
	 if (sb->advanced_mode)
	    return (caddr_t) TRUE; 
         else
	    return (caddr_t) FALSE; 
	 break;

      case SCROLL_LAST_VIEW_START:
	 return (caddr_t) sb->old_view_start;

      case SCROLL_VIEW_START:
	 return (caddr_t) sb->view_start;

      case SCROLL_VIEW_LENGTH:
	 return (caddr_t) sb->view_length;

      case SCROLL_OBJECT_LENGTH:
	 return (caddr_t) sb->object_length;

      case SCROLL_REPEAT_TIME:
	 return (caddr_t) sb->delay;

      case SCROLL_PAINT_BUTTONS_PROC:
	 return (caddr_t) (LINT_CAST(sb->paint_buttons_proc));

      case SCROLL_MODIFY_PROC:
	 return (caddr_t) (LINT_CAST(sb->modify));

      case SCROLL_REQUEST_OFFSET:
	 return (caddr_t) sb->request_offset;

      case SCROLL_REQUEST_MOTION:
	 return (caddr_t) sb->request_motion;

      case SCROLL_END_POINT_AREA:
	 return (caddr_t) sb->end_point_area;

      case HELP_DATA:
	 return (caddr_t) sb->help_data; 

      default:
	 return (caddr_t) 0;
   }
   /*NOTREACHED*/
}

/**************************************************************************/
/* scrollbar_destroy*                                                     */
/**************************************************************************/

int
scrollbar_destroy(sb_client)
Scrollbar sb_client;
{
      scrollbar_handle sb;

      sb = (scrollbar_handle) (LINT_CAST(sb_client));
      scrollbar_free(sb);
      (void)win_unregister((Notify_client)(LINT_CAST(sb)));
      return 0;
}

/**************************************************************************/
/* scrollbar_free                                                         */
/* remove sb from the list of scrollbars for the pixwin, then free it.    */
/**************************************************************************/

static
scrollbar_free(sb)
scrollbar_handle sb;
{
   register scrollbar_handle	prev;

   if (scrollbar_active_sb == sb) 
      scrollbar_active_sb = NULL;

   if (sb == scrollbar_head_sb)
      scrollbar_head_sb = sb->next;
   else
      for (prev = scrollbar_head_sb; prev; prev = prev->next) {
	  if (sb == prev->next) {
	      prev->next = sb->next;
	      break;
	  }
      }
   free((char *)(LINT_CAST(sb)));
}


void
scrollbar_scroll_to(sb_client, new_view_start)
register Scrollbar	sb_client;
long			new_view_start;
{
    scrollbar_handle sb;

    sb = (scrollbar_handle) (LINT_CAST(sb_client));
    sb->old_view_start = sb->view_start;
    sb->view_start = new_view_start;
    if (sb->view_start != sb->old_view_start)
      sb->bubble_modified = TRUE;

    (void)win_post_id_and_arg(sb->notify_client, SCROLL_REQUEST, NOTIFY_SAFE, 
	(char *)sb, NOTIFY_COPY_NULL, NOTIFY_RELEASE_NULL);
}