arrange.cpp

一个3D桌面的实现源码

        //faces[r-1]->render();
        nums.push(r);

    }

    while (!nums.empty()) {
        faces[nums.top() - 1]->render();
        nums.pop();
    }
}
#endif // if 0


void CarouselArrangement::set_current_face (int c, int r) 
{
    current_face = c + (r * n_columns);
    current_col = c;
    current_row = r;
    goto_face_val = 360 - (side_angle * current_face);
    goto_face_mv.disable();
}

float CarouselArrangement::get_distant_z_offset(void) 
{
    return -(z_offset_distance + get_base_z_offset());
}

float CarouselArrangement::get_base_z_offset(void) 
{
    return (radius);
}


void CarouselArrangement::do_movement(void) 
{
    if (!goto_face_mv.at_destination())
        goto_face_mv.change_a_bit ();
    else 
        clamp_degrees(&goto_face_val);

}

void CarouselArrangement::do_position_GL(void) 
{
    glTranslatef(0.0f,0.0f, z_offset);

    glRotatef(X_Rot, 1.0f, 0.0f, 0.0f);

    glRotatef(goto_face_val, 0.0f, 1.0f, 0.0f);
}

void CarouselArrangement::goto_random_face(void)
{
    int which_one;

    do {
        which_one = get_randomi (0, (n_columns * n_rows) - 1);
    } while (which_one == (current_col + (current_row * n_rows)));
    
    current_face = which_one;

    goto_face (which_one);
}

void CarouselArrangement::goto_right(void) 
{
    current_face++;
    if (current_face == n_faces)
        current_face = 0;   // cycle around

    // we are "unrolling" rows and columns so map the linear
    // "current_face" back to rows and columns
    current_col = current_face % n_columns;
    current_row = current_face / n_columns;

    if (goto_face_mv.at_destination()) {
        goto_face_mv.init (&goto_face_val, 
                           goto_face_val, goto_face_val - per_face_change, 
                           cfg->options->face_change_steps, move_type);
    } else {
        goto_face_mv.init (&goto_face_val, 
                           goto_face_val, goto_face_mv.destination() - per_face_change, 
                           cfg->options->face_change_steps, move_type);
    }
}

void CarouselArrangement::goto_left(void) 
{
    if (current_face == 0)
        current_face = n_faces - 1;  // cycle around
    else
        current_face--;
        
    // we are "unrolling" rows and columns so map the linear
    // "current_face" back to rows and columns
    current_col = current_face % n_columns;
    current_row = current_face / n_columns;

    if (goto_face_mv.at_destination()) {
        goto_face_mv.init (&goto_face_val, 
                           goto_face_val, goto_face_val + per_face_change, 
                           cfg->options->face_change_steps, move_type);
    } else {
        goto_face_mv.init (&goto_face_val, 
                           goto_face_val, goto_face_mv.destination() + per_face_change, 
                           cfg->options->face_change_steps, move_type);
    }
}

void CarouselArrangement::entry_movement_start(void) 
{
    if (!cfg->options->entry_exit_movement)
        return;

    x_rot_mv.init (&X_Rot,
                   0.0, x_rot_final,
                   cfg->options->zoom_steps,
                   Movement::MOVE_TYPE_SMOOTH);
    Arrangement::entry_movement_start();
}

void CarouselArrangement::exit_movement_start(void) 
{
    if (!cfg->options->entry_exit_movement)
        return;

    x_rot_mv.init(&X_Rot,
                  X_Rot, 0.0,
                  cfg->options->zoom_steps,
                  Movement::MOVE_TYPE_WACK);
    Arrangement::exit_movement_start();
}

void CarouselArrangement::exit_movement_cancel(void) 
{
    if (!cfg->options->entry_exit_movement)
        return;

    x_rot_mv.init(&X_Rot,
                  X_Rot, x_rot_final,
                  cfg->options->zoom_steps,
                  Movement::MOVE_TYPE_WACK);
    Arrangement::exit_movement_cancel();
}

void CarouselArrangement::entry_exit_move(void) 
{
    if (!cfg->options->entry_exit_movement)
        return;

    x_rot_mv.change_a_bit();
    Arrangement::entry_exit_move();
}


#if !defined (ONE_ARRANGEMENT_ONLY)


// ==============================================================
//  CylinderArrangement
// ==============================================================


CylinderArrangement::CylinderArrangement(VDesktops &vdesks, 
					 float fw, float fh, 
					 FaceSet *fs,
					 Config *c)
    : Arrangement (fs, c)
{
    z_offset_distance = 5.0;

    X_Rot = 0.0;
    x_rot_final = 15.0;

    face_width = fw;
    face_height = fh;
    
    calculate_faces(vdesks);
    
    goto_face_mv.disable();
}

void CylinderArrangement::calculate_faces(VDesktops & vdesks) 
{
    vdesks.get_vdesktop_info (&current_col, &current_row,
                              &n_columns, &n_rows);
    
    // current_face becomes the unrolled current face
    current_face = current_col + (current_row * n_columns);

    // n_faces becomes the total number of desktops 
    n_faces = n_columns * n_rows;
                
    side_angle = 360.0 / (float)n_faces;
    per_face_change = side_angle;

    goto_face_val = 360 - (side_angle * current_face);


    float my_angle = ((FOV / 2.0) * PI) / 180.0;
    
    // get_base_z_offset returns radius
    z_offset_close = z_offset = -(float)((face_height/2.0) / tan(my_angle) + 
                                         get_base_z_offset());
    
    int i;
    float half_face_height = face_height / 2.0;
    float half_face_width = face_width / 2.0;

    Point tl,tr,bl,br;
    
    if (n_faces == 2) {

        // 2 faces really messes up becase the faces sandwhich
        // together and you can't see one of the textures so special
        // case it and move them apart

        tl.set (-half_face_width,  half_face_height, two_face_gap);
        tr.set ( half_face_width,  half_face_height, two_face_gap);
        bl.set (-half_face_width, -half_face_height, two_face_gap);
        br.set ( half_face_width, -half_face_height, two_face_gap);

        face_set->set_face (0, tl, tr, bl, br);

        tl.set ( half_face_width,  half_face_height, -two_face_gap);
        tr.set (-half_face_width,  half_face_height, -two_face_gap);
        bl.set ( half_face_width, -half_face_height, -two_face_gap);
        br.set (-half_face_width, -half_face_height, -two_face_gap);

        face_set->set_face (1, tl, tr, bl, br);

    } else {
        polypoints_t pp;

        calculate_polypoints (n_faces, face_width, &pp);
        for (i = 0; i < n_faces; i++) {
            // translate the values calculated for a n-face polygon in
            // a x-y coord system to the 3d x-y-z coords.  we don't
            // need y because the up and down (y-axis) is always
            // either half_face_height or -half_face_height
            
            //msgout(DEBUG, "%u:: x=%lf    y=%lf\n", i, pp.x[i], pp.y[i]);
            
            tl.set( pp.x[i],  half_face_height, -pp.y[i]);
            bl.set( pp.x[i], -half_face_height, -pp.y[i]);
            
            if (i == n_faces - 1) {
                tr.set( pp.x[0],  half_face_height, -pp.y[0]);
                br.set( pp.x[0], -half_face_height, -pp.y[0]);
            } else {
                tr.set( pp.x[i+1],  half_face_height, -pp.y[i+1]);
                br.set( pp.x[i+1], -half_face_height, -pp.y[i+1]);
            }
            
            face_set->set_face (i, tl, tr, bl, br);

        }
    }

    make_display_list();

}

int CylinderArrangement::get_type () 
{
    return FACE_TYPE_CYLINDER;
}

void CylinderArrangement::set_current_face (int c, int r) 
{
    current_col = c;
    current_row = r;
    current_face = c + (r * n_columns);
    goto_face_val = 360 - (side_angle * current_face);
    goto_face_mv.disable();
}

float CylinderArrangement::get_distant_z_offset(void) 
{
    return -(z_offset_distance + get_base_z_offset());
}

float CylinderArrangement::get_base_z_offset(void) 
{
    if (n_faces == 2) {
        return two_face_gap;
    } else {
        return ((face_width/2.0) / tan (deg_to_rad(side_angle/2.0)));
    }
}

// this has to by overridden because of the 'current_face' variable
// which is private to this class
void CylinderArrangement::goto_random_face(void)
{
    int which_one;

    do {
        which_one = get_randomi (0, (n_columns * n_rows) - 1);
    } while (which_one == (current_col + (current_row * n_rows)));
    
    current_face = which_one;

    goto_face (which_one);
}

void CylinderArrangement::goto_right(void) 
{
    current_face++;
    if (current_face == n_faces)
        current_face = 0;   // cycle around

    // we are "unrolling" rows and columns so map the linear
    // "current_face" back to rows and columns
    current_col = current_face % n_columns;
    current_row = current_face / n_columns;

    if (goto_face_mv.at_destination()) {
        goto_face_mv.init (&goto_face_val, 
                           goto_face_val, goto_face_val - per_face_change, 
                           cfg->options->face_change_steps, move_type);
    } else {
        goto_face_mv.init (&goto_face_val, 
                           goto_face_val, goto_face_mv.destination() - per_face_change, 
                           cfg->options->face_change_steps, move_type);
    }
}

void CylinderArrangement::goto_left(void) 
{
    if (current_face == 0)
        current_face = n_faces - 1;  // cycle around
    else
        current_face--;
        
    // we are "unrolling" rows and columns so map the linear
    // "current_face" back to rows and columns
    current_col = current_face % n_columns;
    current_row = current_face / n_columns;

    if (goto_face_mv.at_destination()) {
        goto_face_mv.init (&goto_face_val, 
                           goto_face_val, goto_face_val + per_face_change, 
                           cfg->options->face_change_steps, move_type);
    } else {
        goto_face_mv.init (&goto_face_val, 
                           goto_face_val, goto_face_mv.destination() + per_face_change, 
                           cfg->options->face_change_steps, move_type);
    }
}


void CylinderArrangement::do_movement(void) 
{
    if (!goto_face_mv.at_destination())
        goto_face_mv.change_a_bit ();
    else
        clamp_degrees(&goto_face_val);
}

void CylinderArrangement::do_position_GL(void) 
{
    glTranslatef(0.0f,0.0f, z_offset);

    glRotatef(X_Rot, 1.0f, 0.0f, 0.0f);

    glRotatef(goto_face_val, 0.0f, 1.0f, 0.0f);
}

void CylinderArrangement::entry_movement_start(void) 
{
    //if (!cfg->options->entry_exit_movement)
    //    return;

    x_rot_mv.init (&X_Rot,
                   0.0, x_rot_final,
                   cfg->options->zoom_steps,
                   Movement::MOVE_TYPE_SMOOTH);
    Arrangement::entry_movement_start();
}

void CylinderArrangement::exit_movement_start(void) 
{
    //if (!cfg->options->entry_exit_movement)
    //    return;

    x_rot_mv.init(&X_Rot,
                  X_Rot, 0.0,
                  cfg->options->zoom_steps,
                  Movement::MOVE_TYPE_WACK);
    Arrangement::exit_movement_start();
}

void CylinderArrangement::exit_movement_cancel(void) 
{
    //if (!cfg->options->entry_exit_movement)
    //    return;

    x_rot_mv.init(&X_Rot,
                  X_Rot, x_rot_final,
                  cfg->options->zoom_steps,
                  Movement::MOVE_TYPE_WACK);
    Arrangement::exit_movement_cancel();
}

void CylinderArrangement::entry_exit_move(void) 
{
    if (!cfg->options->entry_exit_movement)
        return;

    x_rot_mv.change_a_bit();
    Arrangement::entry_exit_move();
}




// ==============================================================
//  ViewMasterArrangement
// ==============================================================

ViewMasterArrangement::ViewMasterArrangement(VDesktops &vdesks, 
                                             float fw, float fh,
                                             FaceSet *fs,
                                             Config *c)
    : Arrangement (fs, c)
{
    z_offset_distance = 10.0;
        
    face_width = fw;
    face_height = fh;
                

    calculate_faces(vdesks);

    goto_face_mv.disable();
}

void ViewMasterArrangement::calculate_faces(VDesktops & vdesks)
{
    vdesks.get_vdesktop_info (&current_col, &current_row,
                              &n_columns, &n_rows);
    
    // current_face becomes the unrolled current face
    current_face = current_col + (current_row * n_columns);

    // n_faces becomes the total number of desktops 
    n_faces = n_columns * n_rows;


    between_angle = 360 / n_faces;
    per_face_change = between_angle;

    center_distance = n_faces;  // distance from the center

    if (n_faces <= 3)
        center_distance = 3.5;

    float my_angle = ((FOV / 2.0) * PI) / 180.0;
    
    z_offset_close = z_offset = -(float)((face_height/2.0) / tan(my_angle) + 
                                         get_base_z_offset());

    Point tl,tr,bl,br;
    int i;
    float angle;
    float center_x, center_y;
    float x1, y1, x2, y2, x3, y3, x4, y4;

    float r = sqrt ((face_height*face_height) + 
                    (face_width*face_width)) / 2.0;
    
    float angle_l, angle_s, hangle_l;

    for (i = 0; i < n_faces; i++) {
        angle = between_angle * i;

        center_x = polar_to_x (center_distance, angle);
        center_y = polar_to_y (center_distance, angle);

        hangle_l = rad_to_deg(atan(face_width/face_height));
        angle_l = hangle_l*2.0;
        angle_s = 180 - angle_l;
        

        x1 = polar_to_x(r, 90+angle+hangle_l) + center_x;
        y1 = polar_to_y(r, 90+angle+hangle_l) + center_y;
        x2 = polar_to_x(r, 90+angle-hangle_l) + center_x;
        y2 = polar_to_y(r, 90+angle-hangle_l) + center_y;
        x3 = polar_to_x(r, 90+angle+hangle_l+angle_s) + center_x;