void Window_Selectable::SetRowByContentSize(int _column){
int num = GetContentSize();
column = _column;
if(num == 0){
row = 1;
}else{
row = (num + column - 1) / column;
}
SetGridSize(column, row);
}
int scContUnit::operator==( const scContUnit& p2 ) const
{
if ( GetContentSize() != p2.GetContentSize() )
return 0;
if ( fSpecRun != p2.fSpecRun )
return 0;
return fCharArray == p2.fCharArray;
}
int IPCStream::GetEmptySize( unsigned int& datasize )
{
unsigned int nLen;
GetUnreleaseSize( nLen );
GetContentSize( datasize );
datasize = m_nBufLen - datasize;
datasize -= nLen;
//keep space
datasize -= 1;
return SUCCESS_VALUE;
}
BRect
CTool::Frame() const
{
D_ACCESS(("CTool::Frame()\n"));
BRect rect;
float width, height;
GetContentSize(&width, &height);
rect.OffsetTo(ContentLocation());
rect.right = rect.left + width;
rect.bottom = rect.top + height;
return rect;
}
void scContUnit::PasteText( const scContUnit* srcPara,
long& offset )
{
try {
if ( offset == 0 ) {
TypeSpec ts = srcPara->GetDefaultSpec();
if ( ts.ptr() )
SetDefaultSpec( ts );
}
// paste the specs in
fSpecRun.InsertRun( offset, srcPara->GetContentSize(), srcPara->GetSpecRun() );
// paste the text in
fCharArray.Paste( ((scContUnit*)srcPara)->GetCharArray(), offset );
Mark( scREBREAK );
#ifdef _RUBI_SUPPORT
// paste the rubis in
if ( fRubiArray || srcPara->GetRubiArray() ) {
if ( fRubiArray && !srcPara->GetRubiArray() )
fRubiArray->BumpRubiData( offset, srcPara->GetContentSize() );
else if ( !fRubiArray && srcPara->GetRubiArray() ) {
AllocRubiArray( *srcPara->GetRubiArray() );
fRubiArray->BumpRubiData( 0, offset );
}
else
fRubiArray->Paste( *srcPara->GetRubiArray(), offset, srcPara->GetContentSize() );
}
#endif
scTextline* txl = FindLine( offset );
if ( txl )
txl->Mark( scREPAINT ); /* force repaint */
long startOffset = offset;
offset += srcPara->GetContentSize();
fSpecRun.SetContentSize( GetContentSize() );
fCharArray.RepairText( fSpecRun, startOffset, offset );
}
catch( ... ) {
SCDebugBreak(); // remove stuff from the paragraph
throw;
}
}
void scContUnit::OffsetGetTSList( long startOffset,
long endOffset,
scTypeSpecList& tsList )
{
if ( endOffset == startOffset )
return;
if ( endOffset == LONG_MAX )
endOffset = GetContentSize();
if ( startOffset == LONG_MIN )
startOffset = 0;
int i = fSpecRun.indexAtOffset( startOffset );
do {
TypeSpec ts = fSpecRun[i].spec();
tsList.Insert( ts );
} while ( fSpecRun[++i].offset() < endOffset );
}
void SimpleGLWindow::Redraw(bool andSwap) {
DrawChecker();
if (tw_ == 0 && th_ == 0) {
if (andSwap) {
Swap();
}
return;
}
if (flags_ & ALPHA_BLEND) {
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBlendEquation(GL_FUNC_ADD);
} else {
glDisable(GL_BLEND);
}
glViewport(0, 0, w_, h_);
glScissor(0, 0, w_, h_);
glBindTexture(GL_TEXTURE_2D, tex_);
glsl_bind(drawProgram_);
float fw, fh;
float x, y;
GetContentSize(x, y, fw, fh);
const float pos[12] = {x,y,0, x+fw,y,0, x+fw,y+fh,0, x,y+fh,0};
static const float texCoords[8] = {0,0, 1,0, 1,1, 0,1};
static const float texCoordsFlipped[8] = {0,1, 1,1, 1,0, 0,0};
static const GLubyte indices[4] = {0,1,3,2};
Matrix4x4 ortho;
ortho.setOrtho(0, (float)w_, (float)h_, 0, -1, 1);
glUniformMatrix4fv(drawProgram_->u_viewproj, 1, GL_FALSE, ortho.getReadPtr());
glVertexAttribPointer(drawProgram_->a_position, 3, GL_FLOAT, GL_FALSE, 12, pos);
glVertexAttribPointer(drawProgram_->a_texcoord0, 2, GL_FLOAT, GL_FALSE, 8, tflipped_ ? texCoordsFlipped : texCoords);
glActiveTexture(GL_TEXTURE0);
glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_BYTE, indices);
if (andSwap) {
Swap();
}
}
/* ===================================================================== */
int scCharArray::FindString( const USTR& ustr,
const SearchState& flags,
int32 start,
int32 end,
int32& offset )
{
scHandleArrayLock h( this );
CharRecordP chRec = (CharRecordP)*h;
start = MAX( start, 0 );
end = MIN( end, GetContentSize() );
if ( !flags.reverse() )
return ForwardSearchWord( chRec, start, end, offset,
flags.caseSensitive(), ustr );
else
return ReverseSearchWord( chRec, start, end, offset,
flags.caseSensitive(), ustr );
}
const void* IPCStream::RcvBuf( unsigned int datasize, bool bMovePtr )
{
unsigned int nLen;
GetContentSize( nLen );
if( datasize > nLen ||
nLen == 0 )
return NULL;
MoveReleasePtr( );
char* szInternalBuf = ((char*)this) + m_nOffset;
if( Iswrapped( ) )
{
GetLPtoRightMargin( nLen );
if( datasize <= nLen )
{
if( bMovePtr )
m_leftpos += datasize;
return szInternalBuf+m_releasepos;
}
else
{
memcpy( szInternalBuf + m_tmppos, szInternalBuf + m_leftpos, nLen );
memcpy( szInternalBuf + m_tmppos + nLen, szInternalBuf, ( datasize - nLen ) );
if( bMovePtr )
m_leftpos = datasize - nLen;
return szInternalBuf + m_tmppos;
}
}
else
{
if( bMovePtr )
m_leftpos += datasize;
return szInternalBuf + m_releasepos;
}
return NULL;
}
/* static */ already_AddRefed<Image>
ImageFactory::CreateRasterImage(nsIRequest* aRequest,
imgStatusTracker* aStatusTracker,
const nsCString& aMimeType,
nsIURI* aURI,
uint32_t aImageFlags,
uint32_t aInnerWindowId)
{
nsresult rv;
nsRefPtr<RasterImage> newImage = new RasterImage(aStatusTracker, aURI);
rv = newImage->Init(aMimeType.get(), aImageFlags);
NS_ENSURE_SUCCESS(rv, BadImage(newImage));
newImage->SetInnerWindowID(aInnerWindowId);
uint32_t len = GetContentSize(aRequest);
// Pass anything usable on so that the RasterImage can preallocate
// its source buffer.
if (len > 0) {
uint32_t sizeHint = std::min<uint32_t>(len, 20000000); // Bound by something reasonable
rv = newImage->SetSourceSizeHint(sizeHint);
if (NS_FAILED(rv)) {
// Flush memory, try to get some back, and try again.
rv = nsMemory::HeapMinimize(true);
nsresult rv2 = newImage->SetSourceSizeHint(sizeHint);
// If we've still failed at this point, things are going downhill.
if (NS_FAILED(rv) || NS_FAILED(rv2)) {
NS_WARNING("About to hit OOM in imagelib!");
}
}
}
mozilla::net::nsMediaFragmentURIParser parser(aURI);
if (parser.HasResolution()) {
newImage->SetRequestedResolution(parser.GetResolution());
}
return newImage.forget();
}
base::AppBuffer CfgFile::GetContent()
{
if (IsCrash())
{
base::AppBuffer buf(0);
return buf;
}
boost::uint32_t content_len = GetContentSize() - cfg_head_len_;
boost::uint32_t readbuflen = 0;
boost::uint32_t readnum = SecRead((boost::uint8_t*) (&readbuflen), sizeof(readbuflen));
assert(readnum == sizeof(readbuflen));
assert(readbuflen == content_len-sizeof(readbuflen));
base::AppBuffer content_buf(readbuflen);
readnum = SecRead((boost::uint8_t*) (content_buf.Data()), content_buf.Length());
assert(readnum == content_buf.Length());
return content_buf;
}
void
TWindowMenuItem::DrawContent()
{
BMenu* menu = Menu();
BPoint contentLocation = ContentLocation() + BPoint(kHPad, 0);
if (fID >= 0) {
menu->SetDrawingMode(B_OP_OVER);
float width = fBitmap->Bounds().Width();
if (width > 16)
contentLocation.x -= 8;
float height;
GetContentSize(NULL, &height);
contentLocation.y += (height - fBitmap->Bounds().Height()) / 2;
menu->MovePenTo(contentLocation);
menu->DrawBitmapAsync(fBitmap);
if (width > 16)
contentLocation.x += 8;
contentLocation.x += kIconRect.Width() + kLabelOffset;
}
contentLocation.y = ContentLocation().y + kVPad + fLabelAscent;
menu->SetDrawingMode(B_OP_COPY);
menu->MovePenTo(contentLocation);
if (IsSelected())
menu->SetHighColor(ui_color(B_MENU_SELECTED_ITEM_TEXT_COLOR));
else
menu->SetHighColor(ui_color(B_MENU_ITEM_TEXT_COLOR));
float labelWidth = menu->StringWidth(Label());
BPoint penLocation = menu->PenLocation();
float offset = penLocation.x - Frame().left;
menu->DrawString(Label(labelWidth + offset));
}
virtual void ApplySchemeSettings(IScheme *pScheme)
{
// set up the scheme settings
Button::ApplySchemeSettings(pScheme);
_textColor = GetSchemeColor("PropertySheet.SelectedTextColor", GetFgColor(), pScheme);
_dimTextColor = GetSchemeColor("PropertySheet.TextColor", GetFgColor(), pScheme);
m_pActiveBorder = pScheme->GetBorder("TabActiveBorder");
m_pNormalBorder = pScheme->GetBorder("TabBorder");
if ( m_pImage )
{
ClearImages();
m_pImage->SetImage(scheme()->GetImage(m_pszImageName, false));
AddImage( m_pImage->GetImage(), 2 );
int w, h;
m_pImage->GetSize( w, h );
w += m_pContextLabel ? 10 : 0;
if ( m_pContextLabel )
{
m_pImage->SetPos( 10, 0 );
}
SetSize( w + 4, h + 2 );
}
else
{
int wide, tall;
int contentWide, contentTall;
GetSize(wide, tall);
GetContentSize(contentWide, contentTall);
wide = max(m_bMaxTabWidth, contentWide + 10); // 10 = 5 pixels margin on each side
wide += m_pContextLabel ? 10 : 0;
SetSize(wide, tall);
}
if ( m_pContextLabel )
{
SetTextInset( 12, 0 );
}
}
float ComboBox::CalculateDropDownListHeight(std::size_t visible_item_count) {
float height = 0;
auto item_source = drop_down_list_box_->GetItemSource();
if (item_source->HasVariableItemHeight()) {
for (std::size_t index = 0; index < visible_item_count; ++index) {
height += item_source->GetItemHeight(index);
}
}
else {
height = item_source->GetItemHeight(0) * visible_item_count;
}
if (height == 0) {
height = GetContentSize().height;
}
return height;
}
void
BitmapMenuItem::DrawContent(void)
{
if (!Label() && !fBitmap)
return;
float width, height;
GetContentSize(&width, &height);
BRect drawrect(Frame());
drawrect.bottom--;
drawrect.top++;
drawrect.left = ContentLocation().x;
if (fBitmap) {
// Scale the fBitmap down to completely fit within the field's height
if (fBitmap->Bounds().Height() > drawrect.Height()) {
drawrect.right = drawrect.left +
(fBitmap->Bounds().Width() *
(Frame().Height() / fBitmap->Bounds().Height()));
} else {
drawrect.right = drawrect.left + fBitmap->Bounds().Width();
}
} else {
drawrect.right = drawrect.left - 5;
}
BPoint stringpoint(ContentLocation());
stringpoint.x = drawrect.right + 10;
Menu()->MovePenTo(stringpoint);
BMenuItem::DrawContent();
if (fBitmap) {
Menu()->PushState();
Menu()->SetDrawingMode(B_OP_ALPHA);
Menu()->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_OVERLAY);
Menu()->DrawBitmap(fBitmap, fBitmap->Bounds(), drawrect, B_FILTER_BITMAP_BILINEAR);
Menu()->PopState();
}
}
void NervColumnLayout::ResizeToFitChildren(){
SetSize(GetContentSize(children));
}
void scContUnit::CharInsert( long computedOffset,
long& offset,
scKeyRecord& keyRec,
long& tmMove,
short& rebreak,
Bool textCleared,
TypeSpec clearedSpec )
{
#if SCDEBUG > 1
{
static int doit;
if ( doit )
fSpecRun.PrintRun( "scContUnit::CharInsert" );
}
#endif
#ifdef _RUBI_SUPPORT
if ( fRubiArray ) {
if ( fRubiArray->IsRubiData( offset + computedOffset ) ) {
scRubiData rd;
fRubiArray->GetRubiAt( rd, offset + computedOffset );
fCharArray.Transform( rd.fStartOffset, rd.fEndOffset, eRemoveJapTran, 0 );
fRubiArray->DeleteRubiData( offset );
if ( !fRubiArray->GetNumItems() )
DeleteRubiArray();
}
}
#endif
if ( computedOffset >= 0 )
fCharArray.SetNumSlots( fCharArray.GetNumItems() + 1 );
fCharArray.CharInsert( tmMove,
fSpecRun,
#ifdef _RUBI_SUPPORT
fRubiArray,
#endif
offset,
keyRec,
textCleared,
clearedSpec );
fSpecRun.SetContentSize( GetContentSize() );
#if SCDEBUG > 1
{
static int doit;
if ( doit )
fSpecRun.PrintRun( "void scContUnit::CharInsert 2" );
}
#endif
scTextline* txl = FindLine( offset );
if ( txl )
txl->Mark( scREPAINT ); /* force repaint */
Mark( scREBREAK );
rebreak = true;
}
scContUnit* scContUnit::KeyInsert( long& offset,
scKeyRecord& keyRec,
long& tmMove,
short& rebreak,
Bool textCleared,
TypeSpec clearedSpec,
Bool& iAmRemoved )
{
scContUnit* startPara = this;
long computedOffset = 0;
/* insert the character into the text */
switch ( keyRec.keycode() ) {
case scUpArrow:
case scDownArrow:
case scLeftArrow:
case scRightArrow:
ArrowSupport( keyRec, tmMove );
break;
case scParaSplit:
startPara = KeySplit( offset, keyRec, tmMove, rebreak );
break;
case scBackSpace:
case scForwardDelete:
if ( keyRec.keycode() == scBackSpace && offset == 0 ) {
startPara = Merge( offset );
iAmRemoved = true;
if ( startPara ) {
startPara->Mark( scREBREAK );
rebreak = true;
keyRec.replacedchar() = scParaSplit;
}
else
keyRec.noop() = true;
tmMove = 0;
return startPara;
}
else if ( keyRec.keycode() == scForwardDelete && offset == GetContentSize() ) {
if ( GetNext() == NULL )
keyRec.noop() = true;
else {
startPara = GetNext()->Merge( offset );
startPara->Mark( scREBREAK );
rebreak = true;
keyRec.replacedchar() = scParaSplit;
keyRec.restoreselect() = true;
/* flag to reset cursor behind new ch */
}
tmMove = 0;
break;
}
computedOffset = -1;
/* FALL THROUGH */
default:
startPara->CharInsert( computedOffset,
offset,
keyRec,
tmMove,
rebreak,
textCleared,
clearedSpec );
break;
}
return startPara;
}
Bool scContUnit::ClearText( long offset1,
long offset2 )
{
scTextline* txl;
Bool entireParaDeleted = false;
offset1 = MAX( MIN( offset1, GetContentSize() ), 0 );
offset2 = MIN( MAX( offset2, 0 ), GetContentSize() );
if ( offset1 == 0 && offset2 == GetContentSize() )
entireParaDeleted = true;
if ( entireParaDeleted ) {
GetCharArray().RemoveBetweenOffsets( offset1, offset2 );
fSpecRun.SetContentSize( 0 );
#ifdef _RUBI_SUPPORT
DeleteRubiArray();
#endif
}
else {
GetCharArray().RemoveBetweenOffsets( offset1, offset2 );
fSpecRun.Clear( offset1, offset2 );
GetCharArray().RepairText( fSpecRun, offset1, offset1 );
#ifdef _RUBI_SUPPORT
if ( GetRubiArray() ) {
GetRubiArray()->DeleteRubiData( offset1, offset2 );
if ( !GetRubiArray()->GetNumItems() )
DeleteRubiArray();
}
#endif
}
Mark( scREBREAK );
/* break link to first line if we remove that text, the refernece
* to this text will be patched in the reformatting process
*/
txl = GetFirstline();
if ( txl ) {
scColumn* col = txl->GetColumn();
if ( txl && col->GetRecomposition() ) {
scTextline* nextTxl;
for ( ; txl && txl->GetPara( ) == this; txl = nextTxl ) {
nextTxl = txl->GetNextLogical();
if ( offset2 >= txl->GetEndOffset( ) ) {
// the delete takes care of patching the para
txl->MarkForDeletion( );
}
else {
long startOffset = MIN( txl->GetStartOffset( ) - offset2, GetContentSize() );
long endOffset = MIN( txl->GetEndOffset( ) - offset2, GetContentSize() );
txl->SetOffsets( startOffset, endOffset );
}
}
}
}
return entireParaDeleted;
}
void Window_Selectable::DrawContent() const{
TCHAR buf[WND_SELECTABLE_TITLELENGTH];
WINDOWAREA tmpArea;
BYTE color;
int contentSize = 0;
if(GetActive()){
int cntX = frameArea.x + contentArea.x;
int cntY = frameArea.y + contentArea.y;
// タイトルを描画する場合
if(content.useTitle){
GetTitle(buf);
DrawStringToHandle(
cntX + GetDrawDeltaX(buf, -1, content.hTitleFont),
cntY,
buf,
windowFont.color, content.hTitleFont);
cntY += content.titleHeight;
}
// 各選択肢の描画
contentSize = GetContentSize();
for(int n=0; n<contentSize; n++){
tmpArea = GetDrawArea(n);
color = select.isActive[n] ? ((select.index == n)
? WND_SELECTABLE_COLOR_SELECTED : WND_SELECTABLE_COLOR_ACTIVE)
: WND_SELECTABLE_COLOR_INACTIVE,
DrawContentItem(n, color);
if(n == select.index){
// フォーカスの描画
pSkin->DrawFocus(
tmpArea.x, tmpArea.y,
tmpArea.w, tmpArea.h, count);
}
}
/*
for(int h=0; h<row; h++){
for(int w=0; w<column; w++){
cell = w+h*column;
GetContent(buf, cell);
cntX = frameArea.x + contentArea.x
+ (item_width+item_margin_x)*w;
switch(windowFont.align){
case 0:
ddx = 0;
break;
case 1:
ddx = (item_width -
GetDrawStringWidthToHandle(buf, strlen(buf), windowFont.hFont))/2;
break;
case 2:
ddx = item_width -
GetDrawStringWidthToHandle(buf, strlen(buf), windowFont.hFont);
break;
}
DrawStringToHandle(
cntX+ddx, cntY,
buf,
select.isActive[cell] ? ((select.index == cell)
? windowFont.color : windowFont.iColor) : windowFont.nColor,
windowFont.hFont);
if(cell == select.index){
// フォーカスの描画
pSkin->DrawFocus(
cntX, cntY,
item_width,
windowFont.fontSize, count);
}
}
cntY += windowFont.lineHeight;
}
*/
}
SetDrawBlendMode(DX_BLENDMODE_NOBLEND, 255);
}
void scContUnit::DebugParaSpecs()
{
SCDebugTrace( 0, scString( "\npara spec - 0x%08x %d\n" ), defspec_, GetContentSize() );
fSpecRun.PrintRun( "para specs" );
}
const char * Response::GetContentBufPointer() const
{
if (GetContentSize() == 0)
return 0;
return &content_buffer_[0];
}
Vec2 Grid::ArrangeChildren()
{
// Count fixed space
Vec2 allFixedSpace(0, 0);
for (GridColumn& column : columns)
if (column.GetSizingPolicy() == eGridLineSizing::FIXED)
allFixedSpace.x += column.GetWidth();
for (GridRow& row : rows)
if (row.GetSizingPolicy() == eGridLineSizing::FIXED)
allFixedSpace.y += row.GetHeight();
// Count FIT_TO_CONTENT space
// Search for max width per column
std::vector<float> maxWidths(columns.size());
for (GridColumn& column : columns)
{
if (column.GetSizingPolicy() == eGridLineSizing::FIT_TO_CONTENT)
{
float maxWidth = 0;
for (Gui* cell : column.GetCells())
maxWidth = std::max(maxWidth, cell->ArrangeChildren().x);
maxWidths[column.GetIndex()] = maxWidth;
}
}
std::vector<float> maxHeights(rows.size());
for (GridRow& row : rows)
{
if (row.GetSizingPolicy() == eGridLineSizing::FIT_TO_CONTENT)
{
float maxHeight = 0;
for (Gui* cell : row.GetCells())
maxHeight = std::max(maxHeight, cell->ArrangeChildren().y);
maxHeights[row.GetIndex()] = maxHeight;
}
}
// Sum remaining space multipliers
Vec2 spaceMultiplierSum(0, 0);
for (GridColumn& column : columns)
if (column.GetSizingPolicy() == eGridLineSizing::FILL_SPACE)
spaceMultiplierSum.x += column.GetSpaceMultiplier();
for (GridRow& row : rows)
if (row.GetSizingPolicy() == eGridLineSizing::FILL_SPACE)
spaceMultiplierSum.y += row.GetSpaceMultiplier();
Vec2 baseSpaceForFlexibleItem = Vec2::Max(Vec2(0, 0), (GetContentSize() - allFixedSpace)) / spaceMultiplierSum;
Vec2 newSize(0, 0);
// Grid cell arrangement
Vec2 pos = GetContentPos();
//float gridHeight = 0;
for (uint32_t i = 0; i < dimension.y; ++i)
{
GridRow* row = GetRow(i);
pos.x = GetContentPos().x;
// Reset grid width
newSize.x = 0;
// Cell size
Vec2 cellSize(0, 0);
for (uint32_t j = 0; j < dimension.x; ++j)
{
Gui* cell = GetCell(j, i);
GridColumn* column = GetColumn(j);
// Determine the size of the cell
if (column->GetSizingPolicy() == eGridLineSizing::FIXED)
cellSize.x = column->GetWidth();
else if (column->GetSizingPolicy() == eGridLineSizing::FILL_SPACE)
cellSize.x = baseSpaceForFlexibleItem.x * column->GetSpaceMultiplier();
else if (column->GetSizingPolicy() == eGridLineSizing::FIT_TO_CONTENT)
cellSize.x = maxWidths[j];
else
assert(0);
if (row->GetSizingPolicy() == eGridLineSizing::FIXED)
cellSize.y = row->GetHeight();
else if (row->GetSizingPolicy() == eGridLineSizing::FILL_SPACE)
cellSize.y = baseSpaceForFlexibleItem.y * row->GetSpaceMultiplier();
else if (row->GetSizingPolicy() == eGridLineSizing::FIT_TO_CONTENT)
cellSize.y = maxHeights[i];
else
assert(0);
cell->Arrange(pos, cellSize);
pos.x += cellSize.x;
newSize.x += cellSize.x;
}
newSize.y += cellSize.y;
pos.y += cellSize.y;
}
return newSize;
}
/* static */ already_AddRefed<Image>
ImageFactory::CreateRasterImage(nsIRequest* aRequest,
ProgressTracker* aProgressTracker,
const nsCString& aMimeType,
ImageURL* aURI,
uint32_t aImageFlags,
uint32_t aInnerWindowId)
{
nsresult rv;
nsRefPtr<RasterImage> newImage = new RasterImage(aProgressTracker, aURI);
rv = newImage->Init(aMimeType.get(), aImageFlags);
NS_ENSURE_SUCCESS(rv, BadImage(newImage));
newImage->SetInnerWindowID(aInnerWindowId);
uint32_t len = GetContentSize(aRequest);
// Pass anything usable on so that the RasterImage can preallocate
// its source buffer.
if (len > 0) {
// Bound by something reasonable
uint32_t sizeHint = std::min<uint32_t>(len, 20000000);
rv = newImage->SetSourceSizeHint(sizeHint);
if (NS_FAILED(rv)) {
// Flush memory, try to get some back, and try again.
rv = nsMemory::HeapMinimize(true);
nsresult rv2 = newImage->SetSourceSizeHint(sizeHint);
// If we've still failed at this point, things are going downhill.
if (NS_FAILED(rv) || NS_FAILED(rv2)) {
NS_WARNING("About to hit OOM in imagelib!");
}
}
}
nsAutoCString ref;
aURI->GetRef(ref);
net::nsMediaFragmentURIParser parser(ref);
if (parser.HasResolution()) {
newImage->SetRequestedResolution(parser.GetResolution());
}
if (parser.HasSampleSize()) {
/* Get our principal */
nsCOMPtr<nsIChannel> chan(do_QueryInterface(aRequest));
nsCOMPtr<nsIPrincipal> principal;
if (chan) {
nsContentUtils::GetSecurityManager()
->GetChannelResultPrincipal(chan, getter_AddRefs(principal));
}
if ((principal &&
principal->GetAppStatus() == nsIPrincipal::APP_STATUS_CERTIFIED) ||
gfxPrefs::ImageMozSampleSizeEnabled()) {
newImage->SetRequestedSampleSize(parser.GetSampleSize());
}
}
return newImage.forget();
}
void scCharArray::CharInsert( long& cursorSize,
scSpecRun& specRun,
#ifdef _RUBI_SUPPORT
scRubiArray* rubiArray,
#endif
long offset,
scKeyRecord& keyRec,
BOOL textCleared,
TypeSpec clearedSpec )
{
/* can we accept a spec with this character */
BOOL specInsert = false;
long streamSize = 0;
#if SCDEBUG > 1
static int doit;
if ( doit )
specRun.PrintRun( "scCharArray::CharInsert" );
#endif
cursorSize = 0;
#ifdef _RUBI_SUPPORT
// handle character insertion
switch ( keyRec.keycode() ) {
case scBackSpace:
DoBackSpace( streamSize, cursorSize, specRun, rubiArray, offset, keyRec, textCleared );
break;
case scForwardDelete:
DoForwardDelete( streamSize, cursorSize, specRun, rubiArray, offset, keyRec, textCleared );
break;
case scDiscHyphen:
DoDiscHyphen( streamSize, cursorSize, specRun, rubiArray, offset, keyRec, textCleared );
break;
case scFixAbsSpace:
case scFixRelSpace:
DoFixSpace( streamSize, cursorSize, specRun, rubiArray, offset, keyRec, textCleared );
break;
case scFillSpace:
default:
DoCharacter( streamSize, cursorSize, specRun, rubiArray, offset, keyRec, textCleared );
specInsert = true;
break;
}
#else
// handle character insertion
switch ( keyRec.keycode() ) {
case scBackSpace:
DoBackSpace( streamSize, cursorSize, specRun, offset, keyRec, textCleared );
specRun.BumpOffset( MAX( offset-1, 0 ), streamSize );
break;
case scForwardDelete:
DoForwardDelete( streamSize, cursorSize, specRun, offset, keyRec, textCleared );
specRun.BumpOffset( MAX( offset, 0 ), streamSize );
break;
case scDiscHyphen:
DoDiscHyphen( streamSize, cursorSize, specRun, offset, keyRec, textCleared );
specRun.BumpOffset( MAX( offset-1, 0 ), streamSize );
break;
case scFixAbsSpace:
case scFixRelSpace:
DoFixSpace( streamSize, cursorSize, specRun, offset, keyRec, textCleared );
specRun.BumpOffset( MAX( offset-1, 0 ), streamSize );
break;
case scFillSpace:
default:
DoCharacter( streamSize, cursorSize, specRun, offset, keyRec, textCleared );
specRun.BumpOffset( MAX( offset-1, 0 ), streamSize );
specInsert = true;
break;
}
#endif
if ( streamSize ) {
// we have changed the size of the stream and now
// we must move the specRec stuff around
fNumItems += streamSize;
#ifdef _RUBI_SUPPORT
if ( rubiArray )
rubiArray->BumpRubiData( MAX( offset, 0 ), streamSize );
#endif
/* if we inserted a spec split the specrun and insert the new one */
if ( specInsert && keyRec.spec().ptr() ) {
specRun.ApplySpec( keyRec.spec(), offset, offset + 1 );
specRun.SetContentSize( GetContentSize() );
}
else if ( textCleared && clearedSpec.ptr() ) {
specRun.ApplySpec( clearedSpec, offset, offset + 1 );
specRun.SetContentSize( GetContentSize() );
}
}
RepairText( specRun, offset, offset );
Validate( );
}
