fl_toggle_tree_base.cxx

bluetooth 驱动

#include <stdio.h> // printf
#include <stdlib.h> // qsort

#include <FL/Fl_Toggle_Node_Base.H>
#include <FL/Fl_Toggle_Tree_Base.H>

Fl_Toggle_Tree_Base::Fl_Toggle_Tree_Base(int x, int y, int w, int h) : Fl_Widget(x, y, w, h) {
  first_ = 0;
  top_ = 0;
  top_depth_ = 0;
  damaged_ = 0;
}

void Fl_Toggle_Tree_Base::draw_node(int depth, int cy, Fl_Toggle_Node_Base*) {
  fl_color(FL_BLACK);
  fl_rectf(x(), cy, depth*16, 16);
  fl_color(FL_WHITE);
  fl_rectf(x() + depth*16, cy, w() - depth*16, 16);
}

Fl_Toggle_Node_Base* Fl_Toggle_Tree_Base::find(int fy, int& depth, int& ry) {
  int cy = parent()->y() + top_yoffset_;
  int ey = parent()->y() + parent()->h();

  if (fy < cy) return 0;

  depth = top_depth_;
  Fl_Toggle_Node_Base* node = top_;
  traverse_start(top_);

  while (cy < ey && node) {
    ry = cy;
    cy += height(node);
    if (cy > fy) return node;
    node = traverse_forward(1, depth);
  }
  return 0;
}

void Fl_Toggle_Tree_Base::update_height(void) {
  resize(x(), y(), w(), total_height(first_));
}

void Fl_Toggle_Tree_Base::draw(void) {
  //  printf("Fl_Toggle_Tree_Base::draw %d %d\n",x(),y());
  update_top();
  int cy = parent()->y() + top_yoffset_;
  int ey = parent()->y() + parent()->h();
  int depth = top_depth_;
  Fl_Toggle_Node_Base* node = top_;
  int drawing = 0;
  //printf("DAMAGE %d %d %d\n",damage(),FL_DAMAGE_ALL,FL_DAMAGE_CHILD);
  if (damage() == FL_DAMAGE_ALL) drawing = 1;
  if (damage() == FL_DAMAGE_CHILD && damaged_ == 0) drawing = 1;
  while (cy < ey && node) {
    if (damaged_ == node) {
      if (damage() == FL_DAMAGE_CHILD) {
        draw_node(depth, cy, node);
        return;
      }
      drawing = 1;
    }
    //printf("%s %d\n",(char*) node->data(),drawing);
    if (drawing) draw_node(depth, cy, node);
    cy += height(node);
    if (node->vsub_) {
      //printf("has sub\n");
      node = node->vsub_;
      depth++;
    } else if (node->next_) {
      //printf("has no sub\n");
      node = node->next_;
    } else {
      while (node && !node->next_) {
        node = node->up_;
        depth--;
      }
      if (node) node = node->next_;
    }
  }
  fl_color(parent()->color());
  fl_rectf(x(), cy, w(), ey - cy);
}

int (*s_node_compare_)(Fl_Toggle_Node_Base *, Fl_Toggle_Node_Base *) = 0;

int Fl_Toggle_Tree_Base::s_compare_(void* a, void *b) {
  Fl_Toggle_Node_Base* nodeA = *(Fl_Toggle_Node_Base**)a;
  Fl_Toggle_Node_Base* nodeB = *(Fl_Toggle_Node_Base**)b;
  return s_node_compare_(nodeA, nodeB);
}

int Fl_Toggle_Tree_Base::s_compare_reverse_(void* a, void *b) {
  Fl_Toggle_Node_Base* nodeA = *(Fl_Toggle_Node_Base**)a;
  Fl_Toggle_Node_Base* nodeB = *(Fl_Toggle_Node_Base**)b;
  return - s_node_compare_(nodeA, nodeB);
}

