void caibrateresultquery::on_pushButton_2_clicked()
{
//next button;
if(display_number <= 1)
display_number = CALIBRATE_RESULT_MAX_RECORD;
update_page(--display_number);
}
caibrateresultquery::caibrateresultquery(QWidget *parent) :
QWidget(parent),
ui(new Ui::caibrateresultquery)
{
p_mySettings = MeasurementDataSave::instance();
ui->setupUi(this);
//得到一个下一次标定会记录在哪的数，所以减一就是最新的数
display_number = p_mySettings->value(MYSETTINGS_CALIBRATE_RESULT_COUNT).toInt() - 1;
update_page(display_number);
for(int i = 0; i < ui->tableWidget->columnCount();i++){
ui->tableWidget->setColumnWidth(i, DESKTOP_WIDTH / 9);
}
for(int i = 0; i < 3; i++)
{
ui->tableWidget->setRowHeight(i, DESKTOP_HEIGHT / 10);
}
INIT_LABEL_SIZE_FONT;
QList<QPushButton *> buttonlist = this->findChildren<QPushButton *>();
for (int i = 0; i < buttonlist.count(); ++i) {
buttonlist[i]->setFont(QFont(FONT_NAME, FONT_SIZE ,QFont::Normal));
}
ui->tableWidget->setFont(QFont(FONT_NAME, FONT_SIZE ,QFont::Normal));
ui->label->setFont(QFont(FONT_NAME, FONT_SIZE * 2 ,QFont::Normal));
ui->label->setObjectName("title");
}
/* We must have : 0 <= offset <= b->total_size */
void eb_delete(EditBuffer *b, int offset, int size)
{
int n, len;
Page *del_start, *p;
if (offset >= b->total_size)
return;
b->total_size -= size;
eb_addlog(b, LOGOP_DELETE, offset, size);
/* find the correct page */
p = find_page(b, &offset);
n = 0;
del_start = NULL;
while (size > 0) {
len = p->size - offset;
if (len > size)
len = size;
if (len == p->size) {
if (!del_start)
del_start = p;
/* we cannot free if read only */
if (!(p->flags & PG_READ_ONLY))
free(p->data);
p++;
offset = 0;
n++;
} else {
update_page(p);
memmove(p->data + offset, p->data + offset + len,
p->size - offset - len);
p->size -= len;
p->data = realloc(p->data, p->size);
offset += len;
if (offset >= p->size) {
p++;
offset = 0;
}
}
size -= len;
}
/* now delete the requested pages */
if (n > 0) {
b->nb_pages -= n;
memmove(del_start, del_start + n,
(b->page_table + b->nb_pages - del_start) * sizeof(Page));
b->page_table = realloc(b->page_table, b->nb_pages * sizeof(Page));
}
/* the page cache is no longer valid */
b->cur_page = NULL;
}
/**
* メインループ処理
*
*/
void StageSelectScene::update()
{
get_graphics_manager()->get_fader()->fade_in();
if ( get_input()->push( Input::A ) )
{
if ( is_mouse_on_left_arrow() )
{
update_page( page_ - 1 );
ok_->play( false );
}
else if ( is_mouse_on_right_arrow() )
{
update_page( page_ + 1 );
ok_->play( false );
}
else if ( Stage* stage = get_pointed_stage() )
{
ok_->play( false );
set_next_stage_name( stage->name );
if ( boost::filesystem::exists( string_t( "media/stage/" ) + stage->name + ".intro" ) )
{
set_next_scene( "stage_intro" );
}
else
{
set_next_scene( "game_play" );
}
}
else
{
click_->play( false );
}
}
}
/* We must have : 0 <= offset <= b->total_size */
static void eb_insert_lowlevel(EditBuffer *b, int offset,
const u8 *buf, int size)
{
int len, len_out, page_index;
Page *p;
b->total_size += size;
/* find the correct page */
p = b->page_table;
if (offset > 0) {
offset--;
p = find_page(b, &offset);
offset++;
/* compute what we can insert in current page */
len = MAX_PAGE_SIZE - offset;
if (len > size)
len = size;
/* number of bytes to put in next pages */
len_out = p->size + len - MAX_PAGE_SIZE;
page_index = p - b->page_table;
if (len_out > 0)
eb_insert1(b, page_index + 1,
p->data + p->size - len_out, len_out);
else
len_out = 0;
/* now we can insert in current page */
if (len > 0) {
p = b->page_table + page_index;
update_page(p);
p->size += len - len_out;
p->data = realloc(p->data, p->size);
memmove(p->data + offset + len,
p->data + offset, p->size - (offset + len));
memcpy(p->data + offset, buf, len);
buf += len;
size -= len;
}
} else {
page_index = -1;
}
/* insert the remaining data in the next pages */
if (size > 0)
eb_insert1(b, page_index + 1, buf, size);
/* the page cache is no longer valid */
b->cur_page = NULL;
}
void trace_view_store_set_spin_button(TraceViewStore *store, GtkWidget *spin)
{
g_return_if_fail (TRACE_VIEW_IS_LIST (store));
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin));
if (store->spin)
g_object_unref(store->spin);
store->spin = spin;
g_object_ref(spin);
gtk_spin_button_set_increments(GTK_SPIN_BUTTON(store->spin),
1.0, 5.0);
update_page(store);
}
bool bin_index_t::file_node::set(const data_t& key,const data_t& val)
{
validate_key_len(key);
open_index_file();
if(!root_page)
{
root_page=create_page();
append_page(*root_page);
save_index_data(0,root_page->page_offset);
add_page(root_page);
}
index_t it;
align_key(key,it);
if(get_item(it))
{
index_t old_i=it;
if(it.data_len>=val.size())save_data(it.data_offset,val);
else it.data_offset=append_data(val);
it.data_len=val.size();
if(old_i.data_offset==it.data_offset&&
old_i.data_len==it.data_len)
return false;
update_page(it);
return false;
}
index_t v;
v.key=key;
align_key(key,v);
v.data_len=val.size();
v.data_offset=append_data(val);
add_item(v);
return true;
}
/* internal function for insertion : 'buf' of size 'size' at the
beginning of the page at page_index */
static void eb_insert1(EditBuffer *b, int page_index, const u8 *buf, int size)
{
int len, n;
Page *p;
if (page_index < b->nb_pages) {
p = b->page_table + page_index;
len = MAX_PAGE_SIZE - p->size;
if (len > size)
len = size;
if (len > 0) {
update_page(p);
p->data = realloc(p->data, p->size + len);
memmove(p->data + len, p->data, p->size);
memcpy(p->data, buf + size - len, len);
size -= len;
p->size += len;
}
}
/* now add new pages if necessary */
n = (size + MAX_PAGE_SIZE - 1) / MAX_PAGE_SIZE;
if (n > 0) {
b->nb_pages += n;
b->page_table = realloc(b->page_table, b->nb_pages * sizeof(Page));
p = b->page_table + page_index;
memmove(p + n, p,
sizeof(Page) * (b->nb_pages - n - page_index));
while (size > 0) {
len = size;
if (len > MAX_PAGE_SIZE)
len = MAX_PAGE_SIZE;
p->size = len;
p->data = malloc(len);
p->flags = 0;
memcpy(p->data, buf, len);
buf += len;
size -= len;
p++;
}
}
}
/* Read or write in the buffer. We must have 0 <= offset < b->total_size */
static int eb_rw(EditBuffer *b, int offset, u8 *buf, int size1, int do_write)
{
Page *p;
int len, size;
if ((offset + size1) > b->total_size)
size1 = b->total_size - offset;
if (size1 <= 0)
return 0;
size = size1;
if (do_write)
eb_addlog(b, LOGOP_WRITE, offset, size);
p = find_page(b, &offset);
while (size > 0) {
len = p->size - offset;
if (len > size)
len = size;
if (do_write) {
update_page(p);
memcpy(p->data + offset, buf, len);
} else {
memcpy(buf, p->data + offset, len);
}
buf += len;
size -= len;
offset += len;
if (offset >= p->size) {
p++;
offset = 0;
}
}
return size1;
}
void caibrateresultquery::show_and_update(){
display_number = p_mySettings->value(MYSETTINGS_CALIBRATE_RESULT_COUNT).toInt() - 1;
update_page(display_number);
this->showFullScreen();
}
/* Insert 'size bytes of 'src' buffer from position 'src_offset' into
buffer 'dest' at offset 'dest_offset'. 'src' MUST BE DIFFERENT from
'dest' */
void eb_insert_buffer(EditBuffer *dest, int dest_offset,
EditBuffer *src, int src_offset,
int size)
{
Page *p, *p_start, *q;
int size_start, len, n, page_index;
if (size == 0)
return;
eb_addlog(dest, LOGOP_INSERT, dest_offset, size);
/* insert the data from the first page if it is not completely
selected */
p = find_page(src, &src_offset);
if (src_offset > 0) {
len = p->size - src_offset;
if (len > size)
len = size;
eb_insert_lowlevel(dest, dest_offset, p->data + src_offset, len);
dest_offset += len;
size -= len;
p++;
}
if (size == 0)
return;
/* cut the page at dest offset if needed */
if (dest_offset < dest->total_size) {
q = find_page(dest, &dest_offset);
page_index = q - dest->page_table;
if (dest_offset > 0) {
page_index++;
eb_insert1(dest, page_index, q->data + dest_offset,
q->size - dest_offset);
/* must reload q because page_table may have been
realloced */
q = dest->page_table + page_index - 1;
update_page(q);
q->data = realloc(q->data, dest_offset);
q->size = dest_offset;
}
} else {
page_index = dest->nb_pages;
}
/* update total_size */
dest->total_size += size;
/* compute the number of complete pages to insert */
p_start = p;
size_start = size;
while (size > 0 && p->size <= size) {
size -= p->size;
p++;
}
n = p - p_start; /* number of pages to insert */
p = p_start;
if (n > 0) {
/* add the pages */
dest->nb_pages += n;
dest->page_table = realloc(dest->page_table,
dest->nb_pages * sizeof(Page));
q = dest->page_table + page_index;
memmove(q + n, q,
sizeof(Page) * (dest->nb_pages - n - page_index));
p = p_start;
while (n > 0) {
len = p->size;
q->size = len;
if (p->flags & PG_READ_ONLY) {
/* simply copy the reference */
q->flags = PG_READ_ONLY;
q->data = p->data;
} else {
/* allocate a new page */
q->flags = 0;
q->data = malloc(len);
memcpy(q->data, p->data, len);
}
n--;
p++;
q++;
}
page_index = q - dest->page_table;
}
/* insert the remaning bytes */
if (size > 0) {
eb_insert1(dest, page_index, p->data, size);
}
/* the page cache is no longer valid */
dest->cur_page = NULL;
}
static void merge_sort_rows_ts(TraceViewStore *store)
{
guint64 ts;
gint next;
guint *indexes;
guint count = 0;
gint cpu;
guint i;
indexes = g_new0(guint, store->cpus);
/* Now sort these by timestamp */
do {
next = -1;
ts = 0;
for (cpu = 0; cpu < store->cpus; cpu++) {
if (!store->all_cpus && !mask_cpu_isset(store, cpu))
continue;
try_again:
if (indexes[cpu] == store->cpu_items[cpu])
continue;
i = indexes[cpu];
if (!store->cpu_list[cpu][i].visible) {
indexes[cpu]++;
goto try_again;
}
if (!ts || store->cpu_list[cpu][i].timestamp < ts) {
ts = store->cpu_list[cpu][i].timestamp;
next = cpu;
}
}
if (next >= 0) {
i = indexes[next]++;
store->rows[count] = &store->cpu_list[next][i];
store->cpu_list[next][i].pos = count++;
}
} while (next >= 0);
store->visible_rows = count;
store->start_row = 0;
store->pages = (count / store->rows_per_page) + 1;
if (store->page > 1) {
if (count < store->page * store->rows_per_page)
store->page = store->pages;
/* still greater? */
if (store->page > 1) {
store->start_row =
(store->page - 1) * store->rows_per_page;
g_assert(store->start_row < count);
}
}
store->num_rows = count > (store->start_row + store->rows_per_page) ?
store->rows_per_page :
count - store->start_row;
update_page(store);
g_free(indexes);
}
