void ev_BeOSMouse::mouseUp(BMessage *msg) { AV_View* pView = m_pBeOSFrame->getFrame()->getCurrentView(); EV_EditMethod * pEM; EV_EditModifierState ems = 0; EV_EditEventMapperResult result; EV_EditMouseButton emb = 0; EV_EditMouseOp mop; EV_EditMouseContext emc = 0; BPoint pt; int32 clicks, mod, buttons; msg->FindInt32("clicks", &clicks); msg->FindInt32("buttons", &buttons); msg->FindInt32("modifiers", &mod); msg->FindPoint("where", &pt); UT_DEBUGMSG(("mouseUp: [x=%f y=%f]\n",pt.x, pt.y)); if (mod & B_SHIFT_KEY) ems |= EV_EMS_SHIFT; if (mod & B_CONTROL_KEY) ems |= EV_EMS_CONTROL; if (mod & B_OPTION_KEY) ems |= EV_EMS_ALT; if (buttons & B_PRIMARY_MOUSE_BUTTON) emb = EV_EMB_BUTTON1; else if (buttons & B_SECONDARY_MOUSE_BUTTON) emb = EV_EMB_BUTTON3; else if (buttons & B_TERTIARY_MOUSE_BUTTON) emb = EV_EMB_BUTTON2; //This seems to only crash when I do this detection ... #if 0 mop = EV_EMO_RELEASE; if (m_clickState == EV_EMO_DOUBLECLICK) mop = EV_EMO_DOUBLERELEASE; m_clickState = 0; #endif emc = m_contextState; // report movements under the mouse button that we did the capture on // UT_DEBUGMSG(("onButtonMove: %p [b=%d m=%d]\n",EV_EMO_DRAG|ems, emb, ems)); result = m_pEEM->Mouse(emc|mop|emb|ems, &pEM); switch (result) { case EV_EEMR_COMPLETE: UT_ASSERT(pEM); invokeMouseMethod(pView,pEM,(UT_sint32)pt.x,(UT_sint32)pt.y); return; case EV_EEMR_INCOMPLETE: // I'm not sure this makes any sense, but we allow it. return; case EV_EEMR_BOGUS_START: case EV_EEMR_BOGUS_CONT: // TODO What to do ?? Should we beep at them or just be quiet ?? return; default: UT_ASSERT(0); return; } }
static gboolean s_preview_exposed(GtkWidget * widget, gpointer /* data */, AP_UnixDialog_Lists * me) { UT_ASSERT(widget && me); me->previewExposed(); return FALSE; }
void AP_UnixDialog_Stylist::activate(void) { UT_ASSERT (m_windowMain); gdk_window_raise (m_windowMain->window); }
static void test_heap(void) { struct mock_pop *mpop = MMAP_ANON_ALIGNED(MOCK_POOL_SIZE, Ut_mmap_align); PMEMobjpool *pop = &mpop->p; memset(pop, 0, MOCK_POOL_SIZE); pop->heap_offset = (uint64_t)((uint64_t)&mpop->heap - (uint64_t)mpop); pop->p_ops.persist = obj_heap_persist; pop->p_ops.memset_persist = obj_heap_memset_persist; pop->p_ops.base = pop; pop->set = MALLOC(sizeof(*(pop->set))); pop->set->options = 0; pop->set->directory_based = 0; struct stats *s = stats_new(pop); UT_ASSERTne(s, NULL); void *heap_start = (char *)pop + pop->heap_offset; uint64_t heap_size = MOCK_POOL_SIZE - sizeof(PMEMobjpool); struct palloc_heap *heap = &pop->heap; struct pmem_ops *p_ops = &pop->p_ops; UT_ASSERT(heap_check(heap_start, heap_size) != 0); UT_ASSERT(heap_init(heap_start, heap_size, &pop->heap_size, p_ops) == 0); UT_ASSERT(heap_boot(heap, heap_start, heap_size, &pop->heap_size, pop, p_ops, s, pop->set) == 0); UT_ASSERT(heap_buckets_init(heap) == 0); UT_ASSERT(pop->heap.rt != NULL); test_alloc_class_bitmap_correctness(); test_container((struct block_container *)container_new_ravl(heap), heap); test_container((struct block_container *)container_new_seglists(heap), heap); struct alloc_class *c_small = heap_get_best_class(heap, 1); struct alloc_class *c_big = heap_get_best_class(heap, 2048); UT_ASSERT(c_small->unit_size < c_big->unit_size); /* new small buckets should be empty */ UT_ASSERT(c_big->type == CLASS_RUN); struct memory_block blocks[MAX_BLOCKS] = { {0, 0, 1, 0}, {0, 0, 1, 0}, {0, 0, 1, 0} }; struct bucket *b_def = heap_bucket_acquire_by_id(heap, DEFAULT_ALLOC_CLASS_ID); for (int i = 0; i < MAX_BLOCKS; ++i) { heap_get_bestfit_block(heap, b_def, &blocks[i]); UT_ASSERT(blocks[i].block_off == 0); } heap_bucket_release(heap, b_def); struct memory_block old_run = {0, 0, 1, 0}; struct memory_block new_run = {0, 0, 0, 0}; struct alloc_class *c_run = heap_get_best_class(heap, 1024); struct bucket *b_run = heap_bucket_acquire(heap, c_run); /* * Allocate blocks from a run until one run is exhausted. */ UT_ASSERTne(heap_get_bestfit_block(heap, b_run, &old_run), ENOMEM); int *nresv = bucket_current_resvp(b_run); do { new_run.chunk_id = 0; new_run.block_off = 0; new_run.size_idx = 1; UT_ASSERTne(heap_get_bestfit_block(heap, b_run, &new_run), ENOMEM); UT_ASSERTne(new_run.size_idx, 0); *nresv = 0; } while (old_run.block_off != new_run.block_off); *nresv = 0; heap_bucket_release(heap, b_run); stats_delete(pop, s); UT_ASSERT(heap_check(heap_start, heap_size) == 0); heap_cleanup(heap); UT_ASSERT(heap->rt == NULL); FREE(pop->set); MUNMAP_ANON_ALIGNED(mpop, MOCK_POOL_SIZE); }
/*! * This method creates a new broken toccontainer, broken at the * offset given. * If the new TOCcontainer is broken from a pre-existing * broken TOC it is inserted into the holding vertical container after * the old broken TOC. * It also inserted into the linked list of containers in the vertical * container. * vpos is relative to the either the start of the TOC if it's the first * non-zero vpos or relative to the previous ybreak if it's further down. */ fp_ContainerObject * fp_TOCContainer::VBreakAt(UT_sint32 vpos) { // // Do the case of creating the first broken TOC from the master TOC. // fp_TOCContainer * pBroke = NULL; if(!isThisBroken() && getLastBrokenTOC() == NULL) { if(getFirstBrokenTOC() != NULL) { UT_ASSERT(UT_SHOULD_NOT_HAPPEN); return NULL; } pBroke = new fp_TOCContainer(getSectionLayout(),this); UT_DEBUGMSG(("SEVIOR:!!!!!!! First broken TOC %p \n",pBroke)); pBroke->setYBreakHere(vpos); pBroke->setYBottom(fp_VerticalContainer::getHeight()); // leave this in! UT_ASSERT(pBroke->getHeight()); setFirstBrokenTOC(pBroke); setLastBrokenTOC(pBroke); pBroke->setContainer(getContainer()); static_cast<fp_VerticalContainer *>(pBroke)->setHeight(pBroke->getHeight()); static_cast<fp_VerticalContainer *>(pBroke)->setY(getY()); return pBroke; } // // Now do the case of breaking a Master TOC. // if(getMasterTOC() == NULL) { return getLastBrokenTOC()->VBreakAt(vpos); } UT_sint32 iTotalHeight = getTotalTOCHeight(); if (vpos >= iTotalHeight) { UT_ASSERT(UT_SHOULD_NOT_HAPPEN); return NULL; } pBroke = new fp_TOCContainer(getSectionLayout(),getMasterTOC()); getMasterTOC()->setLastBrokenTOC(pBroke); xxx_UT_DEBUGMSG(("SEVIOR!!!!!!!!!!! New broken TOC %x \n",getLastBrokenTOC())); // // vpos is relative to the container that contains this height but we need // to add in the height above it. // setYBottom(getYBreak() + vpos -1); UT_ASSERT(getHeight() >0); pBroke->setYBreakHere(getYBreak()+vpos); pBroke->setYBottom(iTotalHeight); UT_ASSERT(pBroke->getHeight() > 0); UT_sint32 i = -1; // // The structure of TOC linked list is as follows. // NULL <= Master <==> Next <==> Next => NULL // first // ie terminated by NULL's in the getNext getPrev list. The second // broken TOC points and is pointed to by the Master TOC // pBroke->setPrev(this); fp_Container * pUpCon = NULL; if(getMasterTOC()->getFirstBrokenTOC() == this) { pUpCon = getMasterTOC()->getContainer(); pBroke->setPrev(getMasterTOC()); pBroke->setNext(NULL); getMasterTOC()->setNext(pBroke); setNext(pBroke); if (pUpCon) { i = pUpCon->findCon(getMasterTOC()); } } else { pBroke->setNext(NULL); setNext(pBroke); if(getYBreak() == 0 ) { UT_ASSERT(UT_SHOULD_NOT_HAPPEN); pUpCon = getMasterTOC()->getContainer(); if(pUpCon) { i = pUpCon->findCon(getMasterTOC()); } } else { pUpCon = getContainer(); if (pUpCon) { i = pUpCon->findCon(this); } } } if((i >= 0) && (i < pUpCon->countCons() -1)) { pUpCon->insertConAt(pBroke,i+1); } else if((i >= 0) && (i == pUpCon->countCons() -1)) { pUpCon->addCon(pBroke); } else { UT_DEBUGMSG(("Breaking a TOC that is not yet inserted\n")); } pBroke->setContainer(pUpCon); // // Now deal with issues from a container overlapping the top of the // of the new broken TOC. // // Skip this for now. Look at fp_TableContainer to see if it's needed later // static_cast<fp_VerticalContainer *>(pBroke)->setHeight(pBroke->getHeight()); return pBroke; }
void AP_UnixLeftRuler::getWidgetPosition(gint * x, gint * y) { UT_ASSERT(x && y); gdk_window_get_position(m_wLeftRuler->window, x, y); }
bool GR_Win32Image::convertToBuffer(UT_ByteBuf** ppBB) const { /* The purpose of this routine is to convert our DIB (m_pDIB) into a PNG image, storing it in a ByteBuf and returning it to the caller. */ // Create our bytebuf UT_ByteBuf* pBB = new UT_ByteBuf(); png_structp png_ptr; png_infop info_ptr; // initialize some libpng stuff png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL, (png_error_ptr)NULL, (png_error_ptr)NULL); info_ptr = png_create_info_struct(png_ptr); // libpng will longjmp back to here if a fatal error occurs if (setjmp(png_jmpbuf(png_ptr))) { /* If we get here, we had a problem reading the file */ png_destroy_write_struct(&png_ptr, (png_infopp)NULL); *ppBB = NULL; return false; } // We want libpng to write to our ByteBuf, not stdio png_set_write_fn(png_ptr, (void *)pBB, _png_write, _png_flush); UT_uint32 iWidth = m_pDIB->bmiHeader.biWidth; UT_uint32 iHeight; /* DIBs are usually bottom-up (backwards, if you ask me), but sometimes they are top-down. */ bool bTopDown = false; if (m_pDIB->bmiHeader.biHeight < 0) { iHeight = -(m_pDIB->bmiHeader.biHeight); bTopDown = true; } else { iHeight = (m_pDIB->bmiHeader.biHeight); } png_set_IHDR(png_ptr, info_ptr, iWidth, iHeight, 8, // 8 bits per channel (24 bits) PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); /* Write the file header information. REQUIRED */ png_write_info(png_ptr, info_ptr); /* The next big thing is writing out all of the pixels into the PNG file. We've got quite a bit of code here to handle various kinds of DIB images. */ UT_uint32 iSizeOfColorData = m_pDIB->bmiHeader.biClrUsed * sizeof(RGBQUAD); RGBQUAD* pColors = (RGBQUAD*) (((unsigned char*) m_pDIB) + m_pDIB->bmiHeader.biSize); UT_Byte* pBits = ((unsigned char*) m_pDIB) + m_pDIB->bmiHeader.biSize + iSizeOfColorData; UT_Byte* pData = (UT_Byte*) g_try_malloc(iWidth * iHeight * 3); UT_return_val_if_fail(pData, false); // TODO outofmem UT_uint32 iRow; UT_uint32 iCol; UT_Byte* pRow; UT_uint32 iBytesInRow; /* We can handle a DIB in either 4-bit, 8-bit, or 24-bit format. The way we do this is allocate a single 24-bit buffer, and regardless of what the format of the DIB is, we convert it to our 24-bit buffer. Below, we will copy our 24-bit buffer into the PNG file. */ switch (m_pDIB->bmiHeader.biBitCount) { case 4: { iBytesInRow = iWidth / 2; if (iWidth % 2) { iBytesInRow++; } if (iBytesInRow % 4) { iBytesInRow += (4 - (iBytesInRow % 4)); } for (iRow = 0; iRow<iHeight; iRow++) { if (bTopDown) { pRow = pBits + iRow * iBytesInRow; } else { pRow = pBits + (iHeight - iRow - 1) * iBytesInRow; } for (iCol=0; iCol<iWidth; iCol++) { UT_Byte byt = pRow[iCol / 2]; UT_Byte pixel; if (iCol % 2) { pixel = byt & 0xf; } else { pixel = byt >> 4; } UT_ASSERT(pixel < m_pDIB->bmiHeader.biClrUsed); pData[(iRow*iWidth + iCol)*3 + 0] = pColors[pixel].rgbRed; pData[(iRow*iWidth + iCol)*3 + 1] = pColors[pixel].rgbGreen; pData[(iRow*iWidth + iCol)*3 + 2] = pColors[pixel].rgbBlue; } } break; } case 8: { iBytesInRow = iWidth; if (iBytesInRow % 4) { iBytesInRow += (4 - (iBytesInRow % 4)); } for (iRow = 0; iRow<iHeight; iRow++) { if (bTopDown) { pRow = pBits + iRow * iBytesInRow; } else { pRow = pBits + (iHeight - iRow - 1) * iBytesInRow; } for (iCol=0; iCol<iWidth; iCol++) { UT_Byte pixel = pRow[iCol]; UT_ASSERT(pixel < m_pDIB->bmiHeader.biClrUsed); pData[(iRow*iWidth + iCol)*3 + 0] = pColors[pixel].rgbRed; pData[(iRow*iWidth + iCol)*3 + 1] = pColors[pixel].rgbGreen; pData[(iRow*iWidth + iCol)*3 + 2] = pColors[pixel].rgbBlue; } } break; } case 24: { iBytesInRow = iWidth * 3; if (iBytesInRow % 4) { iBytesInRow += (4 - (iBytesInRow % 4)); } for (iRow = 0; iRow<iHeight; iRow++) { if (bTopDown) { pRow = pBits + iRow * iBytesInRow; } else { pRow = pBits + (iHeight - iRow - 1) * iBytesInRow; } for (iCol=0; iCol<iWidth; iCol++) { pData[(iRow*iWidth + iCol)*3 + 0] = pRow[iCol*3 + 2]; pData[(iRow*iWidth + iCol)*3 + 1] = pRow[iCol*3 + 1]; pData[(iRow*iWidth + iCol)*3 + 2] = pRow[iCol*3 + 0]; } } break; } default: // there are DIB formats we do not support. UT_ASSERT_HARMLESS(UT_TODO); break; } /* Now that we have converted the image to a normalized 24-bit representation, we can save it out to the PNG file. */ for (UT_uint32 i=0; i<iHeight; i++) { UT_Byte *pRow = pData + i * iWidth * 3; png_write_rows(png_ptr, &pRow, 1); } /* We then g_free our 24-bit buffer. */ g_free(pData); /* Wrap things up with libpng */ png_write_end(png_ptr, info_ptr); /* clean up after the write, and g_free any memory allocated */ png_destroy_write_struct(&png_ptr, (png_infopp)NULL); // And pass the ByteBuf back to our caller *ppBB = pBB; return true; }
UT_Error IE_Imp_StarOffice::_loadFile(GsfInput * input) { try { UT_DEBUGMSG(("SDW: Starting import\n")); mOle = GSF_INFILE (gsf_infile_msole_new(input, NULL)); if (!mOle) return UT_IE_BOGUSDOCUMENT; // firstly, load metadata SDWDocInfo::load(mOle, getDoc()); mDocStream = gsf_infile_child_by_name(mOle, "StarWriterDocument"); if (!mDocStream) return UT_IE_BOGUSDOCUMENT; gsf_off_t size = gsf_input_size(mDocStream); if (!appendStrux(PTX_Section, PP_NOPROPS)) return UT_IE_NOMEMORY; UT_DEBUGMSG(("SDW: Attempting to load DocHdr...\n")); mDocHdr.load(mDocStream); UT_DEBUGMSG(("SDW: ...success\n")); // Ask for and verify the password if (mDocHdr.cryptor) { if (!mDocHdr.cryptor->SetPassword(GetPassword().c_str())) { UT_DEBUGMSG(("SDW: Wrong password\n")); return UT_IE_PROTECTED; } } // do the actual reading char type; bool done = false; UT_uint32 recSize; while (!done) { if (gsf_input_tell(mDocStream) == size) break; readChar(mDocStream, type); gsf_off_t eor; readRecSize(mDocStream, recSize, &eor); switch (type) { case SWG_CONTENTS: { gsf_off_t flagsEnd = 0; UT_uint32 nNodes; // sw/source/core/sw3io/sw3sectn.cxx#L129 if (mDocHdr.nVersion >= SWG_LAYFRAMES) { UT_uint8 flags; readFlagRec(mDocStream, flags, &flagsEnd); } if (mDocHdr.nVersion >= SWG_LONGIDX) streamRead(mDocStream, nNodes); else { if (mDocHdr.nVersion >= SWG_LAYFRAMES) { UT_uint16 sectidDummy; streamRead(mDocStream, sectidDummy); } UT_uint16 nodes16; streamRead(mDocStream, nodes16); nNodes = (UT_uint32)nodes16; } if (flagsEnd) { UT_ASSERT(flagsEnd >= gsf_input_tell(mDocStream)); if (gsf_input_tell(mDocStream) != flagsEnd) { UT_DEBUGMSG(("SDW: have not read all flags\n")); if (gsf_input_seek(mDocStream, flagsEnd, G_SEEK_SET)) return UT_IE_BOGUSDOCUMENT; } } bool done2 = false; UT_uint32 size2; while (!done2) { readChar(mDocStream, type); gsf_off_t eor2; readRecSize(mDocStream, size2, &eor2); switch (type) { case SWG_TEXTNODE: { // sw/source/core/sw3io/sw3nodes.cxx#L788 UT_DEBUGMSG(("SDW: Found Textnode! (start at 0x%08llX end at 0x%08llX)\n", (long long)gsf_input_tell(mDocStream), (long long)eor2)); UT_uint8 flags; gsf_off_t newPos; readFlagRec(mDocStream, flags, &newPos); // XXX check flags if (gsf_input_seek(mDocStream, newPos, G_SEEK_SET)) return UT_IE_BOGUSDOCUMENT; // Read the actual text UT_UCS4Char* str; readByteString(mDocStream, str); UT_UCS4String textNode(str); free(str); UT_DEBUGMSG(("SDW: ...length=%zu contents are: |%s|\n", textNode.length(), textNode.utf8_str())); // now get the attributes UT_String attrs; UT_String pAttrs; UT_Vector charAttributes; while (gsf_input_tell(mDocStream) < eor2) { char attVal; streamRead(mDocStream, attVal); UT_uint32 attSize; gsf_off_t eoa; // end of attribute readRecSize(mDocStream, attSize, &eoa); if (attVal == SWG_ATTRIBUTE) { TextAttr* a = new TextAttr; streamRead(mDocStream, *a, eoa); UT_DEBUGMSG(("SDW: ...found text-sub-node, which=0x%x, ver=0x%x, start=%u, end=%u - data:%s len:%llu data is:", a->which, a->ver, a->start, a->end, a->data?"Yes":"No", (long long unsigned)a->dataLen)); #ifdef DEBUG hexdump(a->data, a->dataLen); putc('\n', stderr); #endif charAttributes.addItem(a); } else if (attVal == SWG_ATTRSET) { // bah, yet another loop UT_DEBUGMSG(("SDW: ...paragraph attributes found\n")); while (gsf_input_tell(mDocStream) < eoa) { // reusing attVal and attSize streamRead(mDocStream, attVal); gsf_off_t eoa2; // end of attribute readRecSize(mDocStream, attSize, &eoa2); if (attVal == SWG_ATTRIBUTE) { TextAttr a; streamRead(mDocStream, a, eoa2); if (!a.attrVal.empty()) { if (a.isPara) UT_String_setProperty(pAttrs, a.attrName, a.attrVal); else UT_String_setProperty(attrs, a.attrName, a.attrVal); } UT_DEBUGMSG(("SDW: ......found paragraph attr, which=0x%x, ver=0x%x, start=%u, end=%u (string now %s) Data:%s Len=%lld Data:", a.which, a.ver, (a.startSet?a.start:0), (a.endSet?a.end:0), attrs.c_str(), (a.data ? "Yes" : "No"), (long long)a.dataLen)); #ifdef DEBUG hexdump(a.data, a.dataLen); putc('\n', stderr); #endif } if (gsf_input_seek(mDocStream, eoa2, G_SEEK_SET)) return UT_IE_BOGUSDOCUMENT; } } else { UT_DEBUGMSG(("SDW: ...unknown attribute '%c' found (start=%" GSF_OFF_T_FORMAT " end=%" GSF_OFF_T_FORMAT ")\n", attVal, gsf_input_tell(mDocStream), eoa)); } if (gsf_input_seek(mDocStream, eoa, G_SEEK_SET)) return UT_IE_BOGUSDOCUMENT; } PP_PropertyVector attributes = { "props", pAttrs.c_str() }; // first, insert the paragraph if (!appendStrux(PTX_Block, attributes)) return UT_IE_NOMEMORY; UT_String pca(attrs); // character attributes for the whole paragraph // now insert the spans of text UT_uint32 len = textNode.length(); UT_uint32 lastInsPos = 0; for (UT_uint32 i = 1; i < len; i++) { bool doInsert = false; // whether there was an attribute change for (UT_sint32 j = 0; j < charAttributes.getItemCount(); j++) { const TextAttr* a = reinterpret_cast<const TextAttr*>(charAttributes[j]); // clear the last attribute, if set if (a->endSet && a->end == (i - 1)) { if (a->isOff) { UT_String propval = UT_String_getPropVal(pca, a->attrName); UT_String_setProperty(attrs, a->attrName, propval); } else UT_String_removeProperty(attrs, a->attrName); } // now set new attribute, if needed if (a->startSet && a->start == (i - 1)) { if (a->isPara) UT_String_setProperty(pAttrs, a->attrName, a->attrVal); else if (a->isOff) UT_String_removeProperty(attrs, a->attrName); else UT_String_setProperty(attrs, a->attrName, a->attrVal); } // insert if this is the last character, or if there was a format change if ((a->endSet && a->end == i) || (a->startSet && a->start == i)) doInsert = true; } if (doInsert || i == (len - 1)) { attributes[1] = attrs.c_str(); UT_DEBUGMSG(("SDW: Going to appendFmt with %s\n", attributes[1].c_str())); if (!appendFmt(attributes)) return UT_IE_NOMEMORY; /* leave cast alone! */ UT_DEBUGMSG(("SDW: About to insert %u-%u\n", lastInsPos, i)); size_t spanLen = i - lastInsPos; if (i == (len - 1)) spanLen++; UT_UCS4String span = textNode.substr(lastInsPos, spanLen); appendSpan(span.ucs4_str(), spanLen); lastInsPos = i; } } UT_VECTOR_PURGEALL(TextAttr*, charAttributes); break; } case SWG_JOBSETUP: { // flags are apparently unused here. no idea why they are there. gsf_off_t newpos; UT_uint8 flags; readFlagRec(mDocStream, flags, &newpos); if (gsf_input_seek(mDocStream, newpos, G_SEEK_SET)) return UT_IE_BOGUSDOCUMENT; UT_uint16 len, system; streamRead(mDocStream, len); streamRead(mDocStream, system); char printerName[64]; streamRead(mDocStream, printerName, 64); char deviceName[32], portName[32], driverName[32]; streamRead(mDocStream, deviceName, 32); streamRead(mDocStream, portName, 32); streamRead(mDocStream, driverName, 32); UT_DEBUGMSG(("SDW: Jobsetup: len %u sys 0x%x printer |%.64s| device |%.32s| port |%.32s| driver |%.32s|\n", len, system, printerName, deviceName, portName, driverName)); if (system == JOBSET_FILE364_SYSTEM || system == JOBSET_FILE605_SYSTEM) { UT_uint16 len2, system2; streamRead(mDocStream, len2); streamRead(mDocStream, system2); UT_uint32 ddl; // driver data length streamRead(mDocStream, ddl); // now the interesting data UT_uint16 orient; // 0=portrait 1=landscape streamRead(mDocStream, orient); UT_uint16 paperBin; streamRead(mDocStream, paperBin); UT_uint16 paperFormat; streamRead(mDocStream, paperFormat); UT_uint32 width, height; streamRead(mDocStream, width); streamRead(mDocStream, height); UT_DEBUGMSG(("SDW: orient %u bin %u format %u width %u height %u\n", orient, paperBin, paperFormat, width, height)); // rest of the data is ignored, seems to be printer specific anyway. // Use A4, Portrait by default PP_PropertyVector attributes = { "pagetype", "a4", // A4/Letter/... "orientation", "portrait", "width", "210", "height", "297", "units", "mm" }; const char* sdwPaperToAbi[] = { "A3", "A4", "A5", "B4", "B5", "Letter", "Legal", "Tabloid/Ledger", "Custom" }; if (paperFormat < sizeof(sdwPaperToAbi)/sizeof(*sdwPaperToAbi)) { attributes[1] = sdwPaperToAbi[paperFormat]; } const char* sdwOrientToAbi[] = { "portrait", "landscape" }; if (orient < sizeof(sdwOrientToAbi)/sizeof(*sdwOrientToAbi)) { attributes[3] = sdwOrientToAbi[orient]; } attributes[5] = UT_std_string_sprintf("%f", static_cast<double>(width)/100); attributes[7] = UT_std_string_sprintf("%f", static_cast<double>(height)/100); getDoc()->setPageSizeFromFile(attributes); } break; } case SWG_EOF: done2 = true; break; default: UT_DEBUGMSG(("SDW: SWG_CONTENT: Skipping %u bytes for record type '%c' (starting at 0x%08llX)\n", size2, type, (long long)gsf_input_tell(mDocStream))); } if (gsf_input_seek(mDocStream, eor2, G_SEEK_SET)) return UT_IE_BOGUSDOCUMENT; } break; } case SWG_STRINGPOOL: { if (mDocHdr.nVersion <= SWG_POOLIDS) { UT_ASSERT_HARMLESS(UT_NOT_IMPLEMENTED); break; } UT_uint8 encoding; streamRead(mDocStream, encoding); UT_iconv_t cd = findConverter(encoding); if (!UT_iconv_isValid(cd)) throw UT_IE_IMPORTERROR; UT_uint16 count; streamRead(mDocStream, count); while (count--) { UT_uint16 id; streamRead(mDocStream, id); char* str; UT_uint16 len; ::readByteString(mDocStream, str, &len); if (id == IDX_NOCONV_FF) { UT_ASSERT_HARMLESS(UT_NOT_IMPLEMENTED); } // FIXME: find a way to not have to copy and free // the result of UT_convert_cd.... --hub UT_DEBUGMSG(("SDW: StringPool: found 0x%04x <-> %.*s\n", id, len, str)); UT_UCS4Char* convertedString = reinterpret_cast<UT_UCS4Char*>(UT_convert_cd(str, len + 1, cd, NULL, NULL)); mStringPool.insert(stringpool_map::value_type(id, convertedString)); FREEP(convertedString); delete [] str; } UT_iconv_close(cd); break; } case SWG_COMMENT: // skip over comments break; case SWG_EOF: done = true; break; default: UT_DEBUGMSG(("SDW: Skipping %u bytes for record type '%c' (starting at 0x%08llX)\n", recSize, type, (long long)gsf_input_tell(mDocStream))); } // Seek to the end of the record, in case it wasn't read completely if (gsf_input_seek(mDocStream, eor, G_SEEK_SET)) return UT_IE_BOGUSDOCUMENT; } UT_DEBUGMSG(("SDW: Done\n")); return UT_OK; } catch(UT_Error e) { UT_DEBUGMSG(("SDW: error %d\n", e)); return e; } catch(...) { UT_DEBUGMSG(("SDW: Unknown error\n")); return UT_IE_BOGUSDOCUMENT; } }
void AP_UnixLeftRuler::_fe::unrealize(AP_UnixLeftRuler *self) { UT_ASSERT(self->m_pG); DELETEP(self->m_pG); }
void Object_ChangeRecordSessionPacket::serialize( Archive& ar ) { Props_ChangeRecordSessionPacket::serialize( ar ); UT_ASSERT(sizeof(m_eObjectType)==4); ar << (int&)m_eObjectType; }
/*! * Take a packet, interpret it's contents and apply the implied operations on the document. */ bool ABI_Collab_Import::_import(const SessionPacket& packet, UT_sint32 iImportAdjustment, BuddyPtr pCollaborator, bool inGlob) { UT_DEBUGMSG(("ABI_Collab_Import::_import() - packet class type: %d, iImportAdjustment: %d\n", packet.getClassType(), iImportAdjustment)); UT_return_val_if_fail(pCollaborator, false); switch (packet.getClassType()) { case PCT_GlobSessionPacket: { const GlobSessionPacket* gp = static_cast<const GlobSessionPacket*>(&packet); UT_return_val_if_fail(gp->getPackets().size() > 0, false); // store the last seen revision from this collaborator (it is immediately used by the export) m_remoteRevs[pCollaborator] = gp->getRev(); for (UT_uint32 j = 0; j < gp->getPackets().size(); j++) { SessionPacket* pGlobPacket = gp->getPackets()[j]; if (pGlobPacket) { bool res = _import(*pGlobPacket, iImportAdjustment, pCollaborator, true); // yay for recursion :) if (!res) { UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN); } } } return true; } case PCT_SignalSessionPacket: { const SignalSessionPacket* sp = static_cast<const SignalSessionPacket*>(&packet); m_pDoc->signalListeners(sp->getSignalType()); return true; } case PCT_RevertSessionPacket: { const RevertSessionPacket* rrp = static_cast<const RevertSessionPacket*>(&packet); UT_DEBUGMSG(("Revert packet seen on import for rev: %d\n", rrp->getRev())); if (m_iAlreadyRevertedRevs.size() == 0 || m_iAlreadyRevertedRevs.front() != rrp->getRev()) { UT_DEBUGMSG(("Incoming revert for revision %d, which we didn't detect locally (m_iAlreadyRevertedRev: %d)!\n", rrp->getRev(), m_iAlreadyRevertedRevs.front())); UT_DEBUGMSG(("DOCUMENT OUT OF SYNC DETECTED!!!!\n")); UT_ASSERT_HARMLESS(UT_NOT_IMPLEMENTED); return false; } m_iAlreadyRevertedRevs.pop_front(); return true; } case PCT_RevertAckSessionPacket: { UT_DEBUGMSG(("RevertAck packet seen on import for rev: %d\n", static_cast<const RevertAckSessionPacket*>(&packet)->getRev())); // remove this collaborator from our revert ack list; he can play again... for (std::vector<std::pair<BuddyPtr, UT_sint32> >::iterator it = m_revertSet.begin(); it != m_revertSet.end(); it++) { if ((*it).first == pCollaborator) { UT_DEBUGMSG(("Found collaborator %s on our revert ack list with rev %d! Removing him from the list...\n", (*it).first->getDescription().utf8_str(), (*it).second)); UT_ASSERT_HARMLESS((*it).second == static_cast<const RevertAckSessionPacket*>(&packet)->getRev()); m_revertSet.erase(it); return true; } } UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN); return false; } default: // silly C++ can't switch on ranges if (packet.getClassType() >= _PCT_FirstChangeRecord && packet.getClassType() <= _PCT_LastChangeRecord) { const ChangeRecordSessionPacket* crp = static_cast<const ChangeRecordSessionPacket*>(&packet); UT_DEBUGMSG(("It's safe to import this packet\n")); UT_DEBUGMSG(("For CR number %d requested point %d adjustment %d \n", crp->getRev(), crp->getPos(), iImportAdjustment)); PT_DocPosition pos = static_cast<PT_DocPosition>(crp->getPos() + iImportAdjustment); UT_ASSERT(pos <= getEndOfDoc()); if (!inGlob) { // store the last seen revision from this collaborator (it is immediately used by the export) // NOTE: if this changerecord is part of a glob, then we don't do this; we'll have // already set the revision of the glob itself as the last seen one m_remoteRevs[pCollaborator] = crp->getRev(); } // todo: remove these temp vars PT_DocPosition iPos2 = 0; // process the packet switch(crp->getPXType()) { case PX_ChangeRecord::PXT_GlobMarker: { UT_DEBUGMSG(("Found GLOB marker (ignoring)\n")); return true; } case PX_ChangeRecord::PXT_InsertSpan: { const InsertSpan_ChangeRecordSessionPacket* icrsp = static_cast<const InsertSpan_ChangeRecordSessionPacket*>( crp ); UT_UCS4String UCSChars = const_cast<UT_UTF8String&>(icrsp->m_sText).ucs4_str(); // ugly, ucs4_str should be const func! PP_AttrProp attrProp; attrProp.setAttributes(const_cast<const gchar**>(icrsp->getAtts())); attrProp.setProperties(const_cast<const gchar**>(icrsp->getProps())); m_pDoc->insertSpan(pos,UCSChars.ucs4_str(),UCSChars.length(), &attrProp); break; } case PX_ChangeRecord::PXT_DeleteSpan: { iPos2 = pos + crp->getLength(); PP_AttrProp *p_AttrProp_Before = NULL; UT_uint32 icnt = 0; m_pDoc->deleteSpan(pos,iPos2,p_AttrProp_Before,icnt,true); break; } case PX_ChangeRecord::PXT_ChangeSpan: { const Props_ChangeRecordSessionPacket* pcrsp = static_cast<const Props_ChangeRecordSessionPacket*>( crp ); gchar** szAtts = pcrsp->getAtts(); gchar** szProps = pcrsp->getProps(); iPos2 = pos + pcrsp->getLength(); if((szProps == NULL) && (szAtts == NULL)) { // // This happens if we remove all formats // we have to handle this seperately // // Get style of containing block // pf_Frag_Strux* sdh = NULL; m_pDoc->getStruxOfTypeFromPosition(pos,PTX_Block,&sdh); if(!sdh) { UT_ASSERT(UT_SHOULD_NOT_HAPPEN); return false; } PD_Style * pStyle = m_pDoc->getStyleFromSDH(sdh); if(!pStyle) { UT_ASSERT(UT_SHOULD_NOT_HAPPEN); return false; } const gchar * szName = pStyle->getName(); const gchar * atts[3] = {PT_STYLE_ATTRIBUTE_NAME,szName,NULL}; m_pDoc->changeSpanFmt(PTC_SetExactly, pos, iPos2, atts, const_cast<const gchar**>( szProps ) ); } else { m_pDoc->changeSpanFmt(PTC_SetExactly, pos, iPos2, const_cast<const gchar**>(szAtts), const_cast<const gchar**>( szProps ) ); } break; } case PX_ChangeRecord::PXT_InsertStrux: { const ChangeStrux_ChangeRecordSessionPacket* pcrsp = static_cast<const ChangeStrux_ChangeRecordSessionPacket*>( crp ); PTStruxType pts = pcrsp->m_eStruxType; gchar** szAtts = pcrsp->getAtts(); gchar** szProps = pcrsp->getProps(); if((szProps != NULL) || (szAtts != NULL)) { m_pDoc->insertStrux( pos, pts, const_cast<const gchar**>( szAtts ), const_cast<const gchar**>( szProps ) ); } else { m_pDoc->insertStrux(pos, pts); } break; } case PX_ChangeRecord::PXT_DeleteStrux: { const DeleteStrux_ChangeRecordSessionPacket* pcrsp = static_cast<const DeleteStrux_ChangeRecordSessionPacket*>( crp ); PTStruxType pts = pcrsp->m_eStruxType; m_pDoc->deleteStrux(pos,pts,true); break; } case PX_ChangeRecord::PXT_ChangeStrux: { const ChangeStrux_ChangeRecordSessionPacket* pcrsp = static_cast<const ChangeStrux_ChangeRecordSessionPacket*>( crp ); PTStruxType pts = pcrsp->m_eStruxType; gchar** szAtts = pcrsp->getAtts(); gchar** szProps = pcrsp->getProps(); UT_return_val_if_fail(szProps != NULL || szAtts != NULL, false); UT_DEBUGMSG(("Executing ChangeStrux pos= %d \n",pos)); m_pDoc->changeStruxFmt(PTC_SetExactly, pos, pos, const_cast<const gchar**>( szAtts ), const_cast<const gchar**>( szProps ), pts); // TODO: this mask is waaaay to generic XAP_Frame *pFrame = XAP_App::getApp()->getLastFocussedFrame(); if (pFrame) { FV_View* pView = static_cast<FV_View*>(pFrame->getCurrentView()); if (pView) pView->notifyListeners(AV_CHG_TYPING | AV_CHG_FMTCHAR | AV_CHG_FMTBLOCK | AV_CHG_PAGECOUNT | AV_CHG_FMTSTYLE ); } break; } case PX_ChangeRecord::PXT_InsertObject: { const Object_ChangeRecordSessionPacket* ocrsp = static_cast<const Object_ChangeRecordSessionPacket*>( crp ); PTObjectType pto = ocrsp->getObjectType(); gchar** szAtts = ocrsp->getAtts(); gchar** szProps = ocrsp->getProps(); if((szProps == NULL) && (szAtts == NULL)) { UT_ASSERT(UT_SHOULD_NOT_HAPPEN); return false; } m_pDoc->insertObject(pos, pto, const_cast<const gchar**>( szAtts ), const_cast<const gchar**>( szProps ) ); break; } case PX_ChangeRecord::PXT_DeleteObject: { iPos2 = pos + 1; PP_AttrProp *p_AttrProp_Before = NULL; UT_uint32 icnt = 0; m_pDoc->deleteSpan(pos, iPos2, p_AttrProp_Before, icnt, true); break; } case PX_ChangeRecord::PXT_ChangeObject: { const Object_ChangeRecordSessionPacket* ccrsp = static_cast<const Object_ChangeRecordSessionPacket*>( crp ); //PTObjectType pto = ccrsp->m_eObjectType; gchar** szAtts = ccrsp->getAtts(); gchar** szProps = ccrsp->getProps(); if ((szProps == NULL) && (szAtts == NULL)) { UT_ASSERT(UT_SHOULD_NOT_HAPPEN); return false; } m_pDoc->changeSpanFmt(PTC_SetExactly, pos, pos + 1, const_cast<const gchar**>( szAtts ), const_cast<const gchar**>( szProps )); break; } case PX_ChangeRecord::PXT_ChangeDocRDF: { // down cast crp to get dcrp const RDF_ChangeRecordSessionPacket* dcrp = static_cast<const RDF_ChangeRecordSessionPacket*>( crp ); gchar** szAtts = dcrp->getAtts(); gchar** szProps = dcrp->getProps(); if ((szProps == NULL) && (szAtts == NULL)) { UT_ASSERT(UT_SHOULD_NOT_HAPPEN); return false; } { // update the local document RDF to remove // szAtts RDF and then add the szProps RDF m_pDoc->getDocumentRDF()->handleCollabEvent( szAtts, szProps ); } break; } case PX_ChangeRecord::PXT_InsertFmtMark: { const Props_ChangeRecordSessionPacket* pcrsp = static_cast<const Props_ChangeRecordSessionPacket*>( crp ); gchar** szAtts = pcrsp->getAtts(); gchar** szProps = pcrsp->getProps(); if((szProps == NULL) && (szAtts == NULL)) { // nothing to do here, please move along // NOTE: why does this happen anyway? // This happens when for example when sending over tables: UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN); return false; } return m_pDoc->changeSpanFmt(PTC_SetExactly, pos, pos, const_cast<const gchar**>( szAtts ), const_cast<const gchar**>( szProps )); } case PX_ChangeRecord::PXT_DeleteFmtMark: { return m_pDoc->deleteFmtMark(pos); } case PX_ChangeRecord::PXT_ChangeFmtMark: { const Props_ChangeRecordSessionPacket* pcrsp = static_cast<const Props_ChangeRecordSessionPacket*>( crp ); gchar** szAtts = pcrsp->getAtts(); gchar** szProps = pcrsp->getProps(); if ((szProps == NULL) && (szAtts == NULL)) { UT_ASSERT(UT_SHOULD_NOT_HAPPEN); return false; } return m_pDoc->changeSpanFmt(PTC_SetExactly, pos, pos, const_cast<const gchar**>( szAtts ), const_cast<const gchar**>( szProps )); } case PX_ChangeRecord::PXT_ChangePoint: { UT_DEBUGMSG(("Change Point CR \n")); return m_pDoc->createAndSendCR(pos, crp->getPXType(), true, 0); } case PX_ChangeRecord::PXT_ListUpdate: { UT_DEBUGMSG(("ListUpdate CR \n")); return m_pDoc->createAndSendCR(pos, crp->getPXType(), true,0); } case PX_ChangeRecord::PXT_StopList: { UT_DEBUGMSG(("StopList CR \n")); return m_pDoc->createAndSendCR(pos, crp->getPXType(), true,0); } case PX_ChangeRecord::PXT_UpdateField: { UT_DEBUGMSG(("UpdateFiled CR \n")); return m_pDoc->createAndSendCR(pos, crp->getPXType(), true,0); } case PX_ChangeRecord::PXT_RemoveList: { UT_DEBUGMSG(("RemoveList CR \n")); return m_pDoc->createAndSendCR(pos, crp->getPXType(), true,0); } case PX_ChangeRecord::PXT_UpdateLayout: { UT_DEBUGMSG(("UpdateLayout CR \n")); return m_pDoc->createAndSendCR(pos, crp->getPXType(), true,0); } case PX_ChangeRecord::PXT_CreateDataItem: { const Data_ChangeRecordSessionPacket* dp = static_cast<const Data_ChangeRecordSessionPacket*>( crp ); const char * szNameV = g_strdup(dp->getAttribute(PT_DATAITEM_ATTRIBUTE_NAME)); PD_DataItemHandle pHandle = NULL; std::string sToken = dp->m_bTokenSet ? dp->m_sToken : ""; UT_ByteBuf * pBuf= new UT_ByteBuf(); UT_DEBUGMSG(("PXT_CreateDataItem: append image buffer @ 0x%p, %lu bytes, sToken %s\n", &dp->m_vecData[0], (long unsigned)dp->m_vecData.size(), sToken.c_str())); pBuf->append(reinterpret_cast<const UT_Byte *>( &dp->m_vecData[0] ), dp->m_vecData.size() ); bool res = m_pDoc->createDataItem(szNameV,false,pBuf,sToken,&pHandle); delete pBuf; return res; } case PX_ChangeRecord::PXT_ChangeDocProp: { UT_DEBUGMSG(("ChangeDocProp CR \n")); const Props_ChangeRecordSessionPacket* pcrsp = static_cast<const Props_ChangeRecordSessionPacket*>( crp ); // // Assemble the Attributes for different properties // const gchar** szAtts = const_cast<const gchar **>(pcrsp->getAtts()); const gchar** szProps = const_cast<const gchar **>(pcrsp->getProps()); // // Now direct the document to make the changes // return m_pDoc->changeDocPropeties(szAtts,szProps); } default: { UT_DEBUGMSG(("Unimplemented crp->getPXType(): %d\n", crp->getPXType())); UT_ASSERT_HARMLESS(UT_NOT_IMPLEMENTED); break; } } return true; } else { UT_DEBUGMSG(("ABI_Collab_Import::import called with unhandled packet class type: %d!\n", packet.getClassType())); return false; } break; } return false; }
void DeleteStrux_ChangeRecordSessionPacket::serialize( Archive& ar ) { ChangeRecordSessionPacket::serialize( ar ); UT_ASSERT(sizeof(m_eStruxType)==4); ar << (int&)m_eStruxType; }
static void s_types_clicked(GtkTreeView *treeview, AP_UnixDialog_Field * dlg) { UT_ASSERT(treeview && dlg); dlg->types_changed(treeview); }
ut_setup() { UT_ASSERT(!os_net_init()); }
// ASSUMPTION: We assume that unordered lists will always pass a number of "0". unpredictable behaviour // may result otherwise void IE_Imp_WordPerfect::openListElement(const librevenge::RVNGPropertyList &propList) { if (m_bHdrFtrOpenCount) return; // HACK UT_DEBUGMSG(("AbiWordPerfect: openListElement\n")); UT_ASSERT(m_pCurrentListDefinition); // FIXME: ABI_LISTS_IMPORT throw an exception back to libwpd, if this fails // Paragraph properties for our list element UT_String szListID; UT_String szParentID; UT_String szLevel; UT_String_sprintf(szListID,"%d",m_pCurrentListDefinition->getListID(m_iCurrentListLevel)); if (m_iCurrentListLevel > 1) UT_String_sprintf(szParentID,"%d", m_pCurrentListDefinition->getListID((m_iCurrentListLevel-1))); else UT_String_sprintf(szParentID,"0"); UT_String_sprintf(szLevel,"%d", m_iCurrentListLevel); const gchar* listAttribs[PT_MAX_ATTRIBUTES*2 + 1]; UT_uint32 attribsCount=0; listAttribs[attribsCount++] = PT_LISTID_ATTRIBUTE_NAME; listAttribs[attribsCount++] = szListID.c_str(); listAttribs[attribsCount++] = PT_PARENTID_ATTRIBUTE_NAME; listAttribs[attribsCount++] = szParentID.c_str(); listAttribs[attribsCount++] = PT_LEVEL_ATTRIBUTE_NAME; listAttribs[attribsCount++] = szLevel.c_str(); // Now handle the Abi List properties UT_String propBuffer; UT_String tempBuffer; UT_String_sprintf(tempBuffer,"list-style:%i;", m_pCurrentListDefinition->getListType(m_iCurrentListLevel)); propBuffer += tempBuffer; #if 0 // FIXME: writing the list delimiter is kind of tricky and silly (because wordperfect wants to define // it within the document, while abi wants to (sensibly probably) define it in the list definition) // (we reset it each time but only for numbered lists) if (listDefinition->isLevelNumbered(m_iCurrentListLevel)) { UT_DEBUGMSG(("WordPerfect: Appending this list delim: %s\n", m_rightListDelim.c_str())); listDefinition->setListRightDelimText(m_iCurrentListLevel, m_rightListDelim.c_str()); X_CheckWordPerfectError(_updateDocumentListDefinition(listDefinition, m_iCurrentListLevel)); } #endif if (m_pCurrentListDefinition->getListType(m_iCurrentListLevel) == BULLETED_LIST) UT_String_sprintf(tempBuffer, "field-font:Symbol; "); else UT_String_sprintf(tempBuffer, "field-font:NULL; "); m_pCurrentListDefinition->incrementLevelNumber(m_iCurrentListLevel); propBuffer += tempBuffer; UT_String_sprintf(tempBuffer, "start-value:%i; ", 1); propBuffer += tempBuffer; UT_String_sprintf(tempBuffer, "margin-left:%.4fin; ", m_pCurrentListDefinition->getListLeftOffset(m_iCurrentListLevel) + m_pCurrentListDefinition->getListMinLabelWidth(m_iCurrentListLevel) - (propList["fo:text-indent"] ? propList["fo:text-indent"]->getDouble() : 0.0f)); propBuffer += tempBuffer; UT_String_sprintf(tempBuffer, "text-indent:%.4fin", - m_pCurrentListDefinition->getListMinLabelWidth(m_iCurrentListLevel) + (propList["fo:text-indent"] ? propList["fo:text-indent"]->getDouble() : 0.0f)); propBuffer += tempBuffer; listAttribs[attribsCount++] = PT_PROPS_ATTRIBUTE_NAME; listAttribs[attribsCount++] = propBuffer.c_str(); listAttribs[attribsCount++] = NULL; X_CheckDocumentError(appendStrux(PTX_Block, PP_std_copyProps(listAttribs))); m_bRequireBlock = false; // hang text off of a list label getDoc()->appendFmtMark(); UT_DEBUGMSG(("WordPerfect: LISTS - Appended a list tag def'n (character props)\n")); // append a list field label PP_PropertyVector fielddef = { "type", "list_label" }; X_CheckDocumentError(appendObject(PTO_Field,fielddef)); UT_DEBUGMSG(("WordPerfect: LISTS - Appended a field def'n\n")); // insert a tab UT_UCS4Char ucs = UCS_TAB; X_CheckDocumentError(appendSpan(&ucs,1)); }
int main(int argc, char *argv[]) { START(argc, argv, "obj_pvector"); if (argc != 2) UT_FATAL("usage: %s [file]", argv[0]); const char *path = argv[1]; PMEMobjpool *pop; if ((pop = pmemobj_create(path, "obj_pvector", PMEMOBJ_MIN_POOL, S_IWUSR | S_IRUSR)) == NULL) UT_FATAL("!pmemobj_create: %s", path); PMEMoid root = pmemobj_root(pop, sizeof(struct test_root)); struct test_root *r = pmemobj_direct(root); UT_ASSERTne(r, NULL); struct pvector_context *ctx = pvector_new(pop, &r->vec); uint64_t *val = pvector_push_back(ctx); *val = 5; val = pvector_push_back(ctx); *val = 10; val = pvector_push_back(ctx); *val = 15; uint64_t v; int n = 0; for (v = pvector_first(ctx); v != 0; v = pvector_next(ctx)) { if (n == 0) UT_ASSERTeq(v, 5); if (n == 1) UT_ASSERTeq(v, 10); if (n == 2) UT_ASSERTeq(v, 15); if (n == 3) UT_ASSERT(0); n++; } uint64_t removed = pvector_pop_back(ctx, NULL); UT_ASSERTeq(removed, 15); n = 0; for (v = pvector_first(ctx); v != 0; v = pvector_next(ctx)) { if (n == 0) UT_ASSERTeq(v, 5); if (n == 1) UT_ASSERTeq(v, 10); if (n == 3) UT_ASSERT(0); n++; } while (pvector_pop_back(ctx, vec_zero_entry) != 0) ; pvector_delete(ctx); ctx = pvector_new(pop, &r->vec); for (int i = 0; i < PVECTOR_INSERT_VALUES; ++i) { val = pvector_push_back(ctx); UT_ASSERTne(val, NULL); *val = i; } n = 0; for (v = pvector_first(ctx); v != 0; v = pvector_next(ctx)) { UT_ASSERTeq(v, n); n++; } n = 0; for (int i = PVECTOR_INSERT_VALUES - 1; i >= 0; --i) { v = pvector_pop_back(ctx, NULL); UT_ASSERTeq(v, i); } UT_ASSERTeq(pvector_first(ctx), 0); pvector_delete(ctx); pmemobj_close(pop); DONE(NULL); }
BOOL XAP_Win32Dialog_Insert_Symbol::_onInitDialog(HWND hWnd, WPARAM /*wParam*/, LPARAM /*lParam*/) { m_hDlg = hWnd; // localize controls localizeControlText(XAP_RID_DIALOG_INSERTSYMBOL_INSERT_BUTTON,XAP_STRING_ID_DLG_Insert); localizeControlText(XAP_RID_DIALOG_INSERTSYMBOL_CLOSE_BUTTON,XAP_STRING_ID_DLG_Close); // *** this is how we add the gc for symbol table *** // attach a new graphics context to the drawing area XAP_Win32App * app = static_cast<XAP_Win32App *> (m_pApp); UT_ASSERT(app); HWND hwndChild = GetDlgItem(hWnd, XAP_RID_DIALOG_INSERTSYMBOL_SYMBOLS); m_pSymbolPreviewWidget = new XAP_Win32PreviewWidget(static_cast<XAP_Win32App *>(m_pApp), hwndChild, 0); UT_uint32 w,h; m_pSymbolPreviewWidget->getWindowSize(&w,&h); _createSymbolFromGC(m_pSymbolPreviewWidget->getGraphics(), w, h); m_pSymbolPreviewWidget->setPreview(m_DrawSymbol); m_pSymbolPreviewWidget->setInsertSymbolParent(this); hwndChild = GetDlgItem(hWnd, XAP_RID_DIALOG_INSERTSYMBOL_SYMBOL_PREVIEW); m_pSamplePreviewWidget = new XAP_Win32PreviewWidget(static_cast<XAP_Win32App *>(m_pApp), hwndChild, 0); m_pSamplePreviewWidget->getWindowSize(&w,&h); _createSymbolareaFromGC(m_pSamplePreviewWidget->getGraphics(), w, h); m_DrawSymbolSample = new XAP_Draw_Symbol_sample(m_DrawSymbol, m_pSamplePreviewWidget->getGraphics()); // TODO: Colour GR_Win32Graphics* gr = (GR_Win32Graphics*) m_DrawSymbolSample->m_pSymbolDraw->getGraphics(); gr->setBrush((HBRUSH)GetSysColorBrush(COLOR_3DFACE)); m_pSamplePreviewWidget->setPreview(m_DrawSymbolSample); XAP_Draw_Symbol * iDrawSymbol = _getCurrentSymbolMap(); UT_ASSERT(iDrawSymbol); // Fill the list box with symbol fonts. HDC hDCScreen = CreateDC("DISPLAY", NULL, NULL, NULL); #if 1 EnumFontFamilies(hDCScreen, (const char *)NULL, (FONTENUMPROC)fontEnumProcedure, (LPARAM)this); #else LOGFONT LogFont; // LogFont.lfCharSet = SYMBOL_CHARSET; - all fonts enum is more inline with XP nature LogFont.lfCharSet = DEFAULT_CHARSET; LogFont.lfFaceName[0] = '\0'; EnumFontFamiliesEx(hDCScreen, &LogFont, (FONTENUMPROC)fontEnumProcedure, (LPARAM)this, 0); #endif DeleteDC(hDCScreen); // Select the current font. UT_sint32 Index = SendDlgItemMessage(m_hDlg, XAP_RID_DIALOG_INSERTSYMBOL_FONT_LIST, CB_FINDSTRING, -1, (LPARAM)Symbol_font_selected); if(Index != -1) { _setFontFromCombo(Index); } else { _setFontFromCombo(0); } // Update the caption ConstructWindowName(); setDialogTitle((LPCSTR)(AP_Win32App::s_fromUTF8ToWinLocale(m_WindowName)).c_str()); centerDialog(); return 1; // 1 == we did not call SetFocus() }
void GetTypeTest::runTest() { HX_RESULT res; StreamType type; // 3a. call before callinq SetStreamCount // expected result: HXR_FAIL // 3b. call before calling OnStreamHeader // expected result: HXR_FAIL init(); res = m_pBRD->GetType(0, 0, type); UT_ASSERT(res == HXR_FAIL); cleanup(); // 3c. call without providing mime type // expected result: HXR_FAIL init(); res = m_pBRD->SetStreamCount(1); UT_ASSERT(res == HXR_OK); m_pSHdr->SetPropertyULONG32("StreamNumber", 0); res = m_pBRD->OnStreamHeader(m_pSHdr); UT_ASSERT(res == HXR_OK); res = m_pBRD->GetType(0, 0, type); UT_ASSERT(res == HXR_FAIL); cleanup(); // 3d. call with mime type // expected result: HXR_OK // 3e. call with in range stream number // expected result: HXR_OK init(); res = m_pBRD->SetStreamCount(1); UT_ASSERT(res == HXR_OK); m_pSHdr->SetPropertyULONG32("StreamNumber", 0); m_pBufA->Set((const UCHAR*)"audio/foo", 9); m_pSHdr->SetPropertyCString("MimeType", m_pBufA); res = m_pBRD->OnStreamHeader(m_pSHdr); UT_ASSERT(res == HXR_OK); res = m_pBRD->GetType(0, 0, type); UT_ASSERT(res == HXR_OK); cleanup(); // 3f. call with out of range stream number // expected result: HXR_FAIL init(); res = m_pBRD->SetStreamCount(1); UT_ASSERT(res == HXR_OK); m_pSHdr->SetPropertyULONG32("StreamNumber", 0); m_pBufA->Set((const UCHAR*)"audio/foo", 9); m_pSHdr->SetPropertyCString("MimeType", m_pBufA); res = m_pBRD->OnStreamHeader(m_pSHdr); UT_ASSERT(res == HXR_OK); res = m_pBRD->GetType(1, 0, type); UT_ASSERT(res == HXR_FAIL); cleanup(); // 3g. call with out of range rule // expected result: HXR_FAIL // 3h. call with in range rule // expected result: HXR_OK init(); res = m_pBRD->SetStreamCount(1); UT_ASSERT(res == HXR_OK); m_pSHdr->SetPropertyULONG32("StreamNumber", 0); m_pBufA->Set((const UCHAR*)"audio/foo", 9); m_pSHdr->SetPropertyCString("MimeType", m_pBufA); m_pBufB->Set((const UCHAR*)"a=1,b=2;c=3;", 12); m_pSHdr->SetPropertyCString("ASMRuleBook", m_pBufB); res = m_pBRD->OnStreamHeader(m_pSHdr); UT_ASSERT(res == HXR_OK); res = m_pBRD->GetType(0, 2, type); UT_ASSERT(res == HXR_FAIL); res = m_pBRD->GetType(0, 1, type); UT_ASSERT(res == HXR_OK); cleanup(); }
void UT_Win32Idle::_unregister(UT_Idle * pIdle) { UT_sint32 n = static_vecIdles.findItem(pIdle); UT_ASSERT(n >= 0); static_vecIdles.deleteNthItem(n); }
void FunctionalityTest::runTest() { HX_RESULT res; StreamType type; // 4a. mime type == realevent // expected result: HXR_OK, STRM_INVALID init(); res = m_pBRD->SetStreamCount(1); UT_ASSERT(res == HXR_OK); m_pSHdr->SetPropertyULONG32("StreamNumber", 0); m_pBufA->Set((const UCHAR*)"application/x-pn-realevent", 26); m_pSHdr->SetPropertyCString("MimeType", m_pBufA); res = m_pBRD->OnStreamHeader(m_pSHdr); UT_ASSERT(res == HXR_OK); res = m_pBRD->GetType(0, 0, type); UT_ASSERT(res == HXR_OK && type == STRM_INVALID); cleanup(); // 4b. AvgBitRate and MaxBitRate exist in header and are unequal // expected result: HXR_OK, STRM_TSD init(); res = m_pBRD->SetStreamCount(1); UT_ASSERT(res == HXR_OK); m_pSHdr->SetPropertyULONG32("StreamNumber", 0); m_pSHdr->SetPropertyULONG32("AvgBitRate", 5000); m_pSHdr->SetPropertyULONG32("MaxBitRate", 5000); m_pBufA->Set((const UCHAR*)"audio/x-pn-foo", 26); m_pSHdr->SetPropertyCString("MimeType", m_pBufA); res = m_pBRD->OnStreamHeader(m_pSHdr); UT_ASSERT(res == HXR_OK); res = m_pBRD->GetType(0, 0, type); UT_ASSERT(res == HXR_OK && type == STRM_TSD); cleanup(); // 4c. AvgBitRate and MaxBitRate exist in header and are equal, // and rulebook doesn't exist // expected result: HXR_OK, STRM_TSD init(); res = m_pBRD->SetStreamCount(1); UT_ASSERT(res == HXR_OK); m_pSHdr->SetPropertyULONG32("StreamNumber", 0); m_pSHdr->SetPropertyULONG32("AvgBitRate", 5000); m_pSHdr->SetPropertyULONG32("MaxBitRate", 6000); m_pBufA->Set((const UCHAR*)"audio/x-pn-foo", 26); m_pSHdr->SetPropertyCString("MimeType", m_pBufA); res = m_pBRD->OnStreamHeader(m_pSHdr); UT_ASSERT(res == HXR_OK); res = m_pBRD->GetType(0, 0, type); UT_ASSERT(res == HXR_OK && type == STRM_TSD); cleanup(); // 4d. AvgBitRate and MaxBitRate do not exist in header, and // rulebook doesn't exist // expected result: HXR_OK, STRM_TSD init(); res = m_pBRD->SetStreamCount(1); UT_ASSERT(res == HXR_OK); m_pSHdr->SetPropertyULONG32("StreamNumber", 0); m_pBufA->Set((const UCHAR*)"audio/x-pn-foo", 26); m_pSHdr->SetPropertyCString("MimeType", m_pBufA); res = m_pBRD->OnStreamHeader(m_pSHdr); UT_ASSERT(res == HXR_OK); res = m_pBRD->GetType(0, 1, type); UT_ASSERT(res == HXR_OK && type == STRM_TSD); cleanup(); // 4e. ASMRuleBook exists, and TimeStampDelivery=t is in rule // expected result: HXR_OK, STRM_TSD // 4f. ASMRuleBook exists, and TimeStampDelivery=t is not in rule // expected result: HXR_OK, STRM_CBR init(); res = m_pBRD->SetStreamCount(1); UT_ASSERT(res == HXR_OK); m_pSHdr->SetPropertyULONG32("StreamNumber", 0); m_pBufA->Set((const UCHAR*)"audio/x-pn-foo", 26); m_pSHdr->SetPropertyCString("MimeType", m_pBufA); m_pBufB->Set((const UCHAR*)"a=1,TimeStampDelivery=T;c=3,d=4;", 32); m_pSHdr->SetPropertyCString("ASMRuleBook", m_pBufB); res = m_pBRD->OnStreamHeader(m_pSHdr); UT_ASSERT(res == HXR_OK); res = m_pBRD->GetType(0, 0, type); UT_ASSERT(res == HXR_OK && type == STRM_TSD); res = m_pBRD->GetType(0, 1, type); UT_ASSERT(res == HXR_OK && type == STRM_CBR); cleanup(); }
bool EV_QtToolbar::synthesize(void) { // create a Qt toolbar from the info provided. const EV_Toolbar_ActionSet * pToolbarActionSet = m_pQtApp->getToolbarActionSet(); UT_ASSERT(pToolbarActionSet); XAP_Toolbar_ControlFactory * pFactory = m_pQtApp->getControlFactory(); UT_ASSERT(pFactory); UT_uint32 nrLabelItemsInLayout = m_pToolbarLayout->getLayoutItemCount(); UT_ASSERT(nrLabelItemsInLayout > 0); m_wToolbar = new QToolBar(); UT_ASSERT(m_wToolbar); Qt::ToolButtonStyle style = getStyle(); m_wToolbar->setToolButtonStyle(style); for (UT_uint32 k=0; (k < nrLabelItemsInLayout); k++) { EV_Toolbar_LayoutItem * pLayoutItem = m_pToolbarLayout->getLayoutItem(k); UT_continue_if_fail(pLayoutItem); XAP_Toolbar_Id id = pLayoutItem->getToolbarId(); EV_Toolbar_Action * pAction = pToolbarActionSet->getAction(id); UT_ASSERT(pAction); EV_Toolbar_Label * pLabel = m_pToolbarLabelSet->getLabel(id); UT_ASSERT(pLabel); const char * szToolTip = pLabel->getToolTip(); if (!szToolTip || !*szToolTip) szToolTip = pLabel->getStatusMsg(); switch (pLayoutItem->getToolbarLayoutFlags()) { case EV_TLF_Normal: { switch (pAction->getItemType()) { case EV_TBIT_PushButton: { UT_ASSERT(g_ascii_strcasecmp(pLabel->getIconName(),"NoIcon")!=0); if(pAction->getToolbarId() != AP_TOOLBAR_ID_INSERT_TABLE) { const char *icon_name = pLabel->getIconName(); QPixmap pixmap; pixmap = abi_pixmap_from_toolbar_id (icon_name); if(!pixmap.isNull()) { QIcon icon(pixmap); QString str = ""; QPushButton *item = new QPushButton(icon, str); m_wToolbar->addWidget(item); } } else { const char *icon_name = pLabel->getIconName(); QPixmap pixmap; pixmap = abi_pixmap_from_toolbar_id (icon_name); if(!pixmap.isNull()) { QIcon icon(pixmap); QString str = ""; QPushButton *item = new QPushButton(icon, str); m_wToolbar->addWidget(item); } } break; } case EV_TBIT_ToggleButton: case EV_TBIT_GroupButton: { UT_ASSERT(g_ascii_strcasecmp(pLabel->getIconName(),"NoIcon")!=0); const char *icon_name = pLabel->getIconName(); QPixmap pixmap; pixmap = abi_pixmap_from_toolbar_id (icon_name); if(!pixmap.isNull()) { QIcon icon(pixmap); QString str = ""; QPushButton *item = new QPushButton(icon, str); item->setCheckable(true); m_wToolbar->addWidget(item); } break; } case EV_TBIT_EditText: { break; } case EV_TBIT_DropDown: { break; } case EV_TBIT_ComboBox: { EV_Toolbar_Control * pControl = pFactory->getControl(this, id); UT_ASSERT(pControl); QComboBox *combo; bool isFontCombo = false; if(id == AP_TOOLBAR_ID_FMT_SIZE) { combo = new QComboBox(); } else if(id == AP_TOOLBAR_ID_FMT_FONT) { isFontCombo = true; combo = new QFontComboBox(); QString str = "AbiFontCombo"; combo->setAccessibleName(str); } else if(id == AP_TOOLBAR_ID_ZOOM) { combo = new QComboBox(); QString str = "AbiZoomCombo"; combo->setAccessibleName(str); } else if(id == AP_TOOLBAR_ID_FMT_STYLE) { combo = new QComboBox(); QString str = "AbiStyleCombo"; combo->setAccessibleName(str); } else { UT_ASSERT(0); } // populate it if (pControl) { pControl->populate(); const UT_GenericVector<const char*> * v = pControl->getContents(); UT_ASSERT(v); gint items = v->getItemCount(); if (isFontCombo) { for (gint m=0; m < items; m++) { QString str = v->getNthItem(m); combo->addItem(str); } } else { for (gint m=0; m < items; m++) { const char * sz = v->getNthItem(m); std::string sLoc; if (id == AP_TOOLBAR_ID_FMT_STYLE) { pt_PieceTable::s_getLocalisedStyleName(sz, sLoc); sz = sLoc.c_str(); } QString str = sz; combo->addItem(str); } } } m_wToolbar->addWidget(combo); // for now, we never repopulate, so can just toss it DELETEP(pControl); break; } case EV_TBIT_ColorFore: case EV_TBIT_ColorBack: { UT_ASSERT (g_ascii_strcasecmp(pLabel->getIconName(),"NoIcon") != 0); QComboBox *combo; if (pAction->getItemType() == EV_TBIT_ColorFore) { // TODO Some icon implementation const XAP_StringSet * pSS = XAP_App::getApp()->getStringSet(); std::string sClear; pSS->getValueUTF8(XAP_STRING_ID_TB_ClearForeground,sClear); combo = new QComboBox(); QString str = sClear.c_str(); combo->setAccessibleName(str); } else { // TODO Some icon implementation const XAP_StringSet * pSS = XAP_App::getApp()->getStringSet(); std::string sClear; pSS->getValueUTF8(XAP_STRING_ID_TB_ClearForeground,sClear); combo = new QComboBox(); QString str = sClear.c_str(); combo->setAccessibleName(str); } m_wToolbar->addWidget(combo); break; } case EV_TBIT_StaticLabel: { // TODO do these... break; } case EV_TBIT_Spacer: { break; } #ifdef ENABLE_MENUBUTTON case EV_TBIT_MenuButton: { break; } #endif case EV_TBIT_BOGUS: default: { break; } } break; } case EV_TLF_Spacer: { m_wToolbar->addSeparator(); break; } default: { UT_ASSERT(0); } } } QMainWindow * wTopLevel = static_cast<XAP_QtFrameImpl *>(m_pFrame->getFrameImpl())->getTopLevel(); wTopLevel->addToolBar(m_wToolbar); wTopLevel->show(); return true; }
void OnStreamHeaderTest::runTest() { HX_RESULT res; // 2a. call with NULL argument // expected result: HXR_FAIL init(); res = m_pBRD->SetStreamCount(1); UT_ASSERT(res == HXR_OK); res = m_pBRD->OnStreamHeader(NULL); UT_ASSERT(res == HXR_FAIL); cleanup(); // 2b. call before calling SetStreamCount // expected result: HXR_FAIL init(); res = m_pBRD->OnStreamHeader(m_pSHdr); UT_ASSERT(res == HXR_FAIL); cleanup(); // 2c. call with out of range stream number // expected result: HXR_FAIL init(); res = m_pBRD->SetStreamCount(2); UT_ASSERT(res == HXR_OK); m_pSHdr->SetPropertyULONG32("StreamNumber", 3); res = m_pBRD->OnStreamHeader(m_pSHdr); UT_ASSERT(res == HXR_FAIL); cleanup(); // 2d. call twice with same StreamNumber // expected result: HXR_FAIL init(); res = m_pBRD->SetStreamCount(1); UT_ASSERT(res == HXR_OK); m_pSHdr->SetPropertyULONG32("StreamNumber", 0); res = m_pBRD->OnStreamHeader(m_pSHdr); UT_ASSERT(res == HXR_OK); res = m_pBRD->OnStreamHeader(m_pSHdr); UT_ASSERT(res == HXR_FAIL); cleanup(); // 2e. call with stream 0 and 1 with StreamCount set to 2 // expexted result: HXR_OK init(); res = m_pBRD->SetStreamCount(2); UT_ASSERT(res == HXR_OK); m_pSHdr->SetPropertyULONG32("StreamNumber", 0); res = m_pBRD->OnStreamHeader(m_pSHdr); UT_ASSERT(res == HXR_OK); m_pSHdr->SetPropertyULONG32("StreamNumber", 1); res = m_pBRD->OnStreamHeader(m_pSHdr); UT_ASSERT(res == HXR_OK); cleanup(); }
static void test_recycler(void) { struct mock_pop *mpop = MMAP_ANON_ALIGNED(MOCK_POOL_SIZE, Ut_mmap_align); PMEMobjpool *pop = &mpop->p; memset(pop, 0, MOCK_POOL_SIZE); pop->heap_offset = (uint64_t)((uint64_t)&mpop->heap - (uint64_t)mpop); pop->p_ops.persist = obj_heap_persist; pop->p_ops.memset_persist = obj_heap_memset_persist; pop->p_ops.base = pop; pop->set = MALLOC(sizeof(*(pop->set))); pop->set->options = 0; pop->set->directory_based = 0; void *heap_start = (char *)pop + pop->heap_offset; uint64_t heap_size = MOCK_POOL_SIZE - sizeof(PMEMobjpool); struct palloc_heap *heap = &pop->heap; struct pmem_ops *p_ops = &pop->p_ops; struct stats *s = stats_new(pop); UT_ASSERTne(s, NULL); UT_ASSERT(heap_check(heap_start, heap_size) != 0); UT_ASSERT(heap_init(heap_start, heap_size, &pop->heap_size, p_ops) == 0); UT_ASSERT(heap_boot(heap, heap_start, heap_size, &pop->heap_size, pop, p_ops, s, pop->set) == 0); UT_ASSERT(heap_buckets_init(heap) == 0); UT_ASSERT(pop->heap.rt != NULL); /* trigger heap bucket populate */ struct memory_block m = MEMORY_BLOCK_NONE; m.size_idx = 1; struct bucket *b = heap_bucket_acquire_by_id(heap, DEFAULT_ALLOC_CLASS_ID); UT_ASSERT(heap_get_bestfit_block(heap, b, &m) == 0); heap_bucket_release(heap, b); int ret; struct recycler *r = recycler_new(&pop->heap, 10000 /* never recalc */); UT_ASSERTne(r, NULL); init_run_with_score(pop->heap.layout, 0, 64); init_run_with_score(pop->heap.layout, 1, 128); init_run_with_score(pop->heap.layout, 15, 0); struct memory_block mrun = {0, 0, 1, 0}; struct memory_block mrun2 = {1, 0, 1, 0}; memblock_rebuild_state(&pop->heap, &mrun); memblock_rebuild_state(&pop->heap, &mrun2); ret = recycler_put(r, &mrun, recycler_calc_score(&pop->heap, &mrun, NULL)); UT_ASSERTeq(ret, 0); ret = recycler_put(r, &mrun2, recycler_calc_score(&pop->heap, &mrun2, NULL)); UT_ASSERTeq(ret, 0); struct memory_block mrun_ret = MEMORY_BLOCK_NONE; mrun_ret.size_idx = 1; struct memory_block mrun2_ret = MEMORY_BLOCK_NONE; mrun2_ret.size_idx = 1; ret = recycler_get(r, &mrun_ret); UT_ASSERTeq(ret, 0); ret = recycler_get(r, &mrun2_ret); UT_ASSERTeq(ret, 0); UT_ASSERTeq(mrun2.chunk_id, mrun2_ret.chunk_id); UT_ASSERTeq(mrun.chunk_id, mrun_ret.chunk_id); init_run_with_score(pop->heap.layout, 7, 256); init_run_with_score(pop->heap.layout, 2, 64); init_run_with_score(pop->heap.layout, 5, 512); init_run_with_score(pop->heap.layout, 10, 128); mrun.chunk_id = 7; mrun2.chunk_id = 2; struct memory_block mrun3 = {5, 0, 1, 0}; struct memory_block mrun4 = {10, 0, 1, 0}; memblock_rebuild_state(&pop->heap, &mrun3); memblock_rebuild_state(&pop->heap, &mrun4); mrun_ret.size_idx = 1; mrun2_ret.size_idx = 1; struct memory_block mrun3_ret = MEMORY_BLOCK_NONE; mrun3_ret.size_idx = 1; struct memory_block mrun4_ret = MEMORY_BLOCK_NONE; mrun4_ret.size_idx = 1; ret = recycler_put(r, &mrun, recycler_calc_score(&pop->heap, &mrun, NULL)); UT_ASSERTeq(ret, 0); ret = recycler_put(r, &mrun2, recycler_calc_score(&pop->heap, &mrun2, NULL)); UT_ASSERTeq(ret, 0); ret = recycler_put(r, &mrun3, recycler_calc_score(&pop->heap, &mrun3, NULL)); UT_ASSERTeq(ret, 0); ret = recycler_put(r, &mrun4, recycler_calc_score(&pop->heap, &mrun4, NULL)); UT_ASSERTeq(ret, 0); ret = recycler_get(r, &mrun2_ret); UT_ASSERTeq(ret, 0); ret = recycler_get(r, &mrun4_ret); UT_ASSERTeq(ret, 0); ret = recycler_get(r, &mrun_ret); UT_ASSERTeq(ret, 0); ret = recycler_get(r, &mrun3_ret); UT_ASSERTeq(ret, 0); UT_ASSERTeq(mrun.chunk_id, mrun_ret.chunk_id); UT_ASSERTeq(mrun2.chunk_id, mrun2_ret.chunk_id); UT_ASSERTeq(mrun3.chunk_id, mrun3_ret.chunk_id); UT_ASSERTeq(mrun4.chunk_id, mrun4_ret.chunk_id); init_run_with_max_block(pop->heap.layout, 1); struct memory_block mrun5 = {1, 0, 1, 0}; memblock_rebuild_state(&pop->heap, &mrun5); ret = recycler_put(r, &mrun5, recycler_calc_score(&pop->heap, &mrun5, NULL)); UT_ASSERTeq(ret, 0); struct memory_block mrun5_ret = MEMORY_BLOCK_NONE; mrun5_ret.size_idx = 11; ret = recycler_get(r, &mrun5_ret); UT_ASSERTeq(ret, ENOMEM); mrun5_ret = MEMORY_BLOCK_NONE; mrun5_ret.size_idx = 10; ret = recycler_get(r, &mrun5_ret); UT_ASSERTeq(ret, 0); recycler_delete(r); stats_delete(pop, s); heap_cleanup(heap); UT_ASSERT(heap->rt == NULL); FREE(pop->set); MUNMAP_ANON_ALIGNED(mpop, MOCK_POOL_SIZE); }
int main(int argc, char *argv[]) { START(argc, argv, "checksum"); if (argc < 2) UT_FATAL("usage: %s files...", argv[0]); for (int arg = 1; arg < argc; arg++) { int fd = OPEN(argv[arg], O_RDONLY); os_stat_t stbuf; FSTAT(fd, &stbuf); size_t size = (size_t)stbuf.st_size; void *addr = MMAP(NULL, size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0); uint64_t *ptr = addr; /* * Loop through, selecting successive locations * where the checksum lives in this block, and * let util_checksum() insert it so it can be * verified against the gold standard fletcher64 * routine in this file. */ while ((char *)(ptr + 1) < (char *)addr + size) { /* save whatever was at *ptr */ uint64_t oldval = *ptr; /* mess with it */ *ptr = htole64(0x123); /* * calculate a checksum and have it installed */ util_checksum(addr, size, ptr, 1, 0); uint64_t csum = *ptr; /* * verify inserted checksum checks out */ UT_ASSERT(util_checksum(addr, size, ptr, 0, 0)); /* put a zero where the checksum was installed */ *ptr = 0; /* calculate a checksum */ uint64_t gold_csum = fletcher64(addr, size); /* put the old value back */ *ptr = oldval; /* * verify checksum now fails */ UT_ASSERT(!util_checksum(addr, size, ptr, 0, 0)); /* * verify the checksum matched the gold version */ UT_ASSERTeq(csum, gold_csum); UT_OUT("%s:%" PRIu64 " 0x%" PRIx64, argv[arg], (char *)ptr - (char *)addr, csum); ptr++; } uint64_t *addr2 = MMAP(NULL, size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0); uint64_t *csum = (uint64_t *)addr; /* * put a zero where the checksum will be installed * in the second map */ *addr2 = 0; for (size_t i = size / 8 - 1; i > 0; i -= 1) { /* calculate a checksum and have it installed */ util_checksum(addr, size, csum, 1, i * 8); /* * put a zero in the second map where an ignored part is */ *(addr2 + i) = 0; /* calculate a checksum */ uint64_t gold_csum = fletcher64(addr2, size); /* * verify the checksum matched the gold version */ UT_ASSERTeq(*csum, gold_csum); } CLOSE(fd); MUNMAP(addr, size); MUNMAP(addr2, size); } DONE(NULL); }
/*! * This method adjusts the m_iYBreak and m_iYBottom variables after a * setY method changes the start position of the top of the table. */ void fp_TOCContainer::adjustBrokenTOCs(void) { if(isThisBroken()) { // UT_ASSERT(UT_SHOULD_NOT_HAPPEN); return; } if(getFirstBrokenTOC() == NULL) { return; } if(getFirstBrokenTOC() == getLastBrokenTOC()) { return; } // // FIXME. Both this code and the code in fp_TableContainer, somehow leads to bugs. I've clearly found // workarounds to what this is trying to achive. In pricinple this code should make laying out TOC's // faster. In parctice I suspect it leads to bugs in fb_ColumnBreaker. I'll leave these returns in place // for now, pending removal of the methods. // return; fp_TOCContainer * pBroke = getFirstBrokenTOC(); fp_VerticalContainer * pVC = static_cast<fp_VerticalContainer *>(getContainer()); UT_sint32 iNewHeight = pVC->getMaxHeight() - getY(); UT_sint32 ishift = iNewHeight - pBroke->getYBottom(); UT_sint32 iNewBot = pBroke->getYBottom() + ishift; UT_sint32 iTOCHeight = fp_VerticalContainer::getHeight(); UT_DEBUGMSG(("SEVIOR: ishift = %d iNewHeight %d pBroke->getYBottom() %d \n",ishift,iNewHeight,pBroke->getYBottom())); if(ishift == 0) { return; } if(iNewBot > iTOCHeight) { iNewBot = iTOCHeight; } pBroke->setYBottom(iNewBot); UT_ASSERT(pBroke->getHeight()); pBroke = static_cast<fp_TOCContainer *>(pBroke->getNext()); while(pBroke) { UT_sint32 iNewTop = pBroke->getYBreak(); iNewBot = pBroke->getYBottom(); pBroke->setYBreakHere(iNewTop + ishift); if(pBroke->getNext()) { pBroke->setYBottom(iNewBot+ishift); UT_ASSERT(pBroke->getHeight()); } else { pBroke->setYBottom(iTOCHeight); UT_ASSERT(pBroke->getHeight()); } xxx_UT_DEBUGMSG(("SEVIOR: Broken TOC %x YBreak adjusted to %d Shift is %d height is %d \n",pBroke,iNewTop+ishift,ishift,pBroke->getHeight())); fp_TOCContainer * pPrev = static_cast<fp_TOCContainer *>(pBroke->getPrev()); // // If the height of the previous plus the height of pBroke offset from // the previous position is less that the column height we can delete // this broken TOC. // UT_sint32 iMaxHeight = 0; bool bDeleteOK = false; if(pPrev) { iMaxHeight = static_cast<fp_VerticalContainer *>(pPrev->getContainer())->getMaxHeight(); xxx_UT_DEBUGMSG(("SEVIOR: sum %d maxheight %d \n",(pPrev->getY() + pPrev->getHeight() + pBroke->getHeight()), iMaxHeight)); } if(bDeleteOK && pPrev && (pPrev->getY() + pPrev->getHeight() + pBroke->getHeight() < iMaxHeight)) { // // FIXME: This if should be unnested.... // if(pPrev == this) { pPrev = getFirstBrokenTOC(); } xxx_UT_DEBUGMSG(("SEVIOR; In adjust - Deleting TOC. Max height %d prev Y %d prev Height %d cur Height %d \n",iMaxHeight, pPrev->getY(),pPrev->getHeight(),pBroke->getHeight())); // // Don't need this TOC any more. Delete it and all following TOCs. // after adjusting the previous TOC. // pPrev->setYBottom(iTOCHeight); UT_ASSERT(pPrev->getHeight()); pPrev->setNext( NULL); if(pPrev == getFirstBrokenTOC()) { setNext(NULL); getFirstBrokenTOC()->setYBreakHere(0); UT_ASSERT(getFirstBrokenTOC()->getHeight()); } setLastBrokenTOC(pPrev); xxx_UT_DEBUGMSG(("SEVIOR!!!!!!!!!!! 2 last broken TOC %x deleting %x Master TOC %x \n",getLastBrokenTOC(),pBroke,this)); xxx_UT_DEBUGMSG(("SEVIOR!!!!!!!!!!! 2 get first %x get last broken TOC %x \n",getFirstBrokenTOC(),getLastBrokenTOC())); fp_TOCContainer * pT = getFirstBrokenTOC(); UT_sint32 j = 0; while(pT) { xxx_UT_DEBUGMSG(("SEVIOR: TOC %d is %x \n",j,pT)); j++; pT = static_cast<fp_TOCContainer *>(pT->getNext()); } while(pBroke) { fp_TOCContainer * pNext = static_cast<fp_TOCContainer *>(pBroke->getNext()); UT_sint32 i = pBroke->getContainer()->findCon(pBroke); if(i >=0) { pBroke->getContainer()->deleteNthCon(i); } else { UT_ASSERT(UT_SHOULD_NOT_HAPPEN); } xxx_UT_DEBUGMSG(("SEVIOR: Adjust - Delete TOC %x \n",pBroke)); delete pBroke; pBroke = pNext; } } else { pBroke = static_cast<fp_TOCContainer *>(pBroke->getNext()); } } }
/*! retrieve the 6-byte address of the network card; returns true on success This implementation is from libuuid; it has not been debugged or even compiled */ bool UT_getEthernetAddress(UT_EthernetAddress &a) { UT_UNUSED(a); #if 0 // TODO -- someone should debug this and turn it on #ifdef HAVE_NET_IF_H int sd; struct ifreq ifr, *ifrp; struct ifconf ifc; char buf[1024]; int n, i; unsigned char *a; /* * BSD 4.4 defines the size of an ifreq to be * max(sizeof(ifreq), sizeof(ifreq.ifr_name)+ifreq.ifr_addr.sa_len * However, under earlier systems, sa_len isn't present, so the size is * just sizeof(struct ifreq) */ #ifdef HAVE_SA_LEN #define ifreq_size(i) max(sizeof(struct ifreq),\ sizeof((i).ifr_name)+(i).ifr_addr.sa_len) #else #define ifreq_size(i) sizeof(struct ifreq) #endif /* HAVE_SA_LEN*/ sd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP); if (sd < 0) { return false; } memset(buf, 0, sizeof(buf)); ifc.ifc_len = sizeof(buf); ifc.ifc_buf = buf; if (ioctl (sd, SIOCGIFCONF, (char *)&ifc) < 0) { close(sd); return false; } n = ifc.ifc_len; for (i = 0; i < n; i+= ifreq_size(*ifr) ) { ifrp = (struct ifreq *)((char *) ifc.ifc_buf+i); strncpy(ifr.ifr_name, ifrp->ifr_name, IFNAMSIZ); #ifdef SIOCGIFHWADDR if (ioctl(sd, SIOCGIFHWADDR, &ifr) < 0) continue; a = (unsigned char *) &ifr.ifr_hwaddr.sa_data; #else #ifdef SIOCGENADDR if (ioctl(sd, SIOCGENADDR, &ifr) < 0) continue; a = (unsigned char *) ifr.ifr_enaddr; #else /* * XXX we don't have a way of getting the hardware * address */ close(sd); return false; #endif /* SIOCGENADDR */ #endif /* SIOCGIFHWADDR */ if (!a[0] && !a[1] && !a[2] && !a[3] && !a[4] && !a[5]) continue; if (node_id) { memcpy(node_id, a, 6); close(sd); return true; } } close(sd); #endif #else // someone needs to debug/fix, ect., the code above UT_ASSERT(UT_NOT_IMPLEMENTED); #endif return false; }
UT_Error UT_XML::parse (const char * szFilename) { UT_ASSERT (m_pListener || m_pExpertListener); UT_ASSERT (szFilename); if ((szFilename == 0) || ((m_pListener == 0) && (m_pExpertListener == 0))) return UT_ERROR; if (!reset_all ()) return UT_OUTOFMEM; UT_Error ret = UT_OK; DefaultReader defaultReader; Reader * reader = &defaultReader; if (m_pReader) reader = m_pReader; if (!reader->openFile (szFilename)) { UT_DEBUGMSG (("Could not open file %s\n", szFilename)); return UT_errnoToUTError (); } char buffer[2048]; m_bStopped = false; xmlSAXHandler hdl; xmlParserCtxtPtr ctxt = 0; memset(&hdl, 0, sizeof(hdl)); hdl.getEntity = _getEntity; hdl.startElement = _startElement; hdl.endElement = _endElement; hdl.characters = _charData; hdl.error = _errorSAXFunc; hdl.fatalError = _fatalErrorSAXFunc; hdl.processingInstruction = _processingInstruction; hdl.comment = _comment; hdl.cdataBlock = _cdata; size_t length = reader->readBytes (buffer, sizeof (buffer)); int done = (length < sizeof (buffer)); if (length != 0) { ctxt = xmlCreatePushParserCtxt (&hdl, static_cast<void *>(this), buffer, static_cast<int>(length), szFilename); if (ctxt == NULL) { UT_DEBUGMSG (("Unable to create libxml2 push-parser context!\n")); reader->closeFile (); return UT_ERROR; } xmlSubstituteEntitiesDefault (1); UT_sint32 chucks = -1; while (!done && !m_bStopped) { chucks++; length = reader->readBytes (buffer, sizeof (buffer)); UT_DEBUGMSG(("Done chunk %d length %zd \n",chucks,length)); done = (length < sizeof (buffer)); if (xmlParseChunk (ctxt, buffer, static_cast<int>(length), 0)) { if(getNumMinorErrors() > getNumRecoveredErrors()) { UT_DEBUGMSG (("Error - 1 parsing '%s' (Line: %d, Column: %d)\n", szFilename, xmlSAX2GetLineNumber(ctxt), xmlSAX2GetColumnNumber(ctxt))); ret = UT_IE_IMPORTERROR; break; } } } if (ret == UT_OK) if (!m_bStopped && (getNumMinorErrors() == 0)) { if (xmlParseChunk (ctxt, "", 0, 1)) { UT_DEBUGMSG (("Error -2 parsing '%s' (Line: %d, Column: %d)\n", szFilename, xmlSAX2GetLineNumber(ctxt), xmlSAX2GetColumnNumber(ctxt))); ret = UT_IE_IMPORTERROR; } } if (ret == UT_OK && (getNumMinorErrors() == 0)) if (!ctxt->wellFormed && !m_bStopped) ret = UT_IE_IMPORTERROR; // How does stopping mid-file affect wellFormed? xmlDocPtr myXmlDoc = ctxt->myDoc; xmlFreeParserCtxt (ctxt); xmlFreeDoc(myXmlDoc); } else { UT_DEBUGMSG(("Empty file to parse - not sure how to proceed\n")); } reader->closeFile (); return ret; }
UT_Error IE_Exp_EPUB::package() { GsfOutput* opf = gsf_outfile_new_child(GSF_OUTFILE(m_oebps), "book.opf", FALSE); if (opf == NULL) { UT_DEBUGMSG(("Can`t create book.opf\n")); return UT_ERROR; } GsfXMLOut* opfXml = gsf_xml_out_new(opf); // <package> gsf_xml_out_start_element(opfXml, "package"); if (m_exp_opt.bEpub2) { gsf_xml_out_add_cstr(opfXml, "version", "2.0"); } else { gsf_xml_out_add_cstr(opfXml, "version", "3.0"); } gsf_xml_out_add_cstr(opfXml, "xmlns", OPF201_NAMESPACE); gsf_xml_out_add_cstr(opfXml, "unique-identifier", "BookId"); if (!m_exp_opt.bEpub2) { gsf_xml_out_add_cstr(opfXml, "profile", EPUB3_PACKAGE_PROFILE); gsf_xml_out_add_cstr(opfXml, "xml:lang", getLanguage().c_str()); } // <metadata> gsf_xml_out_start_element(opfXml, "metadata"); gsf_xml_out_add_cstr(opfXml, "xmlns:dc", DC_NAMESPACE); gsf_xml_out_add_cstr(opfXml, "xmlns:opf", OPF201_NAMESPACE); // Generation of required Dublin Core metadata gsf_xml_out_start_element(opfXml, "dc:title"); gsf_xml_out_add_cstr(opfXml, NULL, getTitle().c_str()); gsf_xml_out_end_element(opfXml); gsf_xml_out_start_element(opfXml, "dc:identifier"); gsf_xml_out_add_cstr(opfXml, "id", "BookId"); gsf_xml_out_add_cstr(opfXml, NULL, getDoc()->getDocUUIDString()); gsf_xml_out_end_element(opfXml); gsf_xml_out_start_element(opfXml, "dc:language"); gsf_xml_out_add_cstr(opfXml, NULL, getLanguage().c_str()); gsf_xml_out_end_element(opfXml); gsf_xml_out_start_element(opfXml, "dc:creator"); gsf_xml_out_add_cstr(opfXml, "opf:role", "aut"); gsf_xml_out_add_cstr(opfXml, NULL, getAuthor().c_str()); gsf_xml_out_end_element(opfXml); // </metadata> gsf_xml_out_end_element(opfXml); // <manifest> gsf_xml_out_start_element(opfXml, "manifest"); gchar *basedir = g_filename_from_uri(m_oebpsDir.c_str(),NULL,NULL); UT_ASSERT(basedir); std::string _baseDir = basedir; std::vector<std::string> listing = getFileList(_baseDir); FREEP(basedir); for (std::vector<std::string>::iterator i = listing.begin(); i != listing.end(); i++) { std::string idStr = escapeForId(*i); std::string fullItemPath = m_oebpsDir + G_DIR_SEPARATOR_S + *i; gsf_xml_out_start_element(opfXml, "item"); if (m_pHmtlExporter->hasMathML((*i))) { gsf_xml_out_add_cstr(opfXml, "mathml", "true"); } gsf_xml_out_add_cstr(opfXml, "id", idStr.c_str()); gsf_xml_out_add_cstr(opfXml, "href", (*i).c_str()); gsf_xml_out_add_cstr(opfXml, "media-type", getMimeType(fullItemPath).c_str()); gsf_xml_out_end_element(opfXml); } // We`ll add navigation files manually gsf_xml_out_start_element(opfXml, "item"); gsf_xml_out_add_cstr(opfXml, "id", "ncx"); gsf_xml_out_add_cstr(opfXml, "href", "toc.ncx"); gsf_xml_out_add_cstr(opfXml, "media-type", "application/x-dtbncx+xml"); gsf_xml_out_end_element(opfXml); if (!m_exp_opt.bEpub2) { gsf_xml_out_start_element(opfXml, "item"); gsf_xml_out_add_cstr(opfXml, "id", "toc"); gsf_xml_out_add_cstr(opfXml, "href", "toc.xhtml"); gsf_xml_out_add_cstr(opfXml, "media-type", "application/xhtml+xml"); gsf_xml_out_end_element(opfXml); } // </manifest> gsf_xml_out_end_element(opfXml); // <spine> gsf_xml_out_start_element(opfXml, "spine"); gsf_xml_out_add_cstr(opfXml, "toc", "ncx"); if (!m_exp_opt.bEpub2) { gsf_xml_out_start_element(opfXml, "itemref"); gsf_xml_out_add_cstr(opfXml, "idref","toc"); gsf_xml_out_end_element(opfXml); } for(std::vector<std::string>::iterator i = m_opsId.begin(); i != m_opsId.end(); i++) { gsf_xml_out_start_element(opfXml, "itemref"); gsf_xml_out_add_cstr(opfXml, "idref", (*i).c_str()); gsf_xml_out_end_element(opfXml); } // </spine> gsf_xml_out_end_element(opfXml); // </package> gsf_xml_out_end_element(opfXml); gsf_output_close(opf); return compress(); }
void AP_UnixDialog_Stylist::notifyActiveFrame(XAP_Frame * /*pFrame*/) { UT_ASSERT(m_windowMain); }
void ev_BeOSMouse::mouseMotion(BMessage *msg) { AV_View* pView = m_pBeOSFrame->getFrame()->getCurrentView(); EV_EditMethod * pEM; EV_EditModifierState ems = 0; EV_EditEventMapperResult result; EV_EditMouseButton emb = 0; EV_EditMouseOp mop; EV_EditMouseContext emc = 0; BPoint pt; int32 clicks, mod, buttons; msg->FindInt32("clicks", &clicks); msg->FindInt32("buttons", &buttons); msg->FindInt32("modifiers", &mod); msg->FindPoint("be:view_where", &pt); // UT_DEBUGMSG(("mouseMotion: [x=%f y=%f]\n",pt.x, pt.y)); if (buttons & B_PRIMARY_MOUSE_BUTTON) emb = EV_EMB_BUTTON1; else if (buttons & B_PRIMARY_MOUSE_BUTTON) emb = EV_EMB_BUTTON2; else if (buttons & B_PRIMARY_MOUSE_BUTTON) emb = EV_EMB_BUTTON3; else { //Bail because I don't think the code expect non button events return; } if (mod & B_SHIFT_KEY) ems |= EV_EMS_SHIFT; if (mod & B_CONTROL_KEY) ems |= EV_EMS_CONTROL; if (mod & B_OPTION_KEY) ems |= EV_EMS_ALT; // report movements under the mouse button that we did the capture on if (m_clickState == 0) { mop = EV_EMO_DRAG; emc = pView->getMouseContext((UT_sint32)pt.x,(UT_sint32)pt.y); } else if (m_clickState == EV_EMO_SINGLECLICK) { mop = EV_EMO_DRAG; emc = m_contextState; } else if (m_clickState == EV_EMO_DOUBLECLICK) { mop = EV_EMO_DOUBLEDRAG; emc = m_contextState; } else { UT_ASSERT(UT_SHOULD_NOT_HAPPEN); return; } // UT_DEBUGMSG(("onButtonMove: %p [b=%d m=%d]\n",EV_EMO_DRAG|ems, emb, ems)); result = m_pEEM->Mouse(emc|mop|emb|ems, &pEM); switch (result) { case EV_EEMR_COMPLETE: UT_ASSERT(pEM); invokeMouseMethod(pView,pEM,(UT_sint32)pt.x,(UT_sint32)pt.y); return; case EV_EEMR_INCOMPLETE: // I'm not sure this makes any sense, but we allow it. return; case EV_EEMR_BOGUS_START: case EV_EEMR_BOGUS_CONT: // TODO What to do ?? Should we beep at them or just be quiet ?? return; default: UT_ASSERT(UT_SHOULD_NOT_HAPPEN); return; } }