void
handlekeypressed(Widget w, caddr_t clientdata, caddr_t calldata)
{
XKeyEvent *keyev = (XKeyPressedEvent *) calldata;
GRAPH *graph = (GRAPH *) clientdata;
char text[4];
int nbytes;
nbytes = XLookupString(keyev, text, 4, NULL, NULL);
if (!nbytes) return;
/* write it */
PushGraphContext(graph);
text[nbytes] = '\0';
SetColor(1);
Text(text, keyev->x, graph->absolute.height - keyev->y);
/* save it */
SaveText(graph, text, keyev->x, graph->absolute.height - keyev->y);
/* warp mouse so user can type in sequence */
XWarpPointer(display, None, DEVDEP(graph).window, 0, 0, 0, 0,
keyev->x + XTextWidth(DEVDEP(graph).font, text, nbytes),
keyev->y);
PopGraphContext();
}
static void
handlekeypressed(Widget w, XtPointer client_data, XEvent *ev, Boolean *continue_dispatch)
{
XKeyEvent *keyev = & ev->xkey;
GRAPH *graph = (GRAPH *) client_data;
char text[4];
int nbytes;
NG_IGNORE(w);
NG_IGNORE(continue_dispatch);
nbytes = XLookupString(keyev, text, 4, NULL, NULL);
if (!nbytes)
return;
/* write it */
PushGraphContext(graph);
text[nbytes] = '\0';
SetColor(1);
DevDrawText(text, keyev->x, graph->absolute.height - keyev->y);
/* save it */
SaveText(graph, text, keyev->x, graph->absolute.height - keyev->y);
/* warp mouse so user can type in sequence */
XWarpPointer(display, None, DEVDEP(graph).window, 0, 0, 0, 0,
keyev->x + XTextWidth(DEVDEP(graph).font, text, nbytes),
keyev->y);
PopGraphContext();
}
GRAPH *
CopyGraph(GRAPH *graph)
{
GRAPH *ret;
struct _keyed *k;
struct dveclist *link, *newlink;
ret = NewGraph();
bcopy(graph, ret, sizeof(GRAPH)); /* va: compatible pointer types */
ret->graphid = RunningId - 1; /* restore id */
/* copy keyed */
for (ret->keyed = NULL, k = graph->keyed; k; k = k->next)
SaveText(ret, k->text, k->x, k->y);
/* copy dvecs */
ret->plotdata = NULL;
for (link = graph->plotdata; link; link = link->next) {
newlink = TMALLOC(struct dveclist, 1);
newlink->next = ret->plotdata;
newlink->vector = vec_copy(link->vector);
/* vec_copy doesn't set v_color or v_linestyle */
newlink->vector->v_color = link->vector->v_color;
newlink->vector->v_linestyle = link->vector->v_linestyle;
newlink->vector->v_flags |= VF_PERMANENT;
ret->plotdata = newlink;
}
ret->commandline = copy(graph->commandline);
ret->plotname = copy(graph->plotname);
return (ret);
}
afs_int32
SBUDB_SaveText(struct rx_call *call, afs_uint32 lockHandle,
afs_int32 textType, afs_int32 offset, afs_int32 flags,
charListT *charListPtr)
{
afs_int32 code;
code = SaveText(call, lockHandle, textType, offset, flags, charListPtr);
osi_auditU(call, BUDB_SavTxtEvent, code, AUD_LONG, textType, AUD_END);
return code;
}
//------------------------------------------------------------------------------
// Draw a right justfied string
void CMenuItem::DrawRightString (int bIsCurrent, int bTiny, char* s)
{
int w, h, aw;
int w1 = m_rightOffset,
x = m_x,
y = m_y;
fontManager.Current ()->StringSize (s, w, h, aw);
x -= 3;
if (w1 == 0)
w1 = w;
if (RETRO_STYLE)
backgroundManager.Current ()->BlitClipped (CCanvas::Current (), x - w1, y, w1, h, x - w1, y);
SaveText ();
SetText (s);
h = m_x;
m_x = x - w;
DrawHotKeyString (bIsCurrent, bTiny, 0, 0);
RestoreText ();
m_x = h;
}
void TextNodeDemo::Save()
{
//文件已存在，不弹对话框
//文件是新文件，弹对话框
if (FileName.isEmpty())
{
FileName = QFileDialog::getSaveFileName(this, \
QStringLiteral("保存文件"),\
QStringLiteral("D://新建文本文档.txt"), \
QStringLiteral("文本文件(*.txt)"));
}
QFile file(FileName);
if (file.open(QFile::WriteOnly | QFile::Text))
{
QTextStream SaveText(&file);
QString contect = ui.plainTextEdit->toPlainText();
SaveText << contect;
setWindowTitle(FileName+QStringLiteral("记事本"));
}
}
void TextNodeDemo::SaveAs()
{
//
QString file_name = QFileDialog::getSaveFileName(this, QStringLiteral("另保存文件"),\
QStringLiteral("D://新建文本文档.txt"), \
QStringLiteral("文本文件(*.txt))"));
if (!file_name.isEmpty()){
QFile file(file_name);
if (!file.open(QFile::WriteOnly | QFile::Text)){
QMessageBox::critical(this, QStringLiteral("错误"),\
QStringLiteral("不能打开文件"));
return;
}
QTextStream SaveText(&file);
QString contect = ui.plainTextEdit->toPlainText();
SaveText << contect;
setWindowTitle(FileName + QStringLiteral("记事本"));
}
}
/*------------------------------------------------------------------------
Procedure: HandleCommand ID:1
Purpose: Handles all menu commands.
Input:
Output:
Errors:
--------------------------------------------------------------------------
Edit History:
06 Oct 2003 - Chris Watford [email protected]
- Removed entries that crashed OCaml
- Removed useless entries
- Added Save ML and Save Transcript
------------------------------------------------------------------------*/
void HandleCommand(HWND hwnd, WPARAM wParam,LPARAM lParam)
{
char *fname;
int r;
switch(LOWORD(wParam)) {
case IDM_OPEN:
fname = SafeMalloc(512);
if (OpenMlFile(fname,512)) {
char *buf = SafeMalloc(512);
char *p = strrchr(fname,'.');
if (p && !stricmp(p,".ml")) {
wsprintf(buf, "#use \"%s\";;", fname);
AddLineToControl(buf);
}
else if (p && !stricmp(p,".cmo")) {
wsprintf(buf, "#load \"%s\";;", fname);
AddLineToControl(buf);
}
free(buf);
}
free(fname);
break;
case IDM_GC:
AddLineToControl("Gc.full_major();;");
break;
case IDCTRLC:
InterruptOcaml();
break;
case IDM_EDITPASTE:
Add_Clipboard_To_Queue();
break;
case IDM_EDITCOPY:
CopyToClipboard(hwnd);
break;
// updated to save a transcript
case IDM_SAVEAS:
fname = SafeMalloc(512);
if (GetSaveName(fname,512)) {
SaveText(fname);
}
free(fname);
break;
// updated to save an ML file
case IDM_SAVE:
fname = SafeMalloc(512);
if (GetSaveMLName(fname,512))
{
SaveML(fname);
}
free(fname);
break;
// updated to work with new history system
case IDM_HISTORY:
r = CallDlgProc(HistoryDlgProc,IDD_HISTORY);
if (r)
{
AddLineToControl(GetHistoryLine(r-1));
}
break;
case IDM_PRINTSU:
// Removed by Chris Watford
// seems to die
// CallPrintSetup();
break;
case IDM_FONT:
CallChangeFont(hwndMain);
break;
case IDM_COLORTEXT:
ProgramParams.TextColor = CallChangeColor(ProgramParams.TextColor);
ForceRepaint();
break;
case IDM_BACKCOLOR:
BackColor = CallChangeColor(BackColor);
DeleteObject(BackgroundBrush);
BackgroundBrush = CreateSolidBrush(BackColor);
ForceRepaint();
break;
case IDM_EDITUNDO:
Undo(hwnd);
break;
/* Removed, really not very useful in this IDE
case IDM_WINDOWTILE:
SendMessage(hwndMDIClient,WM_MDITILE,0,0);
break;
case IDM_WINDOWCASCADE:
SendMessage(hwndMDIClient,WM_MDICASCADE,0,0);
break;
case IDM_WINDOWICONS:
SendMessage(hwndMDIClient,WM_MDIICONARRANGE,0,0);
break;
*/
case IDM_EXIT:
PostMessage(hwnd,WM_CLOSE,0,0);
break;
case IDM_ABOUT:
CallDlgProc(AboutDlgProc,IDD_ABOUT);
break;
default:
if (LOWORD(wParam) >= IDEDITCONTROL && LOWORD(wParam) < IDEDITCONTROL+5) {
switch (HIWORD(wParam)) {
case EN_ERRSPACE:
ResetText();
break;
}
}
break;
}
}
void CMenuItem::Draw (int bIsCurrent, int bTiny)
{
SetColor (bIsCurrent, bTiny);
if (m_bRebuild) {
Destroy ();
m_bRebuild = 0;
}
switch (m_nType) {
case NM_TYPE_TEXT:
// CCanvas::Current ()->Font () = TEXT_FONT);
// fall through on purpose
case NM_TYPE_MENU:
DrawString (bIsCurrent, bTiny);
break;
case NM_TYPE_SLIDER: {
SaveText ();
if (m_value < m_minValue)
m_value = m_minValue;
else if (m_value > m_maxValue)
m_value = m_maxValue;
sprintf (m_text, "%s\t%s", m_savedText, SLIDER_LEFT);
int l = int (strlen (m_text));
int h = m_maxValue - m_minValue + 1;
memset (m_text + l, SLIDER_MIDDLE [0], h);
m_text [l + h] = SLIDER_RIGHT [0];
m_text [l + h + 1] = '\0';
m_text [m_value + 1 + strlen (m_savedText) + 1] = SLIDER_MARKER [0];
DrawSlider (bIsCurrent, bTiny);
RestoreText ();
}
break;
case NM_TYPE_INPUT_MENU:
if (m_group)
DrawInputBox (m_w, m_x, m_y, m_text, bIsCurrent, bTiny);
else
DrawString (bIsCurrent, bTiny);
break;
case NM_TYPE_INPUT:
DrawInputBox (m_w, m_x, m_y, m_text, bIsCurrent, bTiny);
break;
case NM_TYPE_GAUGE:
DrawGauge (m_w, m_x, m_y, m_value, m_maxValue, bIsCurrent);
break;
case NM_TYPE_CHECK:
DrawString (bIsCurrent, bTiny);
if (m_value)
DrawRightString (bIsCurrent, bTiny, CHECKED_CHECK_BOX);
else
DrawRightString (bIsCurrent, bTiny, NORMAL_CHECK_BOX);
break;
case NM_TYPE_RADIO:
DrawString (bIsCurrent, bTiny);
if (m_value)
DrawRightString (bIsCurrent, bTiny, CHECKED_RADIO_BOX);
else
DrawRightString (bIsCurrent, bTiny, NORMAL_RADIO_BOX);
break;
case NM_TYPE_NUMBER:
char text [20];
m_value = NMCLAMP (m_value, m_minValue, m_maxValue);
DrawString (bIsCurrent, bTiny);
sprintf (text, "%d", m_value);
DrawRightString (bIsCurrent, bTiny, text);
break;
}
}
bool GLSLTool::Assemble(
Engine &engine,
const r::Material &material,
const Shader::Ref &shader,
const r::MaterialInputMappings &mapping,
const Shader::TexCoordMapping &tcMapping,
r::Shader::Pass pass,
AssembleFlags flags,
std::ostream &out
) {
std::stringstream ss;
const bool GLES = (flags & kAssemble_GLES) ? true : false;
if (!(flags&(kAssemble_VertexShader|kAssemble_PixelShader)))
flags |= kAssemble_VertexShader;
bool vertexShader = (flags & kAssemble_VertexShader) ? true : false;
if (!GLES)
ss << "#version 120\r\n";
if (vertexShader) {
ss << "#define VERTEX\r\n";
} else {
ss << "#define FRAGMENT\r\n";
ss << "#define MATERIAL\r\n";
}
switch (shader->precisionMode) {
case Shader::kPrecision_Low:
ss << "#define PFLOAT FIXED\r\n";
ss << "#define PFLOAT2 FIXED2\r\n";
ss << "#define PFLOAT3 FIXED3\r\n";
ss << "#define PFLOAT4 FIXED4\r\n";
ss << "#define PFLOAT4X4 FIXED4X4\r\n";
break;
case Shader::kPrecision_Medium:
ss << "#define PFLOAT HALF\r\n";
ss << "#define PFLOAT2 HALF2\r\n";
ss << "#define PFLOAT3 HALF3\r\n";
ss << "#define PFLOAT4 HALF4\r\n";
ss << "#define PFLOAT4X4 HALF4X4\r\n";
break;
case Shader::kPrecision_High:
ss << "#define PFLOAT FLOAT\r\n";
ss << "#define PFLOAT2 FLOAT2\r\n";
ss << "#define PFLOAT3 FLOAT3\r\n";
ss << "#define PFLOAT4 FLOAT4\r\n";
ss << "#define PFLOAT4X4 FLOAT4X4\r\n";
break;
}
if (pass != r::Shader::kPass_Preview) {
if (material.skinMode == r::Material::kSkinMode_Sprite)
ss << "#define SKIN_SPRITE\r\n";
if (material.skinMode == r::Material::kSkinMode_Billboard)
ss << "#define SKIN_BILLBOARD\r\n";
}
if (shader->MaterialSourceUsage(pass, Shader::kMaterialSource_Color) > 0)
ss << "#define SHADER_COLOR\r\n";
if (shader->MaterialSourceUsage(pass, Shader::kMaterialSource_VertexColor) > 0)
ss << "#define SHADER_VERTEX_COLOR\r\n";
if (shader->MaterialSourceUsage(pass, Shader::kMaterialSource_Vertex) > 0)
ss << "#define SHADER_POSITION\r\n";
if (shader->MaterialSourceUsage(pass, Shader::kMaterialSource_MV) > 0)
ss << "#define SHADER_MV\r\n";
if (shader->MaterialSourceUsage(pass, Shader::kMaterialSource_PRJ) > 0)
ss << "#define SHADER_PRJ\r\n";
if (shader->MaterialSourceUsage(pass, Shader::kMaterialSource_MVP) > 0)
ss << "#define SHADER_MVP\r\n";
if (shader->MaterialSourceUsage(pass, Shader::kMaterialSource_InverseMV) > 0)
ss << "#define SHADER_INVERSE_MV\r\n";
if (shader->MaterialSourceUsage(pass, Shader::kMaterialSource_InverseMVP) > 0)
ss << "#define SHADER_INVERSE_MVP\r\n";
if (shader->MaterialSourceUsage(pass, Shader::kMaterialSource_InversePRJ) > 0)
ss << "#define SHADER_INVERSE_PRJ\r\n";
if (shader->MaterialSourceUsage(pass, Shader::kMaterialSource_PFXVars) > 0)
ss << "#define PFX_VARS\r\n";
if (shader->MaterialSourceUsage(pass, Shader::kMaterialSource_EyeVertex) > 0)
ss << "#define SHADER_EYE_VERTEX\r\n";
int numTextures = 0;
for (int i = 0; i < r::kMaxTextures; ++i) {
if (mapping.textures[i][0] == r::kInvalidMapping)
break; // no more texture bindings
switch (mapping.textures[i][0]) {
case r::kMaterialTextureSource_Texture:
ss << "#define T" << i << "TYPE sampler2D" << "\r\n";
break;
default:
break;
}
switch(shader->SamplerPrecisionMode(i)) {
case Shader::kPrecision_Low:
ss << "#define T" << i << "PRECISION lowp" << "\r\n";
break;
case Shader::kPrecision_Medium:
ss << "#define T" << i << "PRECISION mediump" << "\r\n";
break;
case Shader::kPrecision_High:
ss << "#define T" << i << "PRECISION highp" << "\r\n";
break;
}
++numTextures;
}
if (numTextures > 0)
ss << "#define TEXTURES " << numTextures << "\r\n";
const Shader::IntSet &tcUsage = shader->AttributeUsage(pass, Shader::kMaterialSource_TexCoord);
int numTexCoords = (int)tcUsage.size();
if (numTexCoords > 0) {
// Shaders files can read from r::kMaxTexture unique texture coordinate slots.
// The set of read texcoord registers may be sparse. Additionally the engine only supports
// 2 UV channels in most model data. We do some work here to map the set of read texcoord
// registers onto the smallest possible set:
//
// A tcMod may take an input UV channel and modify it, meaning that texture channel is unique,
// however there are a lot of cases where the tcMod is identity and therefore a texture coordinate
// register in a shader can be mapped to a commmon register.
int numTCMods = 0;
for (int i = 0; i < r::kMaterialTextureSource_MaxIndices; ++i) {
if (mapping.tcMods[i] == r::kInvalidMapping)
break;
++numTCMods;
}
// numTCMods is the number of unique texture coordinates read by the pixel shader.
// (which have to be generated by the vertex shader).
ss << "#define TEXCOORDS " << numTCMods << "\r\n";
RAD_VERIFY(tcUsage.size() == tcMapping.size());
if (vertexShader) {
Shader::IntSet tcInputs;
bool genReflect = false;
bool genProject = false;
for (int i = 0; i < r::kMaterialTextureSource_MaxIndices; ++i) {
if (mapping.tcMods[i] == r::kInvalidMapping)
break;
int tcIndex = (int)mapping.tcMods[i];
tcInputs.insert(material.TCUVIndex(tcIndex));
int tcMod = material.TCModFlags(tcIndex);
if (tcMod & r::Material::kTCModFlag_Rotate)
ss << "#define TEXCOORD" << i << "_ROTATE\r\n";
if (tcMod & r::Material::kTCModFlag_Scale)
ss << "#define TEXCOORD" << i << "_SCALE\r\n";
if (tcMod & r::Material::kTCModFlag_Shift)
ss << "#define TEXCOORD" << i << "_SHIFT\r\n";
if (tcMod & r::Material::kTCModFlag_Scroll)
ss << "#define TEXCOORD" << i << "_SCROLL\r\n";
if (tcMod & r::Material::kTCModFlag_Turb)
ss << "#define TEXCOORD" << i << "_TURB\r\n";
int tcGen = material.TCGen(tcIndex);
if (tcGen == r::Material::kTCGen_EnvMap) {
if (!genReflect) {
genReflect = true;
ss << "#define GENREFLECT\r\n";
}
ss << "#define TEXCOORD" << i << "_GENREFLECT\r\n";
} else if (tcGen == r::Material::kTCGen_Projected) {
if (!genProject) {
genProject = true;
ss << "#define GENPROJECT\r\n";
}
ss << "#define TEXCOORD" << i << "_GENPROJECT\r\n";
}
}
ss << "#define TCINPUTS " << tcInputs.size() << "\r\n";
for (int i = 0; i < r::kMaterialTextureSource_MaxIndices; ++i) {
if (mapping.tcMods[i] == r::kInvalidMapping)
break;
int tcIndex = (int)mapping.tcMods[i];
int uvIndex = material.TCUVIndex(tcIndex);
int ofs = 0;
for (Shader::IntSet::const_iterator it2 = tcInputs.begin(); it2 != tcInputs.end(); ++it2) {
if (uvIndex == *it2)
break;
++ofs;
}
RAD_VERIFY(ofs < (int)tcInputs.size());
ss << "#define TEXCOORD" << i << " tc" << ofs << "\r\n";
}
} else {
// fragment shader inputs used generated tc's, which may have expanded from the
// the vertex shader inputs.
int ofs = 0;
for (Shader::IntSet::const_iterator it = tcUsage.begin(); it != tcUsage.end(); ++it, ++ofs) {
ss << "#define TEXCOORD" << ofs << " tc" << tcMapping[ofs].first << "\r\n";
}
}
}
int numColors = shader->MaterialSourceUsage(pass, Shader::kMaterialSource_Color);
if (numColors > 0)
ss << "#define COLORS " << numColors << "\r\n";
int numSpecularColors = std::max(
shader->MaterialSourceUsage(pass, Shader::kMaterialSource_SpecularColor),
shader->MaterialSourceUsage(pass, Shader::kMaterialSource_SpecularExponent)
);
if (numSpecularColors > 0)
ss << "#define SHADER_SPECULAR_COLORS " << numSpecularColors << "\r\n";
int numLightPos = shader->MaterialSourceUsage(pass, Shader::kMaterialSource_LightPos);
int numLightVec = shader->MaterialSourceUsage(pass, Shader::kMaterialSource_LightVec);
int numLightHalfVec = shader->MaterialSourceUsage(pass, Shader::kMaterialSource_LightHalfVec);
int numLightVertex = shader->MaterialSourceUsage(pass, Shader::kMaterialSource_LightVertex);
int numLightTanVec = shader->MaterialSourceUsage(pass, Shader::kMaterialSource_LightTanVec);
int numLightTanHalfVec = shader->MaterialSourceUsage(pass, Shader::kMaterialSource_LightTanHalfVec);
int numLightDiffuseColor = shader->MaterialSourceUsage(pass, Shader::kMaterialSource_LightDiffuseColor);
int numLightSpecularColor = shader->MaterialSourceUsage(pass, Shader::kMaterialSource_LightSpecularColor);
int numShaderNormals = shader->MaterialSourceUsage(pass, Shader::kMaterialSource_Normal);
int numShaderTangents = shader->MaterialSourceUsage(pass, Shader::kMaterialSource_Tangent);
int numShaderBitangents = shader->MaterialSourceUsage(pass, Shader::kMaterialSource_Bitangent);
int numNormals = numShaderNormals;
int numTangents = numShaderTangents;
int numBitangents = numShaderBitangents;
bool needTangents = vertexShader && (numLightTanVec || numLightTanHalfVec);
if (needTangents) {
numNormals = std::max(1, numShaderNormals);
numTangents = std::max(1, numShaderTangents);
numBitangents = std::max(1, numShaderBitangents);
ss << "#define TANGENT_FRAME" << "\r\n";
}
if (numNormals > 0)
ss << "#define NORMALS " << numNormals << "\r\n";
if (numTangents > 0)
ss << "#define TANGENTS " << numTangents << "\r\n";
if (numBitangents > 0)
ss << "#define BITANGENTS " << numBitangents << "\r\n";
if (numShaderNormals > 0)
ss << "#define NUM_SHADER_NORMALS " << numShaderNormals << "\r\n";
if (numShaderTangents > 0)
ss << "#define NUM_SHADER_TANGENTS " << numShaderTangents << "\r\n";
if (numShaderBitangents > 0)
ss << "#define NUM_SHADER_BITANGENTS " << numShaderBitangents << "\r\n";
int numLights = std::max(
numLightPos,
std::max(
numLightVec,
std::max(
numLightHalfVec,
std::max(
numLightVertex,
std::max(
numLightTanVec,
std::max(
numLightTanHalfVec,
std::max(numLightDiffuseColor, numLightSpecularColor)
)
)
)
)
)
);
if (numLights > 0) {
ss << "#define LIGHTS " << numLights << "\r\n";
if (numLightPos > 0)
ss << "#define SHADER_LIGHT_POS " << numLightPos << "\r\n";
if (numLightVec > 0)
ss << "#define SHADER_LIGHT_VEC " << numLightVec << "\r\n";
if (numLightHalfVec > 0)
ss << "#define SHADER_LIGHT_HALFVEC " << numLightHalfVec << "\r\n";
if (numLightVertex > 0)
ss << "#define SHADER_LIGHT_VERTEXPOS " << numLightVertex << "\r\n";
if (numLightTanVec > 0)
ss << "#define SHADER_LIGHT_TANVEC " << numLightTanVec << "\r\n";
if (numLightTanHalfVec > 0)
ss << "#define SHADER_LIGHT_TANHALFVEC " << numLightTanHalfVec << "\r\n";
if (numLightDiffuseColor > 0)
ss << "#define SHADER_LIGHT_DIFFUSE_COLOR " << numLightDiffuseColor << "\r\n";
if (numLightSpecularColor > 0)
ss << "#define SHADER_LIGHT_SPECULAR_COLOR " << numLightSpecularColor << "\r\n";
}
if (GLES) {
ss << "#define _GLES\r\n";
ss << "#define MOBILE\r\n";
}
if (!Inject(engine, "@r:/Source/Shaders/Nodes/GLSL.c", ss))
return false;
if (!Inject(engine, "@r:/Source/Shaders/Nodes/Common.c", ss))
return false;
if (!Inject(engine, "@r:/Source/Shaders/Nodes/Shader.c", ss))
return false;
std::stringstream ex;
if (!ExpandIncludes(*this, ss, ex))
return false;
if (flags & kAssemble_Optimize) {
String in(ex.str());
glslopt_ctx *glslopt = glslopt_initialize(GLES);
glslopt_shader *opt_shader = glslopt_optimize(
glslopt,
vertexShader ? kGlslOptShaderVertex : kGlslOptShaderFragment,
in.c_str,
0
);
char szPass[32];
sprintf(szPass, "_pass%d", (int)pass);
{
engine.sys->files->CreateDirectory("@r:/Temp/Shaders/Logs");
String path(CStr("@r:/Temp/Shaders/Logs/"));
path += shader->name;
path += szPass;
path += "_unoptimized";
if (vertexShader) {
path += ".vert.glsl";
} else {
path += ".frag.glsl";
}
tools::shader_utils::SaveText(engine, path.c_str, in.c_str);
}
if (!glslopt_get_status(opt_shader)) {
COut(C_Error) << "Error optimizing shader: " << std::endl << in << std::endl << glslopt_get_log(opt_shader) << std::endl;
engine.sys->files->CreateDirectory("@r:/Temp/Shaders/Logs");
String path;
for (int i = 0;; ++i) {
path.PrintfASCII("@r:/Temp/Shaders/Logs/%s_error_%d.log", shader->name.get(), i);
if (!engine.sys->files->FileExists(path.c_str)) {
SaveText(engine, path.c_str, in.c_str);
break;
}
}
glslopt_shader_delete(opt_shader);
glslopt_cleanup(glslopt);
return false;
}
std::stringstream z;
if (GLES) {
switch (shader->precisionMode) {
case Shader::kPrecision_Low:
z << "precision lowp float;\r\n";
break;
case Shader::kPrecision_Medium:
z << "precision mediump float;\r\n";
break;
case Shader::kPrecision_High:
z << "precision highp float;\r\n";
break;
}
}
z << glslopt_get_output(opt_shader);
glslopt_shader_delete(opt_shader);
glslopt_cleanup(glslopt);
Copy(z, out);
{
engine.sys->files->CreateDirectory("@r:/Temp/Shaders/Logs");
String path(CStr("@r:/Temp/Shaders/Logs/"));
path += shader->name;
path += szPass;
path += "_optimized";
if (vertexShader) {
path += ".vert.glsl";
} else {
path += ".frag.glsl";
}
tools::shader_utils::SaveText(engine, path.c_str, z.str().c_str());
}
} else {
Copy(ex, out);
}
return true;
}
BOOL CTxtDropTarget::OnDrop(CWnd* pWnd, COleDataObject* pDataObject,
DROPEFFECT dropEffect, CPoint point)
{
try{
CString strMsg;
//
HGLOBAL hData=pDataObject->GetGlobalData(CF_TEXT);
if (hData)
{
LPCSTR lpcszData=(LPCSTR)GlobalLock(hData);
GlobalUnlock(hData);
//if it is a link
HGLOBAL hLinkData=pDataObject->GetGlobalData(RegisterClipboardFormat("FileGroupDescriptor"));
LPCSTR lpcszLink;
if(hLinkData)
{
lpcszLink=((LPCSTR)GlobalLock(hLinkData)) + 76;
strMsg = lpcszLink;
strMsg = strMsg.Left(strMsg.GetLength()-4);//cut .url of abc.url
strMsg += " => ";
strMsg += lpcszData;
GlobalUnlock(hLinkData);
}
else
strMsg += lpcszData;
strMsg += "\r\n";
SaveText(strMsg, 0);
}
else
{
hData=pDataObject->GetGlobalData(CF_HDROP);
if (!hData)
{
TRACE("Fail in getting data\n");
MSGBOX(IDS_NOT_DROP_IMG);
return FALSE;
}
HDROP hdrop =(HDROP)GlobalLock(hData);
DragQueryFile(hdrop, 0, g_szFile, 1024);
GlobalUnlock(hData);
CString filename, rfile;
filename = g_szFile;
int l = filename.ReverseFind('\\');
filename = filename.Mid(l+1);
//fix filename, remove [x]
l = filename.ReverseFind('[');
int i = filename.ReverseFind(']');
CString ext = filename.Mid(i+1);
filename = filename.Left(l);
//?
CString imgPath = ((CVeryIEApp*)AfxGetApp())->m_strImagePath;
if(pmf->m_bImgCateWithSite)
{
CString site;
CChildFrame* tcf = (CChildFrame*)pmf->MDIGetActive();
site = tcf->m_pView->m_lpszUrl;
pmf->GetSiteName(site);
imgPath = imgPath + site + "\\";
}
//create dir
_CreateFullDir(imgPath);
filename = imgPath + filename;
//compare file size
DWORD sz1=0, sz2=0;
HANDLE hfile = INVALID_HANDLE_VALUE;
hfile = CreateFile(g_szFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if(hfile != INVALID_HANDLE_VALUE)
sz1 = GetFileSize(hfile, NULL);
CloseHandle(hfile);
hfile = INVALID_HANDLE_VALUE;
hfile = CreateFile(filename+ext, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if(hfile != INVALID_HANDLE_VALUE)
sz2 = GetFileSize(hfile, NULL);
CloseHandle(hfile);
rfile = filename + ext;
if (sz1==0)//img not show
{
MSGBOX(IDS_SAVEIMAGEFAIL);
return TRUE;
}
else if (sz1==sz2)//exist the same file
{
LOADSTR(strMsg ,IDS_IMG_EXISTED);
strMsg += rfile;
pmf->SetMessageText(strMsg);//SaveText(strMsg,13);
return TRUE;
}
else if(sz1!=sz2 && sz2!=0)
{
char tmp[4];
l = 0;
HFILE hf; OFSTRUCT of;
hf = OpenFile(rfile, &of, OF_EXIST);
while(hf!=HFILE_ERROR)
{
l++;
rfile = filename;
rfile += '[';
itoa(l, tmp, 10);
rfile += tmp;
rfile += ']';
rfile += ext;
hf = OpenFile(rfile, &of, OF_EXIST);
}
}
//copy files
if(!CopyFile(g_szFile, rfile, FALSE))
{
DWORD dwError = GetLastError();
if(dwError == ERROR_PATH_NOT_FOUND)
MSGBOX(IDS_SAVEIMAGEFAIL);
}
else
{
LOADSTR(strMsg ,IDS_IMG_SAVE_TO);
strMsg += rfile;
//
CChildFrame* tcf = (CChildFrame*)pmf->MDIGetActive();
strMsg += " <= ";
strMsg += tcf->m_pView->m_lpszUrl;
//
SaveText(strMsg,13);
}
}
}catch(...){}
return TRUE;
}
