void KJavaAppletServer::slotJavaRequest( const QByteArray& qb )
{
// qb should be one command only without the length string,
// we parse out the command and it's meaning here...
QString cmd;
QStringList args;
int index = 0;
const int qb_size = qb.size();
//get the command code
const char cmd_code = qb[ index++ ];
++index; //skip the next sep
//get contextID
QString contextID;
while( qb[index] != 0 && index < qb_size )
{
contextID += qb[ index++ ];
}
bool ok;
const int ID_num = contextID.toInt( &ok ); // context id or kio job id
/*if (d->locked_context > -1 &&
ID_num != d->locked_context &&
(cmd_code == KJAS_JAVASCRIPT_EVENT ||
cmd_code == KJAS_APPLET_STATE ||
cmd_code == KJAS_APPLET_FAILED))
{
/ * Don't allow requests from other contexts if we're waiting
* on a return value that can trigger JavaScript events
* /
d->java_requests.push_back(qb);
return;
}*/
++index; //skip the sep
if (cmd_code == KJAS_PUT_DATA) {
// rest of the data is for kio put
if (ok) {
KIOJobMap::iterator it = d->kiojobs.find( ID_num );
if (ok && it != d->kiojobs.end()) {
QByteArray qba;
qba = QByteArray::fromRawData(qb.data() + index, qb.size() - index - 1);
it.value()->data(qba);
qba = QByteArray::fromRawData(qb.data() + index, qb.size() - index - 1);
}
kDebug(6100) << "PutData(" << ID_num << ") size=" << qb.size() - index;
} else
kError(6100) << "PutData error " << ok << endl;
return;
}
//now parse out the arguments
while( index < qb_size )
{
int sep_pos = qb.indexOf( (char) 0, index );
if (sep_pos < 0) {
kError(6100) << "Missing separation byte" << endl;
sep_pos = qb_size;
}
//kDebug(6100) << "KJavaAppletServer::slotJavaRequest: "<< QString::fromLocal8Bit( qb.data() + index, sep_pos - index );
args.append( QString::fromLocal8Bit( qb.data() + index, sep_pos - index ) );
index = sep_pos + 1; //skip the sep
}
//here I should find the context and call the method directly
//instead of emitting signals
switch( cmd_code )
{
case KJAS_SHOW_DOCUMENT:
cmd = QLatin1String( "showdocument" );
break;
case KJAS_SHOW_URLINFRAME:
cmd = QLatin1String( "showurlinframe" );
break;
case KJAS_SHOW_STATUS:
cmd = QLatin1String( "showstatus" );
break;
case KJAS_RESIZE_APPLET:
cmd = QLatin1String( "resizeapplet" );
break;
case KJAS_GET_URLDATA:
if (ok && !args.empty() ) {
d->kiojobs.insert(ID_num, new KJavaDownloader(ID_num, args.first()));
kDebug(6100) << "GetURLData(" << ID_num << ") url=" << args.first();
} else
kError(6100) << "GetURLData error " << ok << " args:" << args.size() << endl;
return;
case KJAS_PUT_URLDATA:
if (ok && !args.empty()) {
KJavaUploader* const job = new KJavaUploader(ID_num, args.first());
d->kiojobs.insert(ID_num, job);
job->start();
kDebug(6100) << "PutURLData(" << ID_num << ") url=" << args.first();
} else
kError(6100) << "PutURLData error " << ok << " args:" << args.size() << endl;
return;
case KJAS_DATA_COMMAND:
if (ok && !args.empty()) {
const int cmd = args.first().toInt( &ok );
KIOJobMap::iterator it = d->kiojobs.find( ID_num );
if (ok && it != d->kiojobs.end())
it.value()->jobCommand( cmd );
kDebug(6100) << "KIO Data command: " << ID_num << " " << args.first();
} else
kError(6100) << "KIO Data command error " << ok << " args:" << args.size() << endl;
return;
case KJAS_JAVASCRIPT_EVENT:
cmd = QLatin1String( "JS_Event" );
if(!args.empty()) {
kDebug(6100) << "Javascript request: "<< contextID
<< " code: " << args[0] << endl;
} else {
kError(6100) << "Expected args not to be empty!" << endl;
}
break;
case KJAS_GET_MEMBER:
case KJAS_PUT_MEMBER:
case KJAS_CALL_MEMBER: {
if(!args.empty()) {
const int ticket = args[0].toInt();
JSStack::iterator it = d->jsstack.find(ticket);
if (it != d->jsstack.end()) {
kDebug(6100) << "slotJavaRequest: " << ticket;
args.pop_front();
it.value()->args.operator=(args); // just in case ..
it.value()->ready = true;
it.value()->exit = true;
} else
kDebug(6100) << "Error: Missed return member data";
} else {
kError(6100) << "Expected args not to be empty!" << endl;
}
return;
}
case KJAS_AUDIOCLIP_PLAY:
cmd = QLatin1String( "audioclip_play" );
if(!args.empty())
kDebug(6100) << "Audio Play: url=" << args[0];
else
kError(6100) << "Expected args not to be empty!" << endl;
break;
case KJAS_AUDIOCLIP_LOOP:
cmd = QLatin1String( "audioclip_loop" );
if(!args.empty())
kDebug(6100) << "Audio Loop: url=" << args[0];
else
kError(6100) << "Expected args not to be empty!" << endl;
break;
case KJAS_AUDIOCLIP_STOP:
cmd = QLatin1String( "audioclip_stop" );
if(!args.empty())
kDebug(6100) << "Audio Stop: url=" << args[0];
else
kError(6100) << "Expected args not to be empty!" << endl;
break;
case KJAS_APPLET_STATE:
if(args.size() > 1)
kDebug(6100) << "Applet State Notification for Applet " << args[0] << ". New state=" << args[1];
else
kError(6100) << "Expected args not to be empty!" << endl;
cmd = QLatin1String( "AppletStateNotification" );
break;
case KJAS_APPLET_FAILED:
if(args.size() > 1)
kDebug(6100) << "Applet " << args[0] << " Failed: " << args[1];
else
kError(6100) << "Expected args not to be empty!" << endl;
cmd = QLatin1String( "AppletFailed" );
break;
case KJAS_SECURITY_CONFIRM: {
if (KSSL::doesSSLWork() && !d->kssl)
d->kssl = new KSSL;
QStringList sl;
QString answer( "invalid" );
if (!d->kssl) {
answer = "nossl";
} else if (args.size() > 2) {
const int certsnr = args[1].toInt();
Q_ASSERT(args.size() > certsnr + 1);
QString text;
QList<KSSLCertificate *> certs;
for (int i = certsnr - 1; i >= 0; --i) {
const QByteArray &arg = args[i + 2].toAscii();
KSSLCertificate * cert = KSSLCertificate::fromString(arg.constData());
if (cert) {
certs.prepend(cert);
if (cert->isSigner())
text += i18n("Signed by (validation: %1)", KSSLCertificate::verifyText(cert->validate()));
else
text += i18n("Certificate (validation: %1)", KSSLCertificate::verifyText(cert->validate()));
text += "\n";
QString subject = cert->getSubject() + QChar('\n');
QRegExp reg(QString("/[A-Z]+="));
int pos = 0;
while ((pos = subject.indexOf(reg, pos)) > -1)
subject.replace(pos, 1, QString("\n "));
text += subject.mid(1);
}
}
kDebug(6100) << "Security confirm " << args.first() << certs.count();
if ( !certs.isEmpty() ) {
KSSLCertChain chain;
chain.setChain( certs );
if ( chain.isValid() )
answer = PermissionDialog( qApp->activeWindow() ).exec( text, args[0] );
}
qDeleteAll(certs);
}
sl.push_front( answer );
sl.push_front( QString::number(ID_num) );
process->send( KJAS_SECURITY_CONFIRM, sl );
return;
}
default:
return;
break;
}
if( !ok )
{
kError(6100) << "could not parse out contextID to call command on" << endl;
return;
}
KJavaAppletContext* const context = d->contexts[ ID_num ];
if( context )
context->processCmd( cmd, args );
else if (cmd != "AppletStateNotification")
kError(6100) << "no context object for this id" << endl;
}
void View::view(const QHash<QString, QString>& data, pion::net::HTTPResponseWriterPtr ptr) {
kError() << "Not implemented";
}
// make a list of the best configs for windows by depth
bool SceneOpenGL::initDrawableConfigs()
{
int cnt;
GLXFBConfig *fbconfigs = glXGetFBConfigs(display(), DefaultScreen(display()), &cnt);
for (int i = 0; i <= 32; i++) {
int back, stencil, depth, caveat, alpha, mipmap, rgba;
back = INT_MAX;
stencil = INT_MAX;
depth = INT_MAX;
caveat = INT_MAX;
mipmap = 0;
rgba = 0;
fbcdrawableinfo[ i ].fbconfig = NULL;
fbcdrawableinfo[ i ].bind_texture_format = 0;
fbcdrawableinfo[ i ].texture_targets = 0;
fbcdrawableinfo[ i ].y_inverted = 0;
fbcdrawableinfo[ i ].mipmap = 0;
for (int j = 0; j < cnt; j++) {
XVisualInfo *vi;
int visual_depth;
vi = glXGetVisualFromFBConfig(display(), fbconfigs[ j ]);
if (vi == NULL)
continue;
visual_depth = vi->depth;
XFree(vi);
if (visual_depth != i)
continue;
int value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_ALPHA_SIZE, &alpha);
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_BUFFER_SIZE, &value);
if (value != i && (value - alpha) != i)
continue;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_RENDER_TYPE, &value);
if (!(value & GLX_RGBA_BIT))
continue;
value = 0;
if (i == 32) {
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_BIND_TO_TEXTURE_RGBA_EXT, &value);
if (value) {
// TODO I think this should be set only after the config passes all tests
rgba = 1;
fbcdrawableinfo[ i ].bind_texture_format = GLX_TEXTURE_FORMAT_RGBA_EXT;
}
}
if (!value) {
if (rgba)
continue;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_BIND_TO_TEXTURE_RGB_EXT, &value);
if (!value)
continue;
fbcdrawableinfo[ i ].bind_texture_format = GLX_TEXTURE_FORMAT_RGB_EXT;
}
int back_value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_DOUBLEBUFFER, &back_value);
if (back_value > back)
continue;
int stencil_value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_STENCIL_SIZE, &stencil_value);
if (stencil_value > stencil)
continue;
int depth_value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_DEPTH_SIZE, &depth_value);
if (depth_value > depth)
continue;
int mipmap_value = -1;
if (GLTexture::framebufferObjectSupported()) {
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_BIND_TO_MIPMAP_TEXTURE_EXT, &mipmap_value);
if (mipmap_value < mipmap)
continue;
}
int caveat_value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_CONFIG_CAVEAT, &caveat_value);
if (caveat_value > caveat)
continue;
// ok, config passed all tests, it's the best one so far
fbcdrawableinfo[ i ].fbconfig = fbconfigs[ j ];
caveat = caveat_value;
back = back_value;
stencil = stencil_value;
depth = depth_value;
mipmap = mipmap_value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_BIND_TO_TEXTURE_TARGETS_EXT, &value);
fbcdrawableinfo[ i ].texture_targets = value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_Y_INVERTED_EXT, &value);
fbcdrawableinfo[ i ].y_inverted = value;
fbcdrawableinfo[ i ].mipmap = mipmap;
}
}
if (cnt)
XFree(fbconfigs);
if (fbcdrawableinfo[ DefaultDepth(display(), DefaultScreen(display()))].fbconfig == NULL) {
kError(1212) << "Couldn't find framebuffer configuration for default depth!";
return false;
}
if (fbcdrawableinfo[ 32 ].fbconfig == NULL) {
kError(1212) << "Couldn't find framebuffer configuration for depth 32 (no ARGB GLX visual)!";
return false;
}
return true;
}
SceneOpenGL::SceneOpenGL(Workspace* ws)
: Scene(ws)
, m_resetModelViewProjectionMatrix(true)
, init_ok(false)
{
initGLX();
// check for FBConfig support
if (!hasGLExtension("GLX_SGIX_fbconfig") || !glXGetFBConfigAttrib || !glXGetFBConfigs ||
!glXGetVisualFromFBConfig || !glXCreatePixmap || !glXDestroyPixmap ||
!glXCreateWindow || !glXDestroyWindow) {
kError(1212) << "GLX_SGIX_fbconfig or required GLX functions missing";
return; // error
}
if (!selectMode())
return; // error
if (!initBuffer()) // create destination buffer
return; // error
if (!initRenderingContext())
return; // error
// Initialize OpenGL
GLPlatform *glPlatform = GLPlatform::instance();
glPlatform->detect();
glPlatform->printResults();
initGL();
if (glPlatform->isSoftwareEmulation()) {
kError(1212) << "OpenGL Software Rasterizer detected. Falling back to XRender.";
QTimer::singleShot(0, Workspace::self(), SLOT(fallbackToXRenderCompositing()));
return;
}
if (!hasGLExtension("GL_ARB_texture_non_power_of_two")
&& !hasGLExtension("GL_ARB_texture_rectangle")) {
kError(1212) << "GL_ARB_texture_non_power_of_two and GL_ARB_texture_rectangle missing";
return; // error
}
if (glPlatform->isMesaDriver() && glPlatform->mesaVersion() < kVersionNumber(7, 10)) {
kError(1212) << "KWin requires at least Mesa 7.10 for OpenGL compositing.";
return;
}
if (db)
glDrawBuffer(GL_BACK);
// Check whether certain features are supported
has_waitSync = false;
if (options->isGlVSync()) {
if (glXGetVideoSync && glXSwapInterval && glXIsDirect(display(), ctxbuffer)) {
unsigned int sync;
if (glXGetVideoSync(&sync) == 0) {
if (glXWaitVideoSync(1, 0, &sync) == 0) {
// NOTICE at this time we should actually check whether we can successfully
// deactivate the swapInterval "glXSwapInterval(0) == 0"
// (because we don't actually want it active unless we explicitly run a glXSwapBuffers)
// However mesa/dri will return a range error (6) because deactivating the
// swapinterval (as of today) seems completely unsupported
has_waitSync = true;
glXSwapInterval(0);
}
else
qWarning() << "NO VSYNC! glXWaitVideoSync(1,0,&uint) isn't 0 but" << glXWaitVideoSync(1, 0, &sync);
} else
qWarning() << "NO VSYNC! glXGetVideoSync(&uint) isn't 0 but" << glXGetVideoSync(&sync);
} else
qWarning() << "NO VSYNC! glXGetVideoSync, glXSwapInterval, glXIsDirect" <<
bool(glXGetVideoSync) << bool(glXSwapInterval) << glXIsDirect(display(), ctxbuffer);
}
debug = qstrcmp(qgetenv("KWIN_GL_DEBUG"), "1") == 0;
// scene shader setup
if (GLPlatform::instance()->supports(GLSL)) {
if (!ShaderManager::instance()->isValid()) {
kDebug(1212) << "No Scene Shaders available";
} else {
// push one shader on the stack so that one is always bound
// consistency with GLES
ShaderManager::instance()->pushShader(ShaderManager::SimpleShader);
}
}
// OpenGL scene setup
setupModelViewProjectionMatrix();
if (checkGLError("Init")) {
kError(1212) << "OpenGL compositing setup failed";
return; // error
}
// set strict binding
if (options->isGlStrictBindingFollowsDriver()) {
options->setGlStrictBinding(!glPlatform->supports(LooseBinding));
}
kDebug(1212) << "DB:" << db << ", Direct:" << bool(glXIsDirect(display(), ctxbuffer)) << endl;
init_ok = true;
}
// choose the best configs for the destination buffer
bool SceneOpenGL::initBufferConfigs()
{
int cnt;
GLXFBConfig *fbconfigs = glXGetFBConfigs(display(), DefaultScreen(display()), &cnt);
fbcbuffer_db = NULL;
fbcbuffer_nondb = NULL;
for (int i = 0; i < 2; i++) {
int back, stencil, depth, caveat, alpha;
back = i > 0 ? INT_MAX : 1;
stencil = INT_MAX;
depth = INT_MAX;
caveat = INT_MAX;
alpha = 0;
for (int j = 0; j < cnt; j++) {
XVisualInfo *vi;
int visual_depth;
vi = glXGetVisualFromFBConfig(display(), fbconfigs[ j ]);
if (vi == NULL)
continue;
visual_depth = vi->depth;
XFree(vi);
if (visual_depth != DefaultDepth(display(), DefaultScreen(display())))
continue;
int value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_ALPHA_SIZE, &alpha);
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_BUFFER_SIZE, &value);
if (value != visual_depth && (value - alpha) != visual_depth)
continue;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_RENDER_TYPE, &value);
if (!(value & GLX_RGBA_BIT))
continue;
int back_value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_DOUBLEBUFFER, &back_value);
if (i > 0) {
if (back_value > back)
continue;
} else {
if (back_value < back)
continue;
}
int stencil_value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_STENCIL_SIZE, &stencil_value);
if (stencil_value > stencil)
continue;
int depth_value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_DEPTH_SIZE, &depth_value);
if (depth_value > depth)
continue;
int caveat_value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_CONFIG_CAVEAT, &caveat_value);
if (caveat_value > caveat)
continue;
back = back_value;
stencil = stencil_value;
depth = depth_value;
caveat = caveat_value;
if (i > 0)
fbcbuffer_nondb = fbconfigs[ j ];
else
fbcbuffer_db = fbconfigs[ j ];
}
}
if (cnt)
XFree(fbconfigs);
if (fbcbuffer_db == NULL && fbcbuffer_nondb == NULL) {
kError(1212) << "Couldn't find framebuffer configuration for buffer!";
return false;
}
for (int i = 0; i <= 32; i++) {
if (fbcdrawableinfo[ i ].fbconfig == NULL)
continue;
int vis_drawable = 0;
glXGetFBConfigAttrib(display(), fbcdrawableinfo[ i ].fbconfig, GLX_VISUAL_ID, &vis_drawable);
kDebug(1212) << "Drawable visual (depth " << i << "): 0x" << QString::number(vis_drawable, 16);
}
return true;
}
/**
* Read/parse the Definition file.
* @param pFile Pointer to fileobject.
* @remark throws errorcode on error (TODO: errorhandling)
*/
void kFileDef::read(kFile *pFile)
{
char *pszTmp;
char *psz;
char szBuffer[256];
/* readloop */
psz = readln(pFile, &szBuffer[0], sizeof(szBuffer));
while (psz != NULL)
{
KBOOL fNext = TRUE;
/* if-switch */
if (StringCase(psz, "LIBRARY"))
{
if (pszType != NULL) throw (kError(kError::DEF_MULIPLE_MODULE_STATEMENT));
pszType = dupeString(psz);
fLibrary = TRUE;
if (!setModuleName())
throw (kError(kError::DEF_BAD_LIBRARY_STATEMENT));
fInitInstance = stristr(pszType, "INITINSTANCE") != NULL;
fInitGlobal = stristr(pszType, "INITGLOBAL") != NULL || !fInitInstance;
fTermInstance = stristr(pszType, "TERMINSTANCE") != NULL;
fTermGlobal = stristr(pszType, "TERMGLOBAL") != NULL || !fTermInstance;
}
else if (StringCase(psz, "NAME"))
{
if (pszType != NULL) throw (kError(kError::DEF_MULIPLE_MODULE_STATEMENT));
pszType = dupeString(psz);
fProgram = TRUE;
setModuleName();
if (stristr(pszType, "WINDOWAPI"))
chAppType = kFileDef::pm;
else if (stristr(pszType, "NOTWINDOWCOMPAT"))
chAppType = kFileDef::fullscreen;
else if (stristr(pszType, "WINDOWCOMPAT"))
chAppType = kFileDef::pmvio;
else
chAppType = kFileDef::unknown;
}
else if (StringCase(psz, "PHYSICAL DEVICE")) //gap is fixed to one space, this may be fixed in readln.
{
if (pszType != NULL) throw (kError(kError::DEF_MULIPLE_MODULE_STATEMENT));
pszType = dupeString(psz);
fPhysicalDevice = TRUE;
setModuleName();
}
else if (StringCase(psz, "VIRTUAL DEVICE")) //gap is fixed to one space, this may be fixed in readln.
{
if (pszType != NULL) throw (kError(kError::DEF_MULIPLE_MODULE_STATEMENT));
pszType = dupeString(psz);
fVirtualDevice = TRUE;
setModuleName();
}
else if (StringCase(psz, "BASE"))
pszBase = dupeString(psz, TRUE);
else if (StringCase(psz, "CODE"))
pszCode = dupeString(psz, TRUE);
else if (StringCase(psz, "DATA"))
pszData = dupeString(psz, TRUE);
else if (StringCase(psz, "DESCRIPTION"))
pszDescription = dupeString(psz, TRUE);
else if (StringCase(psz, "EXETYPE"))
pszExeType = dupeString(psz, TRUE);
else if (StringCase(psz, "HEAPSIZE"))
pszHeapSize = dupeString(psz, TRUE);
else if (StringCase(psz, "OLD"))
pszOld = dupeString(psz, TRUE);
else if (StringCase(psz, "PROTMODE"))
pszProtmode = dupeString(psz, TRUE);
else if (StringCase(psz, "STACKSIZE"))
pszStackSize = dupeString(psz, TRUE);
else if (StringCase(psz, "STUB"))
pszStub = dupeString(psz, TRUE);
else if (StringCase(psz, "SEGMENTS"))
{
PDEFSEGMENT *pps = &pSegments;
while (!isKeyword(psz = readln(pFile, &szBuffer[0], sizeof(szBuffer))) && psz != NULL)
{
*pps = new DEFSEGMENT; memset(*pps, 0, sizeof(**pps));
(**pps).psz = dupeString(psz);
pps = &(**pps).pNext;
}
fNext = FALSE;
}
else if (StringCase(psz, "IMPORTS"))
{
PDEFIMPORT *ppi = &pImports;
while (!isKeyword(psz = readln(pFile, &szBuffer[0], sizeof(szBuffer))) && psz != NULL)
{
//DOSCALL1.154 or DosQueryHeaderInfo = DOSCALL1.154
*ppi = new DEFIMPORT; memset(*ppi, 0, sizeof(**ppi));
(**ppi).ulOrdinal = 0xffffffffUL;
if ((pszTmp = strchr(psz, '=')) != NULL)
{
*pszTmp = '\0';
(**ppi).pszIntName = dupeString(trim(psz));
psz = pszTmp + 1;
}
if ((pszTmp = strchr(psz, '.')) != NULL)
{
*pszTmp = '\0';
(**ppi).pszDll = dupeString(trim(psz));
psz = pszTmp + 1;
}
psz = trim(psz);
if (*psz >= '0' && *psz <= '9')
{
(**ppi).ulOrdinal = strtol(psz, &pszTmp, 0);
if (psz ==pszTmp) throw (kError(kError::DEF_BAD_IMPORT));
}
else
(**ppi).pszName = dupeString(psz);
ppi = &(**ppi).pNext;
}
fNext = FALSE;
}
else if (StringCase(psz, "EXPORTS"))
{
PDEFEXPORT *ppe = &pExports;
while (!isKeyword(psz = readln(pFile, &szBuffer[0], sizeof(szBuffer))) && psz != NULL)
{
/* CloseHandle = CloseHandle@4 @1234 RESIDENTNAME 2 */
*ppe = new DEFEXPORT; memset(*ppe, 0, sizeof(**ppe));
(**ppe).ulOrdinal = 0xffffffffUL;
(**ppe).cParam = 0xffffffffUL;
/* look for '=' */
pszTmp = strchr(psz, '=');
if (pszTmp != NULL)
{ /* CloseHandle = CloseHandle@4 */
*pszTmp ='\0';
(**ppe).pszName = dupeString(trim(psz));
psz = trim(pszTmp + 1);
pszTmp = strchr(psz, ' ');
if (pszTmp != NULL)
*pszTmp = '\0';
(**ppe).pszIntName = dupeString(trim(psz));
if (pszTmp != NULL)
psz = pszTmp + 1;
else
psz = NULL;
}
else
{ /* CloseHandle (no '= CloseHandle@4')*/
pszTmp = strchr(psz, ' ');
if (pszTmp != NULL)
*pszTmp = '\0';
(**ppe).pszName = dupeString(trim(psz));
if (pszTmp != NULL)
psz = pszTmp + 1;
else
psz = NULL;
}
if (psz != NULL)
{ /* @1234 RESIDENTNAME 2 */
pszTmp = strchr(psz, '@');
if (pszTmp)
{ /* @1234 RESIDENTNAME 2 */
psz = pszTmp + 1;
(**ppe).ulOrdinal = strtol(psz, &pszTmp, 0);
if (pszTmp == psz) throw (kError(kError::DEF_BAD_EXPORT));
psz = trim(pszTmp);
if (*psz != '\0')
{ /* RESIDENTNAME 2 */
if (StringCase(psz, "RESIDENTNAME"))
{
(**ppe).fResident = TRUE;
psz = trim(psz + sizeof("RESIDENTNAME") - 1);
}
else if (StringCase(psz, "NONAME"))
{
(**ppe).fResident = FALSE;
psz = trim(psz + sizeof("NONAME") - 1);
}
}
else
{
(**ppe).fResident = (**ppe).ulOrdinal == 0xffffffffUL;
}
}
if (*psz != '\0')
{ /* 2 */
(**ppe).cParam = strtol(psz, &pszTmp, 0);
if (pszTmp == psz) throw (kError(kError::DEF_BAD_EXPORT));
}
}
removeFnutts((**ppe).pszIntName);
removeFnutts((**ppe).pszName);
ppe = &(**ppe).pNext;
}
fNext = FALSE;
}
else
throw (kError(kError::DEF_UNKOWN_VERB));
/* next ? */
if (fNext)
psz = readln(pFile, &szBuffer[0], sizeof(szBuffer));
}
/* sanity check */
if (pszType == NULL)
throw (kError(kError::DEF_NO_MODULE_STATEMENT));
}
void PrintPrepareResizeCommandBuilder::buildCommand(KProcess *proc,
BatchProcessImagesItem *item, const QString& albumDest)
{
kDebug() << "resizing for settings: paperWidth = " << m_paperWidth
<< ", paperHeight = " << m_paperHeight << ", dpi = "
<< m_dpi;
// Get image information.
QImage img;
bool loaded = img.load(item->pathSrc());
if (!loaded)
{
kError() << "Unable to load image " << item->pathSrc();
return;
}
unsigned int w = img.width();
unsigned int h = img.height();
const float oneInchInMM = 25.4F;
// calculate needed image size as paper size in pixels for the given
// resolution and rotate the canvas if needed
unsigned int paperWidthInPixels = 0;
unsigned int paperHeightInPixels = 0;
if (w < h)
{
// (w < h) because all paper dimensions are given in landscape format
paperWidthInPixels = (int)((float)(m_paperHeight * m_dpi) / oneInchInMM);
paperHeightInPixels = (int)((float)(m_paperWidth * m_dpi) / oneInchInMM);
}
else
{
paperHeightInPixels = (int)((float)(m_paperHeight * m_dpi) / oneInchInMM);
paperWidthInPixels = (int)((float)(m_paperWidth * m_dpi) / oneInchInMM);
}
kDebug() << "paper size in pixel: " << paperWidthInPixels << "x"
<< paperHeightInPixels;
*proc << "convert" << "-verbose";
*proc << item->pathSrc();
// resize image
const QString rawPaperDimensions = QString::number(paperWidthInPixels)
+ 'x' + QString::number(paperHeightInPixels);
if (m_stretch)
{
// stretching is simple, just force paper dimensions
*proc << "-resize" << rawPaperDimensions + '!';
appendQualityAndFilter(proc);
}
else
{
// if we don't want to stretch the image, some more work is needed
// first resize the image so that it will fit at least the whole paper
// but one dimension can get bigger
*proc << "-resize" << rawPaperDimensions + '^';
appendQualityAndFilter(proc);
// and the crop it to the desired paper size
*proc << "-gravity" << "center";
*proc << "-crop" << rawPaperDimensions + "+0+0" << "+repage";
}
// ImageMagick composite program do not preserve exif data from original.
// Need to use "-profile" option for that.
*proc << "-profile" << item->pathSrc();
*proc << albumDest + '/' + item->nameDest();
}
bool Metalink::metalinkInit(const KUrl &src, const QByteArray &data)
{
kDebug(5001);
if (!src.isEmpty()) {
m_localMetalinkLocation = src;
}
//use the downloaded metalink-file data directly if possible
if (!data.isEmpty()) {
KGetMetalink::HandleMetalink::load(data, &m_metalink);
}
//try to parse the locally stored metalink-file
if (!m_metalink.isValid() && m_localMetalinkLocation.isValid()) {
KGetMetalink::HandleMetalink::load(m_localMetalinkLocation.toLocalFile(), &m_metalink);
}
if (!m_metalink.isValid()) {
kError(5001) << "Unknown error when trying to load the .metalink-file. Metalink is not valid.";
setStatus(Job::Aborted);
setTransferChange(Tc_Status, true);
return false;
}
//offers a dialog to download the newest version of a dynamic metalink
if ((m_source.isLocalFile() || !m_metalinkJustDownloaded) &&
m_metalink.dynamic && (UrlChecker::checkSource(m_metalink.origin) == UrlChecker::NoError)) {
if (KMessageBox::questionYesNo(0, i18n("A newer version of this Metalink might exist, do you want to download it?"),
i18n("Redownload Metalink")) == KMessageBox::Yes) {
m_localMetalinkLocation.clear();
m_source = m_metalink.origin;
downloadMetalink();
return false;
}
}
QList<KGetMetalink::File>::const_iterator it;
QList<KGetMetalink::File>::const_iterator itEnd = m_metalink.files.files.constEnd();
m_totalSize = 0;
KIO::fileoffset_t segSize = 500 * 1024;//TODO use config here!
const KUrl tempDest = KUrl(m_dest.directory());
KUrl dest;
for (it = m_metalink.files.files.constBegin(); it != itEnd ; ++it)
{
dest = tempDest;
dest.addPath((*it).name);
QList<KGetMetalink::Url> urlList = (*it).resources.urls;
//sort the urls according to their priority (highest first)
qSort(urlList.begin(), urlList.end(), qGreater<KGetMetalink::Url>());
KIO::filesize_t fileSize = (*it).size;
m_totalSize += fileSize;
//create a DataSourceFactory for each separate file
DataSourceFactory *dataFactory = new DataSourceFactory(this, dest, fileSize, segSize);
dataFactory->setMaxMirrorsUsed(MetalinkSettings::mirrorsPerFile());
#ifdef HAVE_NEPOMUK
nepomukHandler()->setProperties((*it).properties(), QList<KUrl>() << dest);
#endif //HAVE_NEPOMUK
//TODO compare available file size (<size>) with the sizes of the server while downloading?
connect(dataFactory, SIGNAL(capabilitiesChanged()), this, SLOT(slotUpdateCapabilities()));
connect(dataFactory, SIGNAL(dataSourceFactoryChange(Transfer::ChangesFlags)), this, SLOT(slotDataSourceFactoryChange(Transfer::ChangesFlags)));
connect(dataFactory->verifier(), SIGNAL(verified(bool)), this, SLOT(slotVerified(bool)));
connect(dataFactory->signature(), SIGNAL(verified(int)), this, SLOT(slotSignatureVerified()));
connect(dataFactory, SIGNAL(log(QString,Transfer::LogLevel)), this, SLOT(setLog(QString,Transfer::LogLevel)));
//add the DataSources
for (int i = 0; i < urlList.size(); ++i)
{
const KUrl url = urlList[i].url;
if (url.isValid())
{
dataFactory->addMirror(url, MetalinkSettings::connectionsPerUrl());
}
}
//no datasource has been created, so remove the datasource factory
if (dataFactory->mirrors().isEmpty())
{
delete dataFactory;
}
else
{
dataFactory->verifier()->addChecksums((*it).verification.hashes);
foreach (const KGetMetalink::Pieces &pieces, (*it).verification.pieces) {
dataFactory->verifier()->addPartialChecksums(pieces.type, pieces.length, pieces.hashes);
}
const QHash <QString, QString> signatures = (*it).verification.signatures;
QHash<QString, QString>::const_iterator it;
QHash<QString, QString>::const_iterator itEnd = signatures.constEnd();
for (it = signatures.constBegin(); it != itEnd; ++it) {
if (it.key().toLower() == "pgp") {
dataFactory->signature()->setAsciiDetatchedSignature(*it);
}
}
m_dataSourceFactory[dataFactory->dest()] = dataFactory;
}
}
if ((m_metalink.files.files.size() == 1) && m_dataSourceFactory.size())
{
m_dest = dest;
}
if (!m_dataSourceFactory.size()) {
//TODO make this via log in the future + do not display the KMessageBox
kWarning(5001) << "Download of" << m_source << "failed, no working URLs were found.";
KMessageBox::error(0, i18n("Download failed, no working URLs were found."), i18n("Error"));
setStatus(Job::Aborted);
setTransferChange(Tc_Status, true);
return false;
}
m_ready = !m_dataSourceFactory.isEmpty();
slotUpdateCapabilities();
//the metalink-file has just been downloaded, so ask the user to choose the files that
// should be downloaded
if (m_metalinkJustDownloaded) {
KDialog *dialog = new FileSelectionDlg(fileModel());
dialog->setAttribute(Qt::WA_DeleteOnClose);
connect(dialog, SIGNAL(finished(int)), this, SLOT(fileDlgFinished(int)));
dialog->show();
}
return true;
}
void ColorContext::setupColorLookupTable(bool advanced)
{
kDebug() << m_outputName;
oyProfile_s *dummyProfile = 0;
oyOptions_s *options = 0;
if (!m_dstProfile)
m_dstProfile = dummyProfile = oyProfile_FromStd(oyASSUMED_WEB, icc_profile_flags, 0);
/* skip dummyProfile to dummyProfile conversion */
if (!m_srcProfile && dummyProfile) {
if (dummyProfile)
oyProfile_Release(&dummyProfile);
return;
}
if (!m_srcProfile) {
m_srcProfile = oyProfile_FromStd(oyASSUMED_WEB, icc_profile_flags, 0);
if (!m_srcProfile) {
kError() << "Output" << m_outputName << ":" << "no assumed dummyProfile source profile";
kWarning() << "Output" << m_outputName << "using dummy clut";
buildDummyClut(m_clut);
return;
}
}
int error = 0;
int flags = 0;
// Optionally set advanced options from Oyranos
if (advanced)
flags = oyOPTIONATTRIBUTE_ADVANCED;
// Allocate memory for clut data
m_clut.resize(CLUT_ELEMENT_COUNT);
kDebug() << "Color conversion for" << m_outputName << "flags" << flags << (advanced ? "advanced" : "");
oyImage_s *imageIn = oyImage_Create(
LUT_GRID_POINTS,
LUT_GRID_POINTS * LUT_GRID_POINTS,
m_clut.data(),
OY_TYPE_123_16,
m_srcProfile,
0);
oyImage_s *imageOut = oyImage_Create(
LUT_GRID_POINTS,
LUT_GRID_POINTS * LUT_GRID_POINTS,
m_clut.data(),
OY_TYPE_123_16,
m_dstProfile,
0);
oyConversion_s *conversion = oyConversion_CreateBasicPixels(imageIn, imageOut, options, 0);
if (!conversion) {
kWarning() << "No conversion created for" << m_outputName;
if (dummyProfile)
oyProfile_Release(&dummyProfile);
return;
}
oyOptions_Release(&options);
error = oyOptions_SetFromText(&options, "//"OY_TYPE_STD"/config/display_mode", "1", OY_CREATE_NEW);
if (error) {
kWarning() << "Oy options error:" << error;
if (dummyProfile)
oyProfile_Release(&dummyProfile);
return;
}
error = oyConversion_Correct(conversion, "//"OY_TYPE_STD"/icc", flags, options);
if (error) {
kWarning() << "Failed to correct conversion for" << m_outputName << "flags" << flags;
if (dummyProfile)
oyProfile_Release(&dummyProfile);
return;
}
oyFilterGraph_s *conversionGraph = oyConversion_GetGraph(conversion);
oyFilterNode_s *iccNode = oyFilterGraph_GetNode(conversionGraph, -1, "///icc", 0);
// See what to search for in the cache
QByteArray entryText;
const char *t = oyFilterNode_GetText(iccNode, oyNAME_NAME);
if (t)
entryText = t;
oyStructList_s *cache = Display::getInstance()->cache();
oyHash_s *entry = oyStructList_GetHash(cache, 0, entryText.constData());
oyArray2d_s *oyClut = (oyArray2d_s*) oyHash_GetPointer(entry, oyOBJECT_ARRAY2D_S);
char ** array2d = (char**)oyArray2d_GetData( oyClut );
oyFilterNode_Release(&iccNode);
oyFilterGraph_Release(&conversionGraph);
if (oyClut) {
// Found in cache
kDebug() << "clut" << oyClut << "obtained from cache using entry" << entryText;
memcpy(m_clut.data(), array2d[0], CLUT_DATA_SIZE);
} else {
kDebug() << "clut not found in cache using entry" << entryText << ", doing conversion";
// Create dummy / identity clut data for conversion input
buildDummyClut(m_clut);
// Do conversion
error = oyConversion_RunPixels(conversion, 0);
if (error) {
kWarning() << "Output" << m_outputName << "Error" << error << "in conversion run pixels";
if (dummyProfile)
oyProfile_Release(&dummyProfile);
return;
}
// Save to cache
oyClut = oyArray2d_Create(
NULL,
LUT_GRID_POINTS * 3,
LUT_GRID_POINTS * LUT_GRID_POINTS,
oyUINT16,
NULL);
array2d = (char**)oyArray2d_GetData( oyClut );
memcpy(array2d[0], m_clut.data(), CLUT_DATA_SIZE);
oyHash_SetPointer(entry, (oyStruct_s*) oyClut);
}
oyOptions_Release(&options);
oyImage_Release(&imageIn);
oyImage_Release(&imageOut);
oyConversion_Release(&conversion);
if (!m_dstProfile)
kDebug() << "Output" << m_outputName << "no profile";
}