Fl_Toggle_Node_Base* Fl_Toggle_Tree_Base::sort_ (Fl_Toggle_Node_Base* start, int (*compar)(Fl_Toggle_Node_Base *, Fl_Toggle_Node_Base *),
                         int down, sort_order order) {
  int i;
  Fl_Toggle_Node_Base* node;

  i = 0;
  node = start;
    
  while (node) {
    node = node->next_;
    i++;
  }
  Fl_Toggle_Node_Base** array = new Fl_Toggle_Node_Base * [i];

  i = 0;
  node = start;
  while (node) {
    array[i] = node;
    node = node->next_;
    i++;
  }
  s_node_compare_ = compar;

  if (order == REVERSE_SORT) {
    qsort(array, i, sizeof(Fl_Toggle_Node_Base*),
          (int (*)(const void*, const void*))s_compare_reverse_ );
  } else {
    qsort(array, i, sizeof(Fl_Toggle_Node_Base*),
          (int (*)(const void*, const void*))s_compare_);
  }

  start = array[0];
  int j = 1;
  node = start;
  node->prev_ = 0; //james
  while (j < i) {
    node->next_ = array[j];
    node->next_->prev_ = node;
    node = node->next_;
    j++;
  }
  node->next_ = 0;

  if (down) {
    node = start;
    while (node) {
      if (node->sub_)
        node->sub_ = sort_tree(node->sub_, compar, order);
      if (node->vsub_) 
	node->vsub_ = node->sub_;
      node = node->next_;
    }
  }

  delete [] array;

  return start;
}

Fl_Toggle_Node_Base* Fl_Toggle_Tree_Base::sort(Fl_Toggle_Node_Base* start, int (*compar) (Fl_Toggle_Node_Base *, Fl_Toggle_Node_Base*),
                       sort_order order ) {
  if (first_)
    return sort_(start, compar, 0, order);
  return 0;
}

Fl_Toggle_Node_Base* Fl_Toggle_Tree_Base::sort_tree(Fl_Toggle_Node_Base* start, int (*compar)(Fl_Toggle_Node_Base *, Fl_Toggle_Node_Base*),
                            sort_order order) {
  if (first_)
    return sort_(start, compar, 1, order);
  return 0;
}

void Fl_Toggle_Tree_Base::sort(int (*compar)(Fl_Toggle_Node_Base *, Fl_Toggle_Node_Base *),
                   sort_order order) {
  if (first_)
    first_ = top_ = sort(first_, compar, order);
}

void Fl_Toggle_Tree_Base::sort_tree(int (*compar)(Fl_Toggle_Node_Base *, Fl_Toggle_Node_Base *),
                        sort_order order) {
  if (first_)
    first_ = top_ = sort_tree(first_, compar, order);
}

void Fl_Toggle_Tree_Base::update_top(void) {
  Fl_Toggle_Node_Base *node = first_;
  int py = parent()->y();
  int ly = y();
  int h = 0;
  int depth = 0;

  while (node && ly + (h = height(node)) <= py) {
    ly += h;
    if (node->vsub_) {
      node = node->vsub_;
      depth++;
    } else if (node->next_) {
      node = node->next_;
    } else {
      while (node && !node->next_) {
        node = node->up_;
        depth--;
      }
      if (node) node = node->next_;
    }
  }

  top_ = node;
  top_depth_ = depth;
  top_yoffset_ = ly - py;
}

int Fl_Toggle_Tree_Base::total_height(Fl_Toggle_Node_Base* node) {
  int ret = 0;
  int depth = 1;
  while (node) {
    ret += height(node);
    if (node->vsub_) {
      node = node->vsub_;
      depth++;
    } else if (node->next_) {
      node = node->next_;
    } else {
      while (node && !node->next_) {
        node = node->up_;
        depth--;
        if (depth <= 0) node = 0;
      }
      if (node) node = node->next_;
    }
  }
  return ret;
}

int Fl_Toggle_Tree_Base::height(Fl_Toggle_Node_Base*) {
  return 17;
}

Fl_Toggle_Node_Base * Fl_Toggle_Tree_Base::traverse_start() {
  t_current_ = first_;
  return t_current_;
}

void Fl_Toggle_Tree_Base::traverse_start(Fl_Toggle_Node_Base * a) {
  t_current_ = a;
}

void Fl_Toggle_Tree_Base::traverse_up (void) {
  if (t_current_ && t_current_->up_)
    t_current_ = t_current_->up_;
}


Fl_Toggle_Node_Base * Fl_Toggle_Tree_Base::traverse_forward(int visible, int &depth) {

  if (visible) {
    if (t_current_ && t_current_->vsub_ != 0) {
      t_current_ = t_current_->vsub_;
      depth++;
      return t_current_;
    }
  } else {
    if (t_current_ && t_current_->sub_ != 0) {
      t_current_ = t_current_->sub_;
      depth++;
      return t_current_;
    }
  }

  if (t_current_ && t_current_->next_ != 0) {
    t_current_ = t_current_->next_;
    return t_current_;
  }

  while (t_current_ && !t_current_->next_) {
    t_current_ = t_current_->up_;
    depth--;
  }
  if (t_current_) t_current_ = t_current_->next_;

  return t_current_;
}

Fl_Toggle_Node_Base * Fl_Toggle_Tree_Base::traverse_forward() {
  int d;
  return traverse_forward(0, d);
}

Fl_Toggle_Node_Base * Fl_Toggle_Tree_Base::traverse_backward() {
  if (t_current_ && t_current_->prev_) {
    t_current_ = t_current_->prev_;
    while (t_current_->sub_) {
      t_current_ = t_current_->sub_;
      while (t_current_->next_) {
        t_current_ = t_current_->next_;
        if (t_current_->next_ == 0 && t_current_->sub_) {
          t_current_ = t_current_->sub_;
        }
      }
    }
  } else {
    t_current_ = t_current_->up_;
  }
  return t_current_;
}

void Fl_Toggle_Tree_Base::add_next (Fl_Toggle_Node_Base* node) {
  if (!first_) {
    first_ = node;
    t_current_ = node;
  } else {
    if (t_current_ == 0)
      t_current_ = first_;
    while (t_current_->next_) t_current_=t_current_->next_;
    node->next_ = t_current_->next_;
    if (t_current_->next_) {
      t_current_->next_->prev_ = node;
    }
    t_current_->next_ = node;
    node->prev_ = t_current_;
    node->up_ = t_current_->up_;
    t_current_ = node;
  }

  update_height();
  parent()->damage(FL_DAMAGE_CHILD);
  redraw();
}

void Fl_Toggle_Tree_Base::add_sub (Fl_Toggle_Node_Base* node) {

  if (!first_) {
    first_ = node;
    t_current_ = node;
  } else {
    if (t_current_ == 0)
      t_current_ = first_;
    node->next_ = t_current_->sub_;

    if (t_current_->sub_)
      t_current_->sub_->prev_ = node;
    node->prev_ = 0;
    t_current_->sub_ = node;

    if (t_current_->opened_)
      t_current_->vsub_ = node;

    node->up_ = t_current_;
    t_current_ = node;
  }

  update_height();
  parent()->damage(FL_DAMAGE_CHILD);
  redraw();
}

int Fl_Toggle_Tree_Base::remove (Fl_Toggle_Node_Base * a) 
{
   //
   // If a is NULL, don't bother removing anything
   //
   if ( a )
   {
     Fl_Toggle_Node_Base * temp = a->sub_;
   
     while (temp != 0) { // Remove all children
       remove(temp);
       temp = a->sub_;
     }
   
     if (a->prev_) {
       a->prev_->next_ = a->next_;
       if (a->next_)
         a->next_->prev_ = a->prev_;
     } else if (a->up_) {
       Fl_Toggle_Node_Base * o = a->up_;
       o->sub_ = a->next_;
       if (o->opened_)
         o->vsub_ = a->next_;
       else
         o->vsub_ = 0;
   
       if (a->next_) {
         a->next_->up_ = o;
         a->next_->prev_ = a->prev_;
       }
     }
   
     if (a == first_) {
       if (a->next_) {
         first_ = a->next_;
         first_->up_ = 0;
         first_->prev_ = 0;
       } else {
         first_ = 0;
         top_ = 0;
       }
     }
   
     if (a == current_) {
       if (a->up_)
         current_ = a->up_;
       else if (a->prev_)
         current_ = a->prev_;
       else
         current_ = 0;
     }
   
     if (a == t_current_) {
       if (a->up_)
         t_current_ = a->up_;
       else if (a->prev_)
         t_current_ = a->prev_;
       else
         t_current_ = 0;
     }
   
     update_height();
     parent()->damage(FL_DAMAGE_CHILD);
     redraw();
   
     delete a;
     a = 0;

   }  // If a !NULL 

  return 1;
}

int Fl_Toggle_Tree_Base::clear() {

   //
   // While first_ is not NULL, remove
   //
   while ( first_ )
   {
      remove(first_);
   }

   return 1;
}

int Fl_Toggle_Tree_Base::close(Fl_Toggle_Node_Base* node) {
  int th = total_height(node->vsub_);
  node->opened_ = 0;
  node->vsub_ = 0;
  return th;
}

int Fl_Toggle_Tree_Base::open(Fl_Toggle_Node_Base* node) {
  node->vsub_ = node->sub_;
  int th = total_height(node->vsub_);
  node->opened_ = 1;
  return th;
}