xaostranslator.cpp

另一个分形程序

			out_space = B_RGB32;
		}
	 }
	real_out_space = out_space;
	if (!ioExtension || ioExtension->FindBool(B_TRANSLATOR_EXT_HEADER_ONLY, &headeronly)) headeronly=false;

	if (!ioExtension || ioExtension->FindBool(B_TRANSLATOR_EXT_DATA_ONLY, &dataonly)) dataonly=false;

	out_space = optimaloutspace(out_space);
	
        /* Find the most similar colorspace supported by XaoS engine */
	g_settings_lock.Unlock();

        /* Construct image settings */
	int imagetype;
	union paletteinfo info;
        be_get_imagespecs(out_space, (int *)&imagetype, (int *)&info.truec.rmask, (int *)&info.truec.gmask, (int *)&info.truec.bmask);
	out_rowbytes=bytesperpixel(imagetype)*width;
	if (!out_rowbytes) out_rowbytes=(width+7)/8;

	/* B_TRANSLATOR_BITMAP header */
	TranslatorBitmap hdr;
	hdr.magic = B_HOST_TO_BENDIAN_INT32(B_TRANSLATOR_BITMAP);
	hdr.bounds.left = B_HOST_TO_BENDIAN_FLOAT(0);
	hdr.bounds.top = B_HOST_TO_BENDIAN_FLOAT(0);
	hdr.bounds.right = B_HOST_TO_BENDIAN_FLOAT(width-1);
	hdr.bounds.bottom = B_HOST_TO_BENDIAN_FLOAT(height-1);
	hdr.rowBytes = B_HOST_TO_BENDIAN_INT32(out_rowbytes);
	hdr.colors = (color_space)B_HOST_TO_BENDIAN_INT32(out_space);
	hdr.dataSize = B_HOST_TO_BENDIAN_INT32(out_rowbytes*height);
	if (!dataonly) err = outDestination->Write(&hdr, sizeof(hdr));
	
	if (headeronly) return B_OK;
	struct palette *pal=createpalette(0,0, imagetype, 0, 0, NULL, NULL, NULL, NULL, &info);
	char *bits = new char[out_rowbytes*height];
	if (!pal)
	{
		x_error("Can not create palette (out of memory)\n");
		return B_NO_TRANSLATOR;
	}
	struct image *image=create_image_cont(width, height, out_rowbytes,2, (pixel_t *)bits, (pixel_t *)bits, pal, flipgeneric, 0, pixelwidth, pixelheight);
	if (!image)
	{
		x_error("Can not create image (out of memory)");
		destroypalette(pal);
		return B_NO_TRANSLATOR;
	}
	xio_file input=positionio_ropen(inSource);
	g_calculation_lock.Lock();
	translator=1;
	if(setjmp(translatorjmp)) {
		/* OOPS something went realy badly. 
                   Try to return to application. Hopefully it will work.*/
		xth_uninit();
        	g_calculation_lock.Unlock();
		return B_NO_TRANSLATOR;
	}
	xio_init("");
        uih_registermenus();
	uih_renderimage(NULL, input, NULL, image, anti, NULL, 2 /*output messages */);
	destroypalette(pal);
	xio_uninit();
	xth_uninit();
	uih_unregistermenus();
	translator=0;
	g_calculation_lock.Unlock();
	outDestination->Write(bits, (image->currlines[1]-image->currlines[0])*height);
	destroy_image(image);
	delete bits;
	return B_OK;
}

class XaoSTranslatorView :
	public BView
{
public:
		int visible;
		XaoSTranslatorView(
				const BRect & frame,
				const char * name,
				uint32 resize,
				uint32 flags,	
				BMessage *ioExtension) :
			BView(frame, name, resize, flags)
			{
				visible=0;
				/*if (ioExtension) SetSettings(ioExtension);*/
				g_settings_lock.Lock();
				SetViewColor(220,220,220,0);
				mMenu = new BPopUpMenu("Color Space");
				mMenu->AddItem(new BMenuItem("None", CSMessage(B_NO_COLOR_SPACE)));
				mMenu->AddItem(new BMenuItem("RGB 8:8:8 32 bits", CSMessage(B_RGB32)));
				if (B_HOST_IS_LENDIAN) {
					mMenu->AddItem(new BMenuItem("RGB 5:5:5 16 bits", CSMessage(B_RGB15)));
					mMenu->AddItem(new BMenuItem("RGB 5:6:5 16 bits", CSMessage(B_RGB16)));
				}
				mMenu->AddSeparatorItem();
				mMenu->AddItem(new BMenuItem("Grayscale 8 bits", CSMessage(B_GRAY8)));
				mMenu->AddItem(new BMenuItem("Bitmap 1 bit", CSMessage(B_GRAY1)));
				mMenu->AddSeparatorItem();
				mMenu->AddItem(new BMenuItem("RGB 8:8:8 32 bits big-endian", CSMessage(B_RGB32_BIG)));
				if (B_HOST_IS_BENDIAN) {
					mMenu->AddItem(new BMenuItem("RGB 5:5:5 16 bits big-endian", CSMessage(B_RGB15_BIG)));
					mMenu->AddItem(new BMenuItem("RGB 5:6:5 16 bits big-endian", CSMessage(B_RGB16_BIG)));
				}
				mField = new BMenuField(BRect(20,70,180,90), "Color Space Field", "Color Space", mMenu);
				mField->SetViewColor(ViewColor());
				AddChild(mField);
				SelectColorSpace(g_settings.out_space);
				BMessage * msg = new BMessage(CHANGE_ANTIALIAS);
				mAntialiasing = new BCheckBox(BRect(20,45,180,62), "Antialiasing", "Antialiasing", msg);
				if (g_settings.antialiasing) {
					mAntialiasing->SetValue(1);
				}
				mAntialiasing->SetViewColor(ViewColor());
				AddChild(mAntialiasing);
				char s[256];
				sprintf(s,"%i",g_settings.width);
				mWidth = new BTextControl(BRect(20, 70+35, 180, 70+35+17), "Width", "Width", s, new BMessage(CHANGE_WIDTH));
				mWidth->SetViewColor(ViewColor());
				AddChild(mWidth);
				sprintf(s,"%i",g_settings.height);
				mHeight = new BTextControl(BRect(20, 60+2*35, 180, 60+2*35+17), "Height", "Height", s, new BMessage(CHANGE_HEIGHT));
				mHeight->SetViewColor(ViewColor());
				AddChild(mHeight);
				sprintf(s,"%i",(int)(INCH/g_settings.pixelwidth+0.5));
				mPixelWidth = new BTextControl(BRect(20, 70+3*35, 180, 70+3*35+17), "X DPI", "X DPI", s, new BMessage(CHANGE_PIXELWIDTH));
				mPixelWidth->SetViewColor(ViewColor());
				AddChild(mPixelWidth);
				sprintf(s,"%i",(int)(INCH/g_settings.pixelheight+0.5));
				mPixelHeight = new BTextControl(BRect(20, 60+4*35, 180, 60+4*35+17), "Y DPI", "Y DPI", s, new BMessage(CHANGE_PIXELHEIGHT));
				mPixelHeight->SetViewColor(ViewColor());
				AddChild(mPixelHeight);
				visible=1;
				SelectColorSpace(g_settings.out_space);
				g_settings_lock.Unlock();
			}
		~XaoSTranslatorView()
			{
				/* nothing here */
			}

		enum {
			SET_COLOR_SPACE = 'xpf=',
			CHANGE_ANTIALIAS,
			CHANGE_WIDTH,
			CHANGE_HEIGHT,
			CHANGE_PIXELWIDTH,
			CHANGE_PIXELHEIGHT
		};

virtual	void Draw(
				BRect area)
			{
				area = area; /* silence compiler */
				SetFont(be_bold_font);
				font_height fh;
				GetFontHeight(&fh);
				char str[100];
				sprintf(str, "XaoSTranslator %.2f", (float)translatorVersion/100.0);
				DrawString(str, BPoint(fh.descent+1, fh.ascent+fh.descent*2+fh.leading));
			}
virtual	void MessageReceived(
				BMessage * message)
			{
				if (message->what == SET_COLOR_SPACE) {
					SetSettings(message);
				}
				else if (message->what == CHANGE_ANTIALIAS) {
					BMessage msg;
					msg.AddBool("xpf /antialiasing", mAntialiasing->Value());
					SetSettings(&msg);
				}
				else if (message->what == CHANGE_WIDTH) {
					BMessage msg;
					int i;
					if(sscanf(mWidth->Text(),"%i",&i)==1 && i>0 && i<4096)
					 msg.AddInt32("xpf /width", i), SetSettings(&msg);
				}
				else if (message->what == CHANGE_HEIGHT) {
					BMessage msg;
					int i;
					if(sscanf(mHeight->Text(),"%i",&i)==1 && i>0 && i<4096)
					 msg.AddInt32("xpf /height", i), SetSettings(&msg);
				}
				else if (message->what == CHANGE_PIXELWIDTH) {
					BMessage msg;
					int i;
					if(sscanf(mPixelWidth->Text(),"%i",&i)==1 && i>0) {
					 msg.AddDouble("xpf /pixelwidth", INCH/(double)i), SetSettings(&msg);
					}
				}
				else if (message->what == CHANGE_PIXELHEIGHT) {
					BMessage msg;
					int i;
					if(sscanf(mPixelHeight->Text(),"%i",&i)==1 && i>0)
					 msg.AddDouble("xpf /pixelheight",INCH/(double)i), SetSettings(&msg);
				}
				else {
					BView::MessageReceived(message);
				}
			}
virtual	void AllAttached()
			{
				BView::AllAttached();
				BMessenger msgr(this);
				/*	Tell all menu items we're the man.	*/
				for (int ix=0; ix<mMenu->CountItems(); ix++) {
					BMenuItem * i = mMenu->ItemAt(ix);
					if (i) {
						i->SetTarget(msgr);
					}
				}
				mAntialiasing->SetTarget(msgr);
				mWidth->SetTarget(msgr);
				mHeight->SetTarget(msgr);
				mPixelWidth->SetTarget(msgr);
				mPixelHeight->SetTarget(msgr);
			}

		void SetSettings(
				BMessage * message)
			{
				g_settings_lock.Lock();
				color_space space;
				if (!message->FindInt32(B_TRANSLATOR_EXT_BITMAP_COLOR_SPACE, (int32*)&space)) {
					g_settings.out_space = space;
					SelectColorSpace(space);
					g_settings.settings_touched = true;
				}
				bool antialiasing;
				if (!message->FindBool("xpf /antialiasing", &antialiasing)) {
					g_settings.antialiasing = antialiasing;
					g_settings.settings_touched = true;
				}
				int32 width;
				if (!message->FindInt32("xpf /width", &width)) {
					g_settings.width = width;
					g_settings.settings_touched = true;
				}
				int32 height;
				if (!message->FindInt32("xpf /height", &height)) {
					g_settings.height = height;
					g_settings.settings_touched = true;
				}
				double pixelwidth;
				if (!message->FindDouble("xpf /pixelwidth", &pixelwidth)) {
					g_settings.pixelwidth = pixelwidth;
					g_settings.settings_touched = true;
				}
				double pixelheight;
				if (!message->FindDouble("xpf /pixelheight", &pixelheight)) {
					g_settings.pixelheight = pixelheight;
					g_settings.settings_touched = true;
				}
				g_settings_lock.Unlock();
			}

private:
		BPopUpMenu * mMenu;
		BMenuField * mField;
		BCheckBox * mAntialiasing;
		BTextControl * mWidth;
		BTextControl * mHeight;
		BTextControl * mPixelWidth;
		BTextControl * mPixelHeight;

		BMessage * CSMessage(
				color_space space)
			{
				BMessage * ret = new BMessage(SET_COLOR_SPACE);
				ret->AddInt32(B_TRANSLATOR_EXT_BITMAP_COLOR_SPACE, space);
				return ret;
			}

		void SelectColorSpace(
				color_space space)
			{
				if (!visible) return;
				for (int ix=0; ix<mMenu->CountItems(); ix++) {
					int32 s;
					BMenuItem * i = mMenu->ItemAt(ix);
					if (i) {
						BMessage * m = i->Message();
						if (m && !m->FindInt32(B_TRANSLATOR_EXT_BITMAP_COLOR_SPACE, &s) && (s == space)) {
							mMenu->Superitem()->SetLabel(i->Label());
							break;
						}
					}
				}
			}
};

status_t 
MakeConfig(	/*	optional	*/
	BMessage * ioExtension,	/*	can be NULL	*/
	BView * * outView,
	BRect * outExtent)
{
	XaoSTranslatorView * v = new XaoSTranslatorView(BRect(0,0,200,100), "XaoSTranslator Settings", B_FOLLOW_ALL, B_WILL_DRAW, ioExtension);
	*outView = v;
	*outExtent = v->Bounds();
	return B_OK;
}

status_t
GetConfigMessage(	/*	optional	*/
	BMessage * ioExtension)
{
	status_t err = B_OK;
	const char * name = B_TRANSLATOR_EXT_BITMAP_COLOR_SPACE;
	g_settings_lock.Lock();
	(void)ioExtension->RemoveName(name);
	err = ioExtension->AddInt32(name, g_settings.out_space);
	err = ioExtension->AddInt32("xpf /width", g_settings.width);
	err = ioExtension->AddInt32("xpf /height", g_settings.height);
	err = ioExtension->AddDouble("xpf /pixelwidth", g_settings.pixelwidth);
	err = ioExtension->AddDouble("xpf /pixelheight", g_settings.pixelheight);
	err = ioExtension->AddBool("xpf /antialiasing", g_settings.antialiasing);
	g_settings_lock.Unlock();
	return err;
}