Beispiel #1
0
/*
 *  Set charging animation drawing method according to running mode:
 *  running IPO : using surface flinger , DRAW_ANIM_MODE_SURFACE 
 *  running KPOC: using framebuffer     , DRAW_ANIM_MODE_FB
 */
void set_draw_anim_mode(int running_mode)
{
    int draw_anim_mode = DRAW_ANIM_MODE_SURFACE;
    KPOC_LOGD("[ChargingAnimation %s %d]kpoc flag == 1 ? : running_mode = %d \n ",__FUNCTION__,__LINE__ ,running_mode);
    if(running_mode == 1) {
        draw_anim_mode = DRAW_ANIM_MODE_FB;
        KPOC_LOGD("[ChargingAnimation %s %d]under kernel power off charging mode, use fb to draw animation!",__FUNCTION__,__LINE__ );
    } else {
        draw_anim_mode = DRAW_ANIM_MODE_SURFACE; 
    }        

    set_draw_mode(draw_anim_mode);
//    set_draw_mode(DRAW_ANIM_MODE_SURFACE);
}
Beispiel #2
0
void drawscreen (void)
{
   set_draw_mode(DRAW_NORMAL);
   clearscreen();

   for(auto it = cells.begin(); it != cells.end(); ++it)
   {
      t_point bt_marker = t_point(it->x_pos - 0.3, it->y_pos - 0.3);
      t_bound_box cell_rect = t_bound_box(bt_marker, 0.6, 0.6);
      if (it->fixed)
        setcolor(RED);
      else
        setcolor(BLUE);
      fillrect(cell_rect);
   }

#ifdef _DEBUG_
   setcolor(BLACK);
   for(auto it = virtual_pins.begin(); it != virtual_pins.end(); ++it)
   {
      t_point bt_marker = t_point(it->x_pos - 0.3, it->y_pos - 0.3);
      t_bound_box cell_rect = t_bound_box(bt_marker, 0.6, 0.6);
      fillrect(cell_rect);
   }
#endif

   setcolor(MEDIUMPURPLE);
   setlinestyle(SOLID);
   setlinewidth(1);
   std::vector<int> q_to_c_map;
   q_to_c_map.resize(Q.size());

   unsigned int q_idx=0;
   for(unsigned int i=0; i<cells.size(); i++)
   {
      if (Vertex::v_map_table[i] == -1)
        continue;
      assert(q_idx < Q.size());
      q_to_c_map[q_idx++] = i;
   }

   if (show_nets)
   {
      int drawn_lines =0;
      //draw lines between movable cells
      for(unsigned int c=0; c<Q.size(); c++)
      {
         for(unsigned int r=c+1; r<Q.size(); r++)
         {
            if (Q[c][r] != 0)
            {
                int src_idx = q_to_c_map.at(c);
                int tgt_idx = q_to_c_map.at(r);
                drawline(cells[src_idx].x_pos, cells[src_idx].y_pos, 
                         cells[tgt_idx].x_pos, cells[tgt_idx].y_pos);
                drawn_lines++;
            }
         }
      }
      setcolor(RED);
      setlinestyle(DASHED);
      setlinewidth(1);
      //used edge set to filter 
      std::unordered_set<std::pair<int, int>> u_edges;
      for(auto f_iter = fixed_cells.begin();  f_iter != fixed_cells.end(); ++f_iter)
      {
        std::list<Edge>& adj_cells = f_iter->adj_list;

        //iterating over the edge list to draw
        for(auto t_iter = adj_cells.begin(); t_iter != adj_cells.end(); ++t_iter)
        {
           std::pair<int, int> edge (f_iter->v_id, t_iter->tgt->v_id);
           auto set_idx = u_edges.find(edge);

           //skip if edge is found in the set
           if (set_idx != u_edges.end()) {
              continue;
           }
           u_edges.insert(edge);
           drawline(f_iter->x_pos, f_iter->y_pos, 
                    t_iter->tgt->x_pos, t_iter->tgt->y_pos);
           drawn_lines++;
        }
      }
   }

#ifdef _DEBUG_
   std::cout << "Number of lines drawn: " << drawn_lines << "\n";
#endif
}
void 
GlutViewer::processmenu(int i) 
{
    set_draw_mode(i);
}