gtknotebook.c

gtk是linux一款强大的夸平台的图形化开发工具

{
  GtkNotebook *notebook;
  GdkRectangle child_area;
  GdkRectangle draw_area;

  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_NOTEBOOK (widget));
  g_return_if_fail (area != NULL);

  notebook = GTK_NOTEBOOK (widget);

  draw_area = *area;

  if (GTK_WIDGET_DRAWABLE (widget))
    {
      gboolean have_visible_child;

      have_visible_child = notebook->cur_page && GTK_WIDGET_VISIBLE (notebook->cur_page->child);

      if (have_visible_child != notebook->have_visible_child)
	{
	  notebook->have_visible_child = have_visible_child;
	  draw_area.x = 0;
	  draw_area.y = 0;
	  draw_area.width = widget->allocation.width;
	  draw_area.height = widget->allocation.height;
	}

      gtk_notebook_paint (widget, &draw_area);

      gtk_widget_draw_focus (widget);

      if (notebook->cur_page && GTK_WIDGET_VISIBLE (notebook->cur_page->child) &&
	  gtk_widget_intersect (notebook->cur_page->child, &draw_area, &child_area))
	gtk_widget_draw (notebook->cur_page->child, &child_area);
    }
  else
    notebook->have_visible_child = FALSE;
}

static gint
gtk_notebook_expose (GtkWidget      *widget,
		     GdkEventExpose *event)
{
  GtkNotebook *notebook;
  GdkEventExpose child_event;
  GdkRectangle child_area;
   
  g_return_val_if_fail (widget != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
  g_return_val_if_fail (event != NULL, FALSE);

  if (GTK_WIDGET_DRAWABLE (widget))
    {
      notebook = GTK_NOTEBOOK (widget);

      gtk_notebook_paint (widget, &event->area);
      if (notebook->show_tabs)
	{
	  if (notebook->cur_page && 
	      gtk_widget_intersect (notebook->cur_page->tab_label, 
				    &event->area, &child_area))
	    gtk_widget_draw_focus (widget);
	}

      child_event = *event;
      if (notebook->cur_page && 
	  GTK_WIDGET_NO_WINDOW (notebook->cur_page->child) &&
	  gtk_widget_intersect (notebook->cur_page->child, &event->area, 
				&child_event.area))
	gtk_widget_event (notebook->cur_page->child, (GdkEvent*) &child_event);
    }

  return FALSE;
}

static gint
gtk_notebook_button_press (GtkWidget      *widget,
			   GdkEventButton *event)
{
  GtkNotebook *notebook;
  GtkNotebookPage *page;
  GList *children;
  gint num;

  g_return_val_if_fail (widget != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
  g_return_val_if_fail (event != NULL, FALSE);

  notebook = GTK_NOTEBOOK (widget);

  if (event->type != GDK_BUTTON_PRESS || !notebook->children ||
      notebook->button)
    return FALSE;

  if (event->window == notebook->panel)
    {
      if (!GTK_WIDGET_HAS_FOCUS (widget))
	gtk_widget_grab_focus (widget);

      gtk_grab_add (widget);
      notebook->button = event->button;

      if (event->x <= ARROW_SIZE + ARROW_SPACING / 2)
	{
	  notebook->click_child = GTK_ARROW_LEFT;
	  if (event->button == 1)
	    {
	      if (!notebook->focus_tab ||
		  gtk_notebook_search_page (notebook, notebook->focus_tab,
					    STEP_PREV, TRUE))
		gtk_container_focus (GTK_CONTAINER (notebook), GTK_DIR_LEFT);

	      if (!notebook->timer)
		{
		  notebook->timer = gtk_timeout_add 
		    (NOTEBOOK_INIT_SCROLL_DELAY, 
		     (GtkFunction) gtk_notebook_timer, (gpointer) notebook);
		  notebook->need_timer = TRUE;
		}
	    }
	  else if (event->button == 2)
	    gtk_notebook_page_select (GTK_NOTEBOOK (widget));
	  else if (event->button == 3)
	    gtk_notebook_switch_focus_tab (notebook,
					   gtk_notebook_search_page (notebook,
								     NULL,
								     STEP_NEXT,
								     TRUE));
	  gtk_notebook_draw_arrow (notebook, GTK_ARROW_LEFT);
	}
      else
	{
	  notebook->click_child = GTK_ARROW_RIGHT;
	  if (event->button == 1)
	    {
	      if (!notebook->focus_tab ||
		  gtk_notebook_search_page (notebook, notebook->focus_tab,
					    STEP_NEXT, TRUE))
		gtk_container_focus (GTK_CONTAINER (notebook), GTK_DIR_RIGHT);

	      if (!notebook->timer)
		{
		  notebook->timer = gtk_timeout_add 
		    (NOTEBOOK_INIT_SCROLL_DELAY, 
		     (GtkFunction) gtk_notebook_timer, (gpointer) notebook);
		  notebook->need_timer = TRUE;
		}
	    }      
	  else if (event->button == 2)
	    gtk_notebook_page_select (GTK_NOTEBOOK (widget));
	  else if (event->button == 3)
	    gtk_notebook_switch_focus_tab
	      (notebook, gtk_notebook_search_page (notebook, NULL,
						   STEP_PREV, TRUE));
	  gtk_notebook_draw_arrow (notebook, GTK_ARROW_RIGHT);
	}
    }
  else if (event->window == widget->window)
    {
      if (event->button == 3 && notebook->menu)
	{
	  gtk_menu_popup (GTK_MENU (notebook->menu), NULL, NULL, 
			  NULL, NULL, 3, event->time);
	  return FALSE;
	}

      num = 0;
      children = notebook->children;
      while (children)
	{
	  page = children->data;
	  
	  if (GTK_WIDGET_VISIBLE (page->child) &&
	      page->tab_label && GTK_WIDGET_MAPPED (page->tab_label) &&
	      (event->x >= page->allocation.x) &&
	      (event->y >= page->allocation.y) &&
	      (event->x <= (page->allocation.x + page->allocation.width)) &&
	      (event->y <= (page->allocation.y + page->allocation.height)))
	    {
	      if (page == notebook->cur_page && notebook->focus_tab &&
		  notebook->focus_tab != children &&
		  GTK_WIDGET_HAS_FOCUS (notebook))
		{
		  GtkNotebookPage *old_page;

		  notebook->child_has_focus = FALSE;
		  old_page = (GtkNotebookPage *)
			      (notebook->focus_tab->data);
		  gtk_notebook_switch_focus_tab (notebook, children);
		  gtk_notebook_focus_changed (notebook, old_page);
		}
	      else
		{
		  gtk_notebook_switch_focus_tab (notebook, children);
		  gtk_widget_grab_focus (widget);
		  gtk_notebook_switch_page (notebook, page, num);
		}
	      break;
	    }
	  children = children->next;
	  num++;
	}
      if (!children && !GTK_WIDGET_HAS_FOCUS (widget))
	gtk_widget_grab_focus (widget);
    }
   gtk_notebook_set_shape (notebook);
  return FALSE;
}

static gint
gtk_notebook_button_release (GtkWidget      *widget,
			     GdkEventButton *event)
{
  GtkNotebook *notebook;

  g_return_val_if_fail (widget != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
  g_return_val_if_fail (event != NULL, FALSE);

  if (event->type != GDK_BUTTON_RELEASE)
    return FALSE;

  notebook = GTK_NOTEBOOK (widget);

  if (event->button == notebook->button)
    {
      guint click_child;

      if (notebook->timer)
	{
	  gtk_timeout_remove (notebook->timer);
	  notebook->timer = 0;
	  notebook->need_timer = FALSE;
	}
      gtk_grab_remove (widget);
      click_child = notebook->click_child;
      notebook->click_child = 0;
      notebook->button = 0;
      gtk_notebook_draw_arrow (notebook, click_child);
      
    }
  return FALSE;
}

static gint
gtk_notebook_enter_notify (GtkWidget        *widget,
			   GdkEventCrossing *event)
{
  GtkNotebook *notebook;

  g_return_val_if_fail (widget != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
  g_return_val_if_fail (event != NULL, FALSE);

  notebook = GTK_NOTEBOOK (widget);

  if (event->window == notebook->panel)
    {
      gint x;
      gint y;

      gdk_window_get_pointer (notebook->panel, &x, &y, NULL);

      if (x <= ARROW_SIZE + ARROW_SPACING / 2)
	{
	  notebook->in_child = GTK_ARROW_LEFT;

	  if (notebook->click_child == 0) 
	    gtk_notebook_draw_arrow (notebook, GTK_ARROW_LEFT);
	}
      else 
	{
	  notebook->in_child = GTK_ARROW_RIGHT;

	  if (notebook->click_child == 0) 
	    gtk_notebook_draw_arrow (notebook, GTK_ARROW_RIGHT);
	}
    }

  return FALSE;
}

static gint
gtk_notebook_leave_notify (GtkWidget        *widget,
			   GdkEventCrossing *event)
{
  GtkNotebook *notebook;

  g_return_val_if_fail (widget != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
  g_return_val_if_fail (event != NULL, FALSE);

  notebook = GTK_NOTEBOOK (widget);

  if (event->window == notebook->panel && !notebook->click_child)
    {
      if (notebook->in_child == GTK_ARROW_LEFT)
	{
          notebook->in_child = 0;
	  gtk_notebook_draw_arrow (notebook,GTK_ARROW_LEFT);
	}
      else
	{
          notebook->in_child = 0;
	  gtk_notebook_draw_arrow (notebook,GTK_ARROW_RIGHT);
	}
    }
  return FALSE;
}

static gint
gtk_notebook_motion_notify (GtkWidget      *widget,
			    GdkEventMotion *event)
{
  GtkNotebook *notebook;

  g_return_val_if_fail (widget != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
  g_return_val_if_fail (event != NULL, FALSE);

  notebook = GTK_NOTEBOOK (widget);
  
  if (notebook->button)
    return FALSE;

  if (event->window == notebook->panel)
    {
      gint x;
      
      x = event->x;
      if (event->is_hint)
        gdk_window_get_pointer (notebook->panel, &x, NULL, NULL);

      if (x <= ARROW_SIZE + ARROW_SPACING / 2 && 
          notebook->in_child == GTK_ARROW_RIGHT)
        {
          notebook->in_child = GTK_ARROW_LEFT;
          gtk_notebook_draw_arrow (notebook, GTK_ARROW_LEFT);
          gtk_notebook_draw_arrow (notebook, GTK_ARROW_RIGHT);
        }
      else if (x > ARROW_SIZE + ARROW_SPACING / 2 && 
	       notebook->in_child == GTK_ARROW_LEFT)
        {
          notebook->in_child = GTK_ARROW_RIGHT;
          gtk_notebook_draw_arrow (notebook, GTK_ARROW_RIGHT);
          gtk_notebook_draw_arrow (notebook, GTK_ARROW_LEFT);
        }
      return FALSE;
    }
  return FALSE;
}

static gint
gtk_notebook_key_press (GtkWidget   *widget,
			GdkEventKey *event)
{
  GtkNotebook *notebook;
  GtkDirectionType direction = 0;
  GList *list;

  g_return_val_if_fail (widget != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
  g_return_val_if_fail (event != NULL, FALSE);

  notebook = GTK_NOTEBOOK (widget);

  if (!notebook->children || !notebook->show_tabs)
    return FALSE;

  switch (event->keyval)
    {
    case GDK_Up:
      switch (notebook->tab_pos)
	{
	case GTK_POS_BOTTOM:
	  gtk_notebook_page_select (GTK_NOTEBOOK (widget));
	  return TRUE;
	case GTK_POS_TOP:
	  return FALSE;
	default:
	  direction = GTK_DIR_UP;
	  break;
	}
      break;
    case GDK_Left:
      switch (notebook->tab_pos)
	{
	case GTK_POS_RIGHT:
	  gtk_notebook_page_select (GTK_NOTEBOOK (widget));
	  return TRUE;
	case GTK_POS_LEFT:
	  return FALSE;
	default:
	  direction = GTK_DIR_LEFT;
	  break;
	}
      break;
    case GDK_Down:
      switch (notebook->tab_pos)
	{
	case GTK_POS_TOP:
	  gtk_notebook_page_select (GTK_NOTEBOOK (widget));
	  return TRUE;
	case GTK_POS_BOTTOM:
	  return FALSE;
	default:
	  direction = GTK_DIR_DOWN;
	  break;
	}
      break;
    case GDK_Right:
      switch (notebook->tab_pos)
	{
	case GTK_POS_LEFT:
	  gtk_notebook_page_select (GTK_NOTEBOOK (widget));
	  return TRUE;
	case GTK_POS_RIGHT:
	  return FALSE;
	default:
	  direction = GTK_DIR_RIGHT;
	  break;
	}
      break;
    case GDK_Tab:
    case GDK_ISO_Left_Tab:
      if (event->state & GDK_SHIFT_MASK)
	direction = GTK_DIR_TAB_BACKWARD;
      else
	direction = GTK_DIR_TAB_FORWARD;
      break;
    case GDK_Home:
      list = gtk_notebook_search_page (notebook, NULL, STEP_NEXT, TRUE);
      if (list)
	gtk_notebook_switch_focus_tab (notebook, list);
      return TRUE;
    case GDK_End:
      list = gtk_notebook_search_page (notebook, NULL, STEP_PREV, TRUE);
      if (list)
	gtk_notebook_switch_focus_tab (notebook, list);
      return TRUE;
    case GDK_Return:
    case GDK_space:
      gtk_notebook_page_select (GTK_NOTEBOOK (widget));
      return TRUE;
    default:
      return FALSE;
    }
  return gtk_container_focus (GTK_CONTAINER (widget), direction);
}

static gint
gtk_notebook_focus_in (GtkWidget     *widget,
		       GdkEventFocus *event)
{
  g_return_val_if_fail (widget != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
  g_return_val_if_fail (event != NULL, FALSE);