path: root/e-util/e-bit-array.c

/*
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with the program; if not, see <http://www.gnu.org/licenses/>
 *
 *
 * Authors:
 *      Chris Lahey <clahey@ximian.com>
 *
 * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <gtk/gtk.h>

#include "e-bit-array.h"

#define ONES ((guint32) 0xffffffff)

#define BOX(n) ((n) / 32)
#define OFFSET(n) (31 - ((n) % 32))
#define BITMASK(n) ((guint32)(((guint32) 0x1) << OFFSET((n))))
#define BITMASK_LEFT(n) ((((n) % 32) == 0) ? 0 : (ONES << (32 - ((n) % 32))))
#define BITMASK_RIGHT(n) ((guint32)(((guint32) ONES) >> ((n) % 32)))

G_DEFINE_TYPE (
    EBitArray,
    e_bit_array,
    G_TYPE_OBJECT)

static void
e_bit_array_insert_real (EBitArray *bit_array,
                         gint row)
{
    gint box;
    gint i;
    if (bit_array->bit_count >= 0) {
        /* Add another word if needed. */
        if ((bit_array->bit_count & 0x1f) == 0) {
            bit_array->data = g_renew (
                guint32, bit_array->data,
                (bit_array->bit_count >> 5) + 1);
            bit_array->data[bit_array->bit_count >> 5] = 0;
        }

        /* The box is the word that our row is in. */
        box = BOX (row);
        /* Shift all words to the right of our box right one bit. */
        for (i = bit_array->bit_count >> 5; i > box; i--) {
            bit_array->data[i] =
                (bit_array->data[i] >> 1) |
                (bit_array->data[i - 1] << 31);
        }

        /* Shift right half of box one bit to the right. */
        bit_array->data[box] =
            (bit_array->data[box] & BITMASK_LEFT (row)) |
            ((bit_array->data[box] & BITMASK_RIGHT (row)) >> 1);
        bit_array->bit_count++;
    }
}

static void
e_bit_array_delete_real (EBitArray *bit_array,
                         gint row,
                         gboolean move_selection_mode)
{
    gint box;
    gint i;
    gint last;
    gint selected = FALSE;

    if (bit_array->bit_count > 0) {
        guint32 bitmask;
        box = row >> 5;
        last = (bit_array->bit_count - 1) >> 5;

        /* Build bitmasks for the left and right half of the box */
        bitmask = BITMASK_RIGHT (row) >> 1;
        if (move_selection_mode)
            selected = e_bit_array_value_at (bit_array, row);
        /* Shift right half of box one bit to the left. */
        bit_array->data[box] =
            (bit_array->data[box] & BITMASK_LEFT (row)) |
            ((bit_array->data[box] & bitmask) << 1);

        /* Shift all words to the right of our box left one bit. */
        if (box < last) {
            bit_array->data[box] &= bit_array->data[box + 1] >> 31;

            for (i = box + 1; i < last; i++) {
                bit_array->data[i] =
                    (bit_array->data[i] << 1) |
                    (bit_array->data[i + 1] >> 31);
            }
            /* this over-runs our memory! */
            /*bit_array->data[i] = bit_array->data[i] << 1; */
        }
        bit_array->bit_count--;
        /* Remove the last word if not needed. */
        if ((bit_array->bit_count & 0x1f) == 0) {
            bit_array->data = g_renew (guint32, bit_array->data, bit_array->bit_count >> 5);
        }
        if (move_selection_mode && selected && bit_array->bit_count > 0) {
            e_bit_array_select_single_row (
                bit_array, row == bit_array->bit_count ? row - 1 : row);
        }
    }
}

/* FIXME : Improve efficiency here. */
void
e_bit_array_delete (EBitArray *bit_array,
                    gint row,
                    gint count)
{
    gint i;
    for (i = 0; i < count; i++)
        e_bit_array_delete_real (bit_array, row, FALSE);
}

/* FIXME : Improve efficiency here. */
void
e_bit_array_delete_single_mode (EBitArray *bit_array,
                                gint row,
                                gint count)
{
    gint i;
    for (i = 0; i < count; i++)
        e_bit_array_delete_real (bit_array, row, TRUE);
}

/* FIXME : Improve efficiency here. */
void
e_bit_array_insert (EBitArray *bit_array,
                    gint row,
                    gint count)
{
    gint i;
    for (i = 0; i < count; i++)
        e_bit_array_insert_real (bit_array, row);
}

/* FIXME: Implement this more efficiently. */
void
e_bit_array_move_row (EBitArray *bit_array,
                      gint old_row,
                      gint new_row)
{
    e_bit_array_delete_real (bit_array, old_row, FALSE);
    e_bit_array_insert_real (bit_array, new_row);
}

static void
bit_array_finalize (GObject *object)
{
    EBitArray *bit_array;

    bit_array = E_BIT_ARRAY (object);

    g_free (bit_array->data);

    /* Chain up to parent's finalize() method. */
    G_OBJECT_CLASS (e_bit_array_parent_class)->finalize (object);
}

/**
 * e_bit_array_value_at
 * @bit_array: #EBitArray to check
 * @n: The row to check
 *
 * This routine calculates whether the given row is selected.
 *
 * Returns: %TRUE if the given row is selected
 */
gboolean
e_bit_array_value_at (EBitArray *bit_array,
                      gint n)
{
    if (bit_array->bit_count < n || bit_array->bit_count == 0)
        return 0;
    else
        return (bit_array->data[BOX (n)] >> OFFSET (n)) & 0x1;
}

/**
 * e_bit_array_foreach
 * @bit_array: #EBitArray to traverse
 * @callback: The callback function to call back.
 * @closure: The closure
 *
 * This routine calls the given callback function once for each
 * selected row, passing closure as the closure.
 */
void
e_bit_array_foreach (EBitArray *bit_array,
                     EForeachFunc callback,
                     gpointer closure)
{
    gint i;
    gint last = (bit_array->bit_count + 31) / 32;
    for (i = 0; i < last; i++) {
        if (bit_array->data[i]) {
            gint j;
            guint32 value = bit_array->data[i];
            for (j = 0; j < 32; j++) {
                if (value & 0x80000000) {
                    callback (i * 32 + j, closure);
                }
                value <<= 1;
            }
        }
    }
}

#define PART(x,n) (((x) & (0x01010101 << n)) >> n)
#define SECTION(x, n) (((x) >> (n * 8)) & 0xff)

/**
 * e_bit_array_selected_count
 * @bit_array: #EBitArray to count
 *
 * This routine calculates the number of rows selected.
 *
 * Returns: The number of rows selected in the given model.
 */
gint
e_bit_array_selected_count (EBitArray *bit_array)
{
    gint count;
    gint i;
    gint last;

    if (!bit_array->data)
        return 0;

    count = 0;

    last = BOX (bit_array->bit_count - 1);

    for (i = 0; i <= last; i++) {
        gint j;
        guint32 thiscount = 0;
        for (j = 0; j < 8; j++)
            thiscount += PART (bit_array->data[i], j);
        for (j = 0; j < 4; j++)
            count += SECTION (thiscount, j);
    }

    return count;
}

/**
 * e_bit_array_select_all
 * @bit_array: #EBitArray to select all
 *
 * This routine selects all the rows in the given
 * #EBitArray.
 */
void
e_bit_array_select_all (EBitArray *bit_array)
{
    gint i;

    if (!bit_array->data)
        bit_array->data = g_new0 (guint32, (bit_array->bit_count + 31) / 32);

    for (i = 0; i < (bit_array->bit_count + 31) / 32; i++) {
        bit_array->data[i] = ONES;
    }

    /* need to zero out the bits corresponding to the rows not
     * selected in the last full 32 bit mask */
    if (bit_array->bit_count % 32) {
        gint unselected_mask = 0;
        gint num_unselected_in_last_byte = 32 - bit_array->bit_count % 32;

        for (i = 0; i < num_unselected_in_last_byte; i++)
            unselected_mask |= 1 << i;

        bit_array->data[(bit_array->bit_count + 31) / 32 - 1] &= ~unselected_mask;
    }
}

/**
 * e_bit_array_invert_selection
 * @bit_array: #EBitArray to invert
 *
 * This routine inverts all the rows in the given
 * #EBitArray.
 */
void
e_bit_array_invert_selection (EBitArray *bit_array)
{
    gint i;

    if (!bit_array->data)
        bit_array->data = g_new0 (guint32, (bit_array->bit_count + 31) / 32);

    for (i = 0; i < (bit_array->bit_count + 31) / 32; i++) {
        bit_array->data[i] = ~bit_array->data[i];
    }
}

gint
e_bit_array_bit_count (EBitArray *bit_array)
{
    return bit_array->bit_count;
}

#define OPERATE(object, i,mask,grow) \
    ((grow) ? (((object)->data[(i)]) |= ((guint32) ~(mask))) : \
    (((object)->data[(i)]) &= (mask)))

void
e_bit_array_change_one_row (EBitArray *bit_array,
                            gint row,
                            gboolean grow)
{
    gint i;
    i = BOX (row);

    OPERATE (bit_array, i, ~BITMASK (row), grow);
}

void
e_bit_array_change_range (EBitArray *bit_array,
                          gint start,
                          gint end,
                          gboolean grow)
{
    gint i, last;
    if (start != end) {
        i = BOX (start);
        last = BOX (end);

        if (i == last) {
            OPERATE (
                bit_array, i, BITMASK_LEFT (start) |
                BITMASK_RIGHT (end), grow);
        } else {
            OPERATE (bit_array, i, BITMASK_LEFT (start), grow);
            if (grow)
                for (i++; i < last; i++)
                    bit_array->data[i] = ONES;
            else
                for (i++; i < last; i++)
                    bit_array->data[i] = 0;
            OPERATE (bit_array, i, BITMASK_RIGHT (end), grow);
        }
    }
}

void
e_bit_array_select_single_row (EBitArray *bit_array,
                               gint row)
{
    gint i;
    for (i = 0; i < ((bit_array->bit_count + 31) / 32); i++) {
        if (!((i == BOX (row) && bit_array->data[i] == BITMASK (row)) ||
              (i != BOX (row) && bit_array->data[i] == 0))) {
            g_free (bit_array->data);
            bit_array->data = g_new0 (guint32, (bit_array->bit_count + 31) / 32);
            bit_array->data[BOX (row)] = BITMASK (row);

            break;
        }
    }
}

void
e_bit_array_toggle_single_row (EBitArray *bit_array,
                               gint row)
{
    if (bit_array->data[BOX (row)] & BITMASK (row))
        bit_array->data[BOX (row)] &= ~BITMASK (row);
    else
        bit_array->data[BOX (row)] |= BITMASK (row);
}

static void
e_bit_array_init (EBitArray *bit_array)
{
    bit_array->data = NULL;
    bit_array->bit_count = 0;
}

static void
e_bit_array_class_init (EBitArrayClass *class)
{
    GObjectClass *object_class;

    object_class = G_OBJECT_CLASS (class);
    object_class->finalize = bit_array_finalize;
}

EBitArray *
e_bit_array_new (gint count)
{
    EBitArray *bit_array;

    bit_array = g_object_new (E_TYPE_BIT_ARRAY, NULL);
    bit_array->bit_count = count;
    bit_array->data = g_new0 (guint32, (bit_array->bit_count + 31) / 32);

    return bit_array;
}