HRESULT OcxObject::RawInvoke(IRef<ITypeInfo>& typeinfo, IDispatch *dispatch, DISPID dispid, word flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excep, unsigned *arg_err)
{
LOGINVOKE("IDispatch::Invoke");
if(dispid == 0) { // convert object to dispatch value
if(!result) return E_INVALIDARG;
result->vt = VT_DISPATCH;
result->pdispVal = dispatch;
if(dispatch) dispatch->AddRef();
return S_OK;
}
if(!typeinfo) {
LOG("dispid = " << FormatIntHex(dispid) << ": typeinfo = NULL");
return E_FAIL;
}
#if LOG_INVOKES >= 1
BSTR names[1] = { NULL };
unsigned count = 0;
typeinfo->GetNames(dispid, names, 1, &count);
String name;
if(names[0])
name = BSTRToString(names[0]);
else
name = FormatIntHex(dispid);
switch(flags) {
case DISPATCH_METHOD: name << " - method"; break;
case DISPATCH_PROPERTYGET: name << " - propget"; break;
case DISPATCH_PROPERTYPUT: name << " - propput"; break;
case DISPATCH_PROPERTYPUTREF: name << " - propputref"; break;
}
LOG("Member name: " << name);
#endif
if(!typeinfo)
return E_FAIL;
TYPEATTR *attr;
typeinfo->GetTypeAttr(&attr);
LOGINVOKE("GetTypeInfo: typekind = " << (int)attr->typekind);
// HRESULT res = typeinfo->Invoke(dispatch, dispid, flags, params, result, excep, arg_err);
HRESULT res = DispInvoke(dispatch, ~typeinfo, dispid, flags, params, result, excep, arg_err);
if(FAILED(res)) {
RLOG("failure: dispid = " << (int)dispid << ", #args = " << (int)params->cArgs
<< ", #named args = " << (int)params->cNamedArgs << ", return " << FormatIntHex(result));
for(int i = 0; i < (int)params->cArgs; i++) {
RLOG("arg[" << i << "] (vt = " << (int)params->rgvarg[i].vt << "): " << StdFormat(AsValue(params->rgvarg[i])));
}
RLOG("#funcs = " << attr->cFuncs);
for(int i = 0; i < attr->cFuncs; i++) {
FUNCDESC *func;
typeinfo->GetFuncDesc(i, &func);
RLOG("memid = " << func->memid << ", cParams " << func->cParams
<< ", cParamsOpt = " << func->cParamsOpt << ", cScodes " << func->cScodes
<< ", funckind = " << (int)func->funckind << ", invkind " << (int)func->invkind
<< ", flags = " << FormatIntHex(func->wFuncFlags));
typeinfo->ReleaseFuncDesc(func);
}
}
typeinfo->ReleaseTypeAttr(attr);
LOGINVOKE("//IDispatch::Invoke");
return LOGRESULT(res);
}
void CoWork::Finish() {
Pool& p = GetPool();
p.lock.Enter();
while(!jobs.IsEmpty(1)) {
LLOG("Finish: todo: " << todo << " (CoWork " << FormatIntHex(this) << ")");
p.DoJob(*jobs.GetNext(1));
}
while(todo) {
LLOG("WaitForFinish (CoWork " << FormatIntHex(this) << ")");
waitforfinish.Wait(p.lock);
}
p.lock.Leave();
LLOG("CoWork " << FormatIntHex(this) << " finished");
}
void Pdb::MemMenu(ArrayCtrl& array, Bar& bar, const String& exp)
{
if(bar.IsScanKeys())
return;
CParser p(exp);
try {
Val v = Exp(p);
bool sep = true;
if(v.ref > 0) {
if(sep)
bar.Separator();
sep = false;
bar.Add("Memory at " + exp, THISBACK1(MemoryGoto, exp));
}
else
if(v.rvalue) {
if(sep)
bar.Separator();
sep = false;
bar.Add("Memory at 0x" + FormatIntHex((dword)GetInt(v)), THISBACK1(MemoryGoto, "&" + exp));
}
if(!v.rvalue) {
if(sep)
bar.Separator();
sep = false;
bar.Add("Memory at &&" + exp, THISBACK1(MemoryGoto, "&" + exp));
}
}
catch(CParser::Error e) {
}
}
String RichPara::Format::ToString() const
{
String out;
if(!UPP::IsNull(label))
out << "label <" << label << ">: ";
out
<< align << ", left " << lm << ", right " << rm
<< ", indent " << indent << ", before " << before << ", after " << after
<< ", tabsize " << tabsize << ", bullet " << bullet
<< (newpage ? ", newpage" : "")
<< (keep ? ", keep" : "")
<< (keepnext ? ", keepnext" : "")
<< (orphan ? ", orphan" : "");
int i;
for(i = 0; i < tab.GetCount(); i++)
out << (i ? "\n" : ", ")
<< "tab[" << i << "] = " << tab[i].pos << ", align " << tab[i].align
<< ", fill " << FormatIntHex(tab[i].fillchar, 2);
out << "\n";
out << "before_number " << before_number << ", after_number " << after_number
<< (reset_number ? ", reset_number" : "");
for(i = 0; i < __countof(number); i++)
if(number[i] != RichPara::NUMBER_NONE)
out << " num[" << i << "] = " << (int)number[i];
out << "\n";
return out;
}
void TopWindow::Open(HWND hwnd)
{
GuiLock __;
if(dokeys && (!GUI_AKD_Conservative() || GetAccessKeysDeep() <= 1))
DistributeAccessKeys();
UsrLogT(3, "OPEN " + Desc(this));
LLOG("TopWindow::Open, owner HWND = " << FormatIntHex((int)hwnd, 8) << ", Active = " << FormatIntHex((int)::GetActiveWindow(), 8));
IgnoreMouseUp();
SyncCaption();
#ifdef PLATFORM_WINCE
if(!GetRect().IsEmpty())
#endif
if(fullscreen) {
SetRect(GetScreenSize());
Create(hwnd, WS_POPUP, 0, false, SW_SHOWMAXIMIZED, false);
}
else {
CenterRect(hwnd, hwnd && hwnd == GetTrayHWND__() ? center ? 2 : 0 : center);
Create(hwnd, style, exstyle, false, state == OVERLAPPED ? SW_SHOWNORMAL :
state == MINIMIZED ? SW_MINIMIZE :
SW_MAXIMIZE, false);
}
PlaceFocus();
SyncCaption();
FixIcons();
}
void Pdb::RestoreForeground()
{
if(hWnd) {
SetForegroundWindow(hWnd);
LLOG("Restored foreground window: " << FormatIntHex((dword)hWnd));
}
hWnd = NULL;
}
void Pdb::RemoveThread(dword dwThreadId)
{
int q = threads.Find(dwThreadId);
if(q >= 0) {
Thread& f = threads[q];
LLOG("Closing thread " << dwThreadId << ", handle: " << FormatIntHex((dword)(f.hThread)));
CloseHandle(f.hThread);
threads.Remove(q);
}
}
String GetLangIdent(int language)
{
switch(language)
{
#undef LNGITEM
#define LNGITEM(lcode, charset) case lcode: return #lcode;
LNGLIST()
default: return "0x" + FormatIntHex(language, 8);
}
}
int OcxObject::ExternalAddRef()
{
if(outer_unknown) {
int res = outer_unknown->AddRef();
#if LOG_ADDREFS
OCXLOG("OcxObject::ExternalAddRef -> outer(" << FormatIntHex(outer_unknown) << ") -> " << res);
#endif
return res;
}
return InternalAddRef();
}
String Ctrl::Name() const {
GuiLock __;
#ifdef CPU_64
String s = String(typeid(*this).name()) + " : 0x" + FormatIntHex(this);
#else
String s = String(typeid(*this).name()) + " : " + Format("0x%x", (int) this);
#endif
if(IsChild())
s << "(parent " << String(typeid(*parent).name()) << ")";
return s;
}
int OcxObject::ExternalRelease()
{
if(outer_unknown) {
int res = outer_unknown->Release();
#if LOG_ADDREFS
// note: this might have been destructed by this time
OCXLOG("OcxObject::ExternalRelease -> outer(" << FormatIntHex(outer_unknown) << ") -> " << res);
#endif
return res;
}
return InternalRelease();
}
void CoWork::Pool::DoJob(MJob& job)
{
job.UnlinkAll();
LLOG("DoJob (CoWork " << FormatIntHex(job.work) << ")");
finlock = false;
Function<void ()> fn = pick(job.fn);
Free(job);
CoWork *work = job.work;
lock.Leave();
fn();
if(!finlock)
lock.Enter();
if(!work)
return;
if(--work->todo == 0) {
LLOG("Releasing waitforfinish of (CoWork " << FormatIntHex(work) << ")");
work->waitforfinish.Signal();
}
LLOG("DoJobA, todo: " << work->todo << " (CoWork " << FormatIntHex(work) << ")");
ASSERT(work->todo >= 0);
LLOG("Finished, remaining todo " << work->todo);
}
void Draw::SetColor(Color color)
{
DrawLock __;
LLOG("SetColor " << color);
if(color != lastColor) {
LLOG("Setting, lastColor:" << FormatIntHex(lastColor.GetRaw())
<< " color:" << FormatIntHex(color.GetRaw()) <<
" GetColor:" << FormatIntHex(GetColor(color)) << " palette:" << palette);
HBRUSH oldBrush = actBrush;
HBRUSH h;
if(!IsNull(color))
h = (HBRUSH) SelectObject(handle, actBrush = CreateSolidBrush(GetColor(color)));
else {
HGDIOBJ empty = GetStockObject(HOLLOW_BRUSH);
h = (HBRUSH) SelectObject(handle, empty);
actBrush = NULL;
}
ASSERT(h);
if(!orgBrush) orgBrush = h;
if(oldBrush) DeleteObject(oldBrush);
lastColor = color;
}
}
bool Ctrl::SetFocus0(bool activate)
{
GuiLock __;
USRLOG(" SETFOCUS " << Desc(this));
LLOG("Ctrl::SetFocus " << Desc(this));
LLOG("focusCtrlWnd " << UPP::Name(focusCtrlWnd));
LLOG("Ctrl::SetFocus0 -> deferredSetFocus = NULL; was: " << UPP::Name(defferedSetFocus));
defferedSetFocus = NULL;
if(focusCtrl == this) return true;
if(!IsOpen() || !IsEnabled() || !IsVisible()) return false;
Ptr<Ctrl> pfocusCtrl = focusCtrl;
Ptr<Ctrl> topwindow = GetTopWindow();
Ptr<Ctrl> topctrl = GetTopCtrl();
Ptr<Ctrl> _this = this;
if(!topwindow) topwindow = topctrl;
LLOG("SetFocus -> SetWndFocus: topwindow = " << UPP::Name(topwindow) << ", focusCtrlWnd = " << UPP::Name(focusCtrlWnd));
if(!topwindow->HasWndFocus() && !topwindow->SetWndFocus()) return false;// cxl 31.1.2004
#ifdef PLATFORM_OSX11 // ugly temporary hack - popups not behaving right in MacOS
// before 2012-9-2 was #ifdef GUI_X11, but that caused issues in most linux distros (cxl)
// as parent window of popup always manages focus/keyboard for popup in X11
if(activate) // Dolik/fudadmin 2011-5-1
topctrl->SetWndForeground();
#else
topwindow->SetWndForeground(); // cxl 2007-4-27
#endif
LLOG("SetFocus -> focusCtrl = this: " << FormatIntHex(this) << ", _this = " << FormatIntHex(~_this) << ", " << UPP::Name(_this));
focusCtrl = _this;
focusCtrlWnd = topwindow;
DoKillFocus(pfocusCtrl, _this);
LLOG("SetFocus 2");
DoDeactivate(pfocusCtrl, _this);
DoSetFocus(pfocusCtrl, _this, activate);
if(topwindow)
lastActiveWnd = topwindow;
return true;
}
Ctrl *Ctrl::GetActiveCtrl()
{
GuiLock __;
if(focusCtrl)
return focusCtrl->GetTopCtrl();
HWND actwnd = ::GetActiveWindow();
Vector<Ctrl *> top = GetTopCtrls();
for(int i = 0; i < top.GetCount(); i++)
if(top[i]->IsActiveX() && top[i]->GetHWND()) {
LLOG("-> top[" << i << "] = " << FormatIntHex(top[i]->GetHWND()));
for(HWND hwnd = top[i]->GetHWND(); hwnd; hwnd = ::GetParent(hwnd))
if(hwnd == actwnd) {
LLOG("-> match for " <<UPP::Name(top[i]));
return top[i];
}
}
LLOG("//Ctrl::GetActiveCtrl -> not found (NULL)");
return NULL;
}
void PosOverrunTest()
{
String tmpfile = GetTempFileName("pos");
FileOut fo;
if(!fo.Open(tmpfile)) {
Cout() << "PosOverrunTest: error creating file " << tmpfile << "\n";
return;
}
for(int i = 0; i < 0x10000; i++)
fo.PutIW(i);
int64 size = fo.GetSize();
fo.Close();
if(fo.IsError() || size != 0x20000) {
Cout() << "PosOverrunTest generator error, file " << tmpfile << "\n";
return;
}
FileIn fi;
fi.SetBufferSize(4096);
if(!fi.Open(tmpfile)) {
Cout() << "PosOverrunTest: error reopening temporary file " << tmpfile << "\n";
return;
}
for(int i = 0; i < 4096; i++)
fi.Get();
char buffer[32];
fi.GetAll(buffer, 32);
bool ok = true;
for(int i = 0; i < 16; i++) {
int strmval = PeekIW(buffer + 2 * i);
int expect = 2048 + i;
if(strmval != expect) {
Cout() << "PosOverrunTest: " << FormatIntHex(expect, 4) << " expected, " << FormatIntHex(strmval, 4) << " found\n";
ok = false;
}
}
if(ok)
Cout() << "PosOverrunTest: finished without errors\n";
}
CoWork::~CoWork()
{
Finish();
LLOG("~CoWork " << FormatIntHex(this));
}
bool Pdb::RunToException()
{
DR_LOG("RunToException");
LLOG("RUN TO EXCEPTION");
TimeStop ts;
bool disasfocus = disas.HasFocus();
bool locked = false;
bool frestored = false;
invalidpage.Clear();
mempage.Clear();
int opn = 0;
for(;;) {
if(terminated) {
if(locked)
Unlock();
return false;
}
opn++;
DR_LOG("WaitForDebugEvent");
if(WaitForDebugEvent(&event, 0)) {
DR_LOG("WaitForDebugEvent ended");
debug_threadid = event.dwThreadId;
opn = 0;
running = false;
switch(event.dwDebugEventCode) {
case EXCEPTION_DEBUG_EVENT: {
DR_LOG("EXCEPTION_DEBUG_EVENT");
LLOG("Exception: " << FormatIntHex(event.u.Exception.ExceptionRecord.ExceptionCode) <<
" at: " << FormatIntHex(event.u.Exception.ExceptionRecord.ExceptionAddress) <<
" first: " << event.u.Exception.dwFirstChance);
SaveForeground();
const EXCEPTION_RECORD& x = event.u.Exception.ExceptionRecord;
if(findarg(x.ExceptionCode, EXCEPTION_BREAKPOINT, EXCEPTION_SINGLE_STEP,
STATUS_WX86_BREAKPOINT, STATUS_WX86_SINGLE_STEP) < 0)
{
LLOG("Non-debug EXCEPTION");
if(event.u.Exception.dwFirstChance) {
LLOG("First chance " << FormatIntHex(x.ExceptionCode));
break;
}
String desc = Format("Exception: [* %lX] at [* %16llX]&",
(int64)x.ExceptionCode, (int64)x.ExceptionAddress);
for(int i = 0; i < __countof(ex_desc); i++)
if(ex_desc[i].code == x.ExceptionCode)
desc << "[* " << DeQtf(ex_desc[i].text) << "]&";
if(x.ExceptionCode == EXCEPTION_ACCESS_VIOLATION) {
desc << (x.ExceptionInformation[0] ? "[*@3 writing]" : "[*@4 reading]");
desc << Format(" at [* %08llX]", (int64)x.ExceptionInformation[1]);
}
ToForeground();
PromptOK(desc);
}
#ifdef CPU_64
if(!win64 && x.ExceptionCode == EXCEPTION_BREAKPOINT && !break_running) // Ignore x64 breakpoint in wow64
break;
#endif
if(break_running)
debug_threadid = mainThreadId;
break_running = false;
ToForeground();
if(disasfocus)
disas.SetFocus();
if(locked)
Unlock();
if(refreshmodules)
LoadModuleInfo();
LLOG("event.dwThreadId = " << event.dwThreadId);
bool isbreakpoint = findarg(x.ExceptionCode, EXCEPTION_BREAKPOINT, STATUS_WX86_BREAKPOINT) >= 0;
for(int i = 0; i < threads.GetCount(); i++) {
Thread& t = threads[i];
(Context&)t = ReadContext(threads[i].hThread);
if(event.dwThreadId == threads.GetKey(i)) {
LLOG("Setting current context");
if(isbreakpoint
#ifdef CPU_64
&& bp_set.Find((win64 ? t.context64.Rip : t.context32.Eip) - 1) >= 0
#else
&& bp_set.Find(t.context32.Eip - 1) >= 0
#endif
) // We have stopped at breakpoint, need to move address back
#ifdef CPU_64
if(win64)
t.context64.Rip--;
else
#endif
t.context32.Eip--;
context = t;
}
}
RemoveBp();
return true;
}
case CREATE_THREAD_DEBUG_EVENT:
DR_LOG("CREATE_THREAD_DEBUG_EVENT");
LLOG("Create thread: " << event.dwThreadId);
AddThread(event.dwThreadId, event.u.CreateThread.hThread);
break;
case EXIT_THREAD_DEBUG_EVENT:
DR_LOG("EXIT_THREAD_DEBUG_EVENT");
LLOG("Exit thread: " << event.dwThreadId);
RemoveThread(event.dwThreadId);
break;
case CREATE_PROCESS_DEBUG_EVENT:
DR_LOG("CREATE_PROCESS_DEBUG_EVENT");
LLOG("Create process: " << event.dwProcessId);
processid = event.dwProcessId;
AddThread(event.dwThreadId, event.u.CreateProcessInfo.hThread);
CloseHandle(event.u.CreateProcessInfo.hFile);
CloseHandle(event.u.CreateProcessInfo.hProcess);
break;
case EXIT_PROCESS_DEBUG_EVENT:
DR_LOG("EXIT_PROCESS_DEBUG_EVENT");
LLOG("Exit process: " << event.dwProcessId);
if(locked)
Unlock();
terminated = true;
return false;
case LOAD_DLL_DEBUG_EVENT: {
DR_LOG("LOAD_DLL_DEBUG_EVENT");
LLOG("Load dll: " << event.u.LoadDll.lpBaseOfDll);
CloseHandle(event.u.LoadDll.hFile);
refreshmodules = true;
break;
}
case UNLOAD_DLL_DEBUG_EVENT:
DR_LOG("UNLOAD_DLL_DEBUG_EVENT");
LLOG("UnLoad dll: " << event.u.UnloadDll.lpBaseOfDll);
refreshmodules = true;
break;
case RIP_EVENT:
DR_LOG("RIP_EVENT");
LLOG("RIP!");
Exclamation("Process being debugged died unexpectedly!");
terminated = true;
if(locked)
Unlock();
return false;
}
DR_LOG("ContinueDebugEvent");
ContinueDebugEvent(event.dwProcessId, event.dwThreadId, DBG_EXCEPTION_NOT_HANDLED);
running = true;
}
if(ts.Elapsed() > 200) {
DR_LOG("ts.Elpsed() > 200");
if(!lock) {
Lock();
locked = true;
}
if(!frestored) {
RestoreForeground();
frestored = true;
}
}
if(lock) {
DR_LOG("GuiSleep");
GuiSleep(opn < 1000 ? 0 : 100);
Ctrl::ProcessEvents();
}
else {
DR_LOG("Sleep");
Sleep(opn < 1000 ? 0 : 100);
}
}
}
void Ctrl::EventProc(XWindow& w, XEvent *event)
{
GuiLock __;
eventid++;
Ptr<Ctrl> _this = this;
bool pressed = false;
int count = 1;
switch(event->type) {
case NoExpose:
LLOG("NoExpose serial " << event->xnoexpose.serial);
break;
case GraphicsExpose:
LLOG("GraphicsExpose serial " << event->xgraphicsexpose.serial);
case Expose: {
XExposeEvent& e = event->xexpose;
w.exposed = true;
LLOG("Expose " << RectC(e.x, e.y, e.width, e.height));
Invalidate(w, RectC(e.x, e.y, e.width, e.height));
}
return;
case ConfigureNotify: {
XConfigureEvent& e = event->xconfigure;
int x, y;
Window dummy;
// 01/12/2007 - mdelfede
// added support for windowed controls
// if(top)
// XTranslateCoordinates(Xdisplay, top->window, Xroot, 0, 0, &x, &y, &dummy);
if(top) {
Window DestW = (parent ? GetParentWindow() : Xroot);
XTranslateCoordinates(Xdisplay, top->window, DestW, 0, 0, &x, &y, &dummy);
Rect rect = RectC(x, y, e.width, e.height);
LLOG("CongigureNotify " << rect);
if(GetRect() != rect)
SetWndRect(rect);
// Synchronizes native windows (NOT the main one)
}
SyncNativeWindows();
// 01/12/2007 - END
}
return;
default:
if(!IsEnabled()) return;
}
LTIMING("XUserInput");
switch(event->type) {
case FocusIn:
if(w.xic)
XSetICFocus(w.xic);
break;
case FocusOut:
if(w.xic)
XUnsetICFocus(w.xic);
break;
case KeyPress:
pressed = true;
LLOG("event type:" << event->type << " state:" << event->xkey.state <<
"keycode:" << event->xkey.keycode);
for(;;) {
XEvent ev1[1], ev2[1];
bool hasev2 = false;
if(!IsWaitingEvent()) break;
do
XNextEvent(Xdisplay, ev1);
while(ev1->type == NoExpose && IsWaitingEvent());
LLOG("ev1 type:" << ev1->type << " state:" << ev1->xkey.state <<
"keycode:" << ev1->xkey.keycode);
if(ev1->type == KeyPress)
*ev2 = *ev1;
else {
if(ev1->type != KeyRelease ||
ev1->xkey.state != event->xkey.state ||
ev1->xkey.keycode != event->xkey.keycode ||
!IsWaitingEvent()) {
XPutBackEvent(Xdisplay, ev1);
break;
}
do
XNextEvent(Xdisplay, ev2);
while(ev2->type == NoExpose && IsWaitingEvent());
LLOG("ev2 type:" << ev2->type << " state:" << ev2->xkey.state <<
"keycode:" << ev2->xkey.keycode);
hasev2 = true;
}
if(ev2->type != KeyPress ||
ev2->xkey.state != event->xkey.state ||
ev2->xkey.keycode != event->xkey.keycode) {
if(hasev2)
XPutBackEvent(Xdisplay, ev2);
XPutBackEvent(Xdisplay, ev1);
break;
}
else {
XFilterEvent(ev1, None);
if(hasev2)
XFilterEvent(ev2, None);
}
count++;
}
case KeyRelease: {
mousePos = Point(event->xkey.x_root, event->xkey.y_root);
char buff[128];
Xeventtime = event->xkey.time;
LLOG("Key Xeventtime: " << Xeventtime << " count:" << count);
KeySym keysym;
int chr = 0;
WString wtext;
if(pressed && w.xic) {
Status status;
int len = Xutf8LookupString(w.xic, &event->xkey, buff, sizeof(buff), &keysym, &status);
buff[len] = 0;
if(status == XLookupChars || status == XLookupBoth) {
chr = FromUtf8(buff, len)[0];
if(status == XLookupChars)
wtext = FromUtf8(buff, len);
}
else
if(status != XLookupKeySym && status != XLookupBoth)
keysym = 0;
}
else {
int len = XLookupString(&event->xkey, buff, sizeof(buff), &keysym, NULL);
buff[len] = 0;
chr = FromUtf8(buff, len)[0];
if(len > 1)
wtext = FromUtf8(buff, len);
}
if(keysym == XK_Control_L || keysym == XK_Control_R) {
keysym = XK_Control_L;
if(pressed)
sKbdState |= ControlMask;
else
sKbdState &= ~ControlMask;
}
if(keysym == XK_Shift_L || keysym == XK_Shift_R) {
keysym = XK_Shift_L;
if(pressed)
sKbdState |= ShiftMask;
else
sKbdState &= ~ShiftMask;
}
if(keysym == XK_Meta_L || keysym == XK_Meta_R || keysym == XK_Alt_L ||
keysym == XK_Alt_R || keysym == XK_Super_L || keysym == XK_Super_R ||
keysym == XK_Hyper_L || keysym == XK_Hyper_R || keysym == XK_ISO_Prev_Group) {
keysym = XK_Meta_L;
if(pressed)
sKbdState |= Mod1Mask;
else
sKbdState &= ~Mod1Mask;
}
LLOG("KeySym:" << FormatIntHex(keysym) << " " << (char)keysym << " " << count);
dword up = pressed ? 0 : K_KEYUP;
static struct { KeySym keysym; dword key; } tab[] = {
{ XK_ISO_Left_Tab, K_TAB|K_SHIFT },
{ XK_BackSpace, K_BACKSPACE },
{ XK_Tab, K_TAB },
{ XK_Return, K_ENTER },
{ XK_KP_Enter, K_ENTER },
{ XK_Escape, K_ESCAPE },
{ XK_space, K_SPACE },
{ XK_KP_Space, K_SPACE },
{ XK_KP_Tab, K_TAB },
{ XK_KP_Enter, K_ENTER },
{ XK_KP_F1, K_F1 },
{ XK_KP_F2, K_F2 },
{ XK_KP_F3, K_F3 },
{ XK_KP_F4, K_F4 },
{ XK_KP_Home, K_HOME },
{ XK_KP_Left, K_LEFT },
{ XK_KP_Up, K_UP },
{ XK_KP_Right, K_RIGHT },
{ XK_KP_Down, K_DOWN },
{ XK_KP_Page_Up, K_PAGEUP },
{ XK_KP_Page_Down, K_PAGEDOWN },
{ XK_KP_End, K_END },
{ XK_KP_Begin, K_HOME },
{ XK_KP_Insert, K_INSERT },
{ XK_KP_Delete, K_DELETE },
};
for(int i = 0; i < __countof(tab); i++)
if(tab[i].keysym == keysym) {
DispatchKey(KEYtoK(tab[i].key)|up, count);
return;
}
if(GetShift() && chr == 0) {
static dword k[] = { 41, 33, 64, 35, 36, 37, 94, 38, 42, 40 };
for(int i = 0; i < 10; i++)
if(keysym == k[i]) {
DispatchKey(KEYtoK(i + K_0)|up, count);
return;
}
}
if(keysym >= 48 && keysym <= 57 && chr == 0) {
DispatchKey(KEYtoK(keysym - 48 + K_0)|up, count);
return;
}
if(chr >= 1 && chr < 32) {
DispatchKey(KEYtoK(chr - 1 + K_CTRL_A)|up, count);
return;
}
if(keysym >= 0xff80 && keysym <= 0xffb9 && chr) {
DispatchKey(KEYtoK(chr)|up, count);
return;
}
if(keysym >= 0xff00 && chr < 128 ||
(GetCtrl() || GetAlt()) && keysym >= 0x20 && keysym < 0x7f) {
if(keysym >= 'a' && keysym <= 'z')
keysym = keysym - 'a' + 'A';
DispatchKey(KEYtoK(keysym|K_DELTA)|up, count);
return;
}
if((chr == 32 || chr == 9 || chr == 13) && !pressed)
DispatchKey(chr|K_KEYUP, count);
if(chr && pressed) {
DispatchKey(chr, count);
for(int ii = 1; ii < wtext.GetLength(); ii++)
DispatchKey(wtext[ii], count);
}
}
break;
case ButtonPress: {
if(!HasWndFocus() && !popup)
SetWndFocus();
ClickActivateWnd();
mousePos = Point(event->xbutton.x_root, event->xbutton.y_root);
ReleaseGrab();
XButtonEvent& e = event->xbutton;
sModState = e.state;
Xeventtime = e.time;
if(ignoreclick) break;
Point p = Point(e.x, e.y);
dword action = DOWN;
if((dword)e.time - (dword)Xbuttontime < 800) {
action = DOUBLE;
Xbuttontime = Xeventtime - 0x80000000;
}
else {
Xbuttontime = e.time;
Xbuttonpos = mousePos;
}
switch(e.button) {
case Button1:
sModState |= Button1Mask;
DispatchMouse(LEFT|action, p, 0);
break;
case Button2:
sModState |= Button2Mask;
if(Xbuttons < 3)
DispatchMouse(RIGHT|action, p, 0);
else
DispatchMouse(MIDDLE|action, p, 0);
break;
case Button3:
sModState |= Button3Mask;
DispatchMouse(RIGHT|action, p, 0);
break;
}
if(_this) PostInput();
}
break;
case ButtonRelease: {
mousePos = Point(event->xbutton.x_root, event->xbutton.y_root);
XButtonEvent& e = event->xbutton;
sModState = e.state;
Xeventtime = e.time;
Point p = Point(e.x, e.y);
switch(e.button) {
case Button1:
sModState &= ~Button1Mask;
break;
case Button2:
sModState &= ~Button2Mask;
break;
case Button3:
sModState &= ~Button3Mask;
break;
}
if(ignoreclick)
EndIgnore();
else
switch(e.button) {
case Button1:
DispatchMouse(LEFTUP, p, 0);
break;
case Button2:
if(Xbuttons < 3)
DispatchMouse(RIGHTUP, p, 0);
else
DispatchMouse(MIDDLEUP, p, 0);
break;
case Button3:
DispatchMouse(RIGHTUP, p, 0);
break;
case Button4:
DispatchMouse(MOUSEWHEEL, p, 120);
break;
case Button5:
DispatchMouse(MOUSEWHEEL, p, -120);
break;
}
if(_this) PostInput();
}
break;
case MotionNotify:
while(XCheckWindowEvent(Xdisplay, top->window, PointerMotionMask, event));
EndIgnore();
mousePos = Point(event->xmotion.x_root, event->xmotion.y_root);
Xeventtime = event->xmotion.time;
Point p = mousePos - Xbuttonpos;
if(max(abs(p.x), abs(p.y)) > 4)
Xbuttontime = Xeventtime - 0x80000000;
sModState = event->xmotion.state;
DispatchMouse(MOUSEMOVE, Point(event->xmotion.x, event->xmotion.y));
DoCursorShape();
break;
}
DropEvent(w, event);
}
static String ThreadId()
{
return String().Cat() << "[T" << FormatIntHex(GetCurrentThreadId()) << "]";
}
void Pdb::AddThread(dword dwThreadId, HANDLE hThread)
{
if(threads.Find(dwThreadId) >= 0)
return;
DR_LOG("AddThread");
Thread& f = threads.GetAdd(dwThreadId);
// Retrive "base-level" stack-pointer, to have limit for stackwalks:
Context c = ReadContext(hThread);
#ifdef CPU_64
f.sp = win64 ? c.context64.Rsp : c.context32.Esp;
#else
f.sp = c.context32.Esp;
#endif
f.hThread = hThread;
LLOG("Adding thread " << dwThreadId << ", Thread SP: " << Hex(f.sp) << ", handle: " << FormatIntHex((dword)(hThread)));
}
bool Ctrl::DispatchKey(dword keycode, int count)
{
GuiLock __;
if(GUI_AltAccessKeys()) {
bool alt = GetAlt();
Ctrl *c = GetActiveCtrl();
if(c)
c->RefreshAccessKeysDo(alt);
}
// RLOGBLOCK("Ctrl::DispatchKey");
// RLOG("DispatchKey: focusCtrl = " << FormatIntHex((int)~focusCtrl) << ", wnd = " << FormatIntHex((int)~focusCtrlWnd) << ")");
LLOG("DispatchKey " << keycode << " (0x" << Sprintf("%08x", keycode)
<< ", " << GetKeyDesc(keycode) << "), count:" << count
<< " focusCtrl:" << UPP::Name(focusCtrl) << " focusCtrlWnd:" << UPP::Name(focusCtrlWnd));
if((keycode & K_KEYUP) && ignorekeyup)
{
ignorekeyup = false;
return true;
}
for(int i = 0; i < keyhook().GetCount(); i++)
if((*keyhook()[i])(focusCtrl, keycode, count))
return true;
dword k = keycode;
word l = LOWORD(keycode);
if(!(k & K_DELTA) && l >= 32 && l != 127 && GetDefaultCharset() != CHARSET_UNICODE)
k = MAKELONG((word)FromUnicode(l, CHARSET_DEFAULT), HIWORD(keycode));
if(!focusCtrl)
return false;
Ptr<Ctrl> p = focusCtrl;
if(Ini::user_log) {
String kl;
dword k = keycode;
const char *l = "";
if(k < 65536) {
kl << "CHAR \'" << ToUtf8((wchar)keycode) << "\' (" << keycode << ')';
l = " ";
}
else {
kl << "KEY";
if(k & K_KEYUP) {
kl << "UP";
k &= ~K_KEYUP;
l = " ";
}
kl << " " << GetKeyDesc(k);
}
USRLOG(l << kl);
}
for(;;) {
LLOG("Trying to DispatchKey: p = " << Desc(p));
if(p->IsEnabled() && p->Key(p->unicode ? keycode : k, count))
{
LLOG("Ctrl::DispatchKey(" << FormatIntHex(keycode) << ", " << GetKeyDesc(keycode)
<< "): eaten in " << Desc(p));
if(Ini::user_log)
USRLOG(" -> " << Desc(p));
eventCtrl = focusCtrl;
return true;
}
s_hotkey = true;
if(!p->GetParent()) {
if(p->HotKey(keycode)) {
eventCtrl = focusCtrl;
return true;
}
return false;
}
p = p->GetParent();
}
USRLOG(" key was ignored");
return false;
}
void FontDB::Perform()
{
Progress pi("Scanning fonts");
OpenMain();
pi.SetTotal(Font::GetFaceCount());
for(int face = 0; face < Font::GetFaceCount(); face++) {
fclass.Add(ClassifyFontFace(face));
}
for(int face = 0; face < Font::GetFaceCount(); face++) {
if(pi.StepCanceled())
return;
Font fnt(face, 100);
if(fnt.IsScaleable() && fnt.IsUnicode()) {
pi.SetText(fnt.GetFaceName());
Image I = LetterImg('I', fnt);
Image V = LetterImg('V', fnt);
int density = 0;
int complexity = 0;
byte cc = 0;
for(const RGBA *s = I; s < ~I + I.GetLength(); s++) {
if(s->r == 0)
density++;
if(s->r != cc) {
cc = s->r;
complexity++;
}
}
for(const RGBA *s = V; s < ~V + V.GetLength(); s++) {
if(s->r != cc) {
cc = s->r;
complexity++;
}
}
int thickness = 0;
for(const RGBA *s = V[45]; s < V[45] + 100; s++) {
if(s->r == 0)
thickness++;
}
int ithickness = 0;
for(const RGBA *s = I[45]; s < I[45] + 100; s++) {
if(s->r == 0)
ithickness++;
}
int vserif = 0;
int iserif = 0;
for(int i = 0; i < 100; i++) {
int v = 0;
int w = 0;
for(const RGBA *s = V[i]; s < V[i] + 100; s++) {
if(s->r == 0)
v++;
}
for(const RGBA *s = I[i]; s < I[i] + 100; s++) {
if(s->r == 0)
w++;
}
vserif = max(vserif, v);
iserif = max(iserif, w);
}
dword lower = 0;
dword all = 0;
#if 0
Progress pi(fnt.GetFaceName() << " glyphs");
pi.SetTotal(65536);
for(int i = 0; i < 65536;) {
if(pi.SetPosCanceled(i)) {
Execute();
return;
}
if(fnt.IsNormal(i)) {
if(i < 8192)
lower |= 1 << (i / 256);
all |= 1 << (i / 2048);
i = (i + 256) & 0xffff00;
}
else
i++;
}
#endif
vserif -= thickness;
iserif -= ithickness;
vserif = 15 * minmax(vserif, 0, 40) / 40;
iserif = 15 * minmax(iserif, 0, 20) / 20;
density = 15 * minmax(density, 0, 2000) / 2000;
thickness = 15 * minmax(thickness - ithickness, 0, 20) / 20;
ithickness = 15 * minmax(ithickness, 0, 60) / 60;
complexity = 15 * minmax(complexity - 600, 0, 600) / 600;
int vw = 15 * minmax(fnt['V'], 0, 100) / 100;
int qc = ClassifyFontFace(face);
int q = 0;
int min = INT_MAX;
for(int i = 0; i < fclass.GetCount(); i++) {
dword w = Font::GetFaceInfo(i);
if((w & Font::SCALEABLE) && !(w & Font::LOCAL) && i != face && (w & Font::FIXEDPITCH) == fnt.IsFixedPitch()) {
int d = FontClassDistance(qc, fclass[i]);
if(d < min) {
q = i;
min = d;
}
}
}
list.Add(fnt.GetFaceName(), Rescale(I, 40, 40), Rescale(V, 40, 40),
density, complexity, thickness, ithickness, vserif, iserif, vw,
FormatIntHex(qc), Font::GetFaceName(q),
FormatBin(lower), FormatBin(all));
}
}
pi.Close();
Execute();
}
HRESULT OcxObject::ExternalQueryInterface(const GUID& iid, void **ppv)
{
if(outer_unknown) {
HRESULT hr = outer_unknown->QueryInterface(iid, ppv);
#if LOG_QUERIES >= 2
OCXLOG("OcxObject::ExternalQueryInterface(" << GetInterfaceName(iid) << ") -> outer(" << FormatIntHex(outer_unknown) << ") -> " << FormatIntHex(hr));
#endif
return hr;
}
return InternalQueryInterface(iid, ppv);
}
void Ctrl::Proc()
{
#ifdef LOG_EVENTS
String ev = "?";
Tuple2<int, const char *> *f = FindTuple(xEvent, __countof(xEvent), CurrentEvent.type);
if(f)
ev = f->b;
LOG(rmsecs() << " PROCESS EVENT " << Upp::Name(this) << " " << ev);
ProcStop tm;
tm.ev = ev;
#endif
if(!IsOpen())
return;
Ptr<Ctrl> _this = this;
bool pressed = false;
int kv;
static int clicktime = msecs() - 100000;
switch(CurrentEvent.type) {
case GDK_MOTION_NOTIFY: {
GtkMouseEvent(MOUSEMOVE, MOUSEMOVE, 0);
break;
}
case GDK_BUTTON_PRESS:
if(!HasWndFocus() && !popup)
SetWndFocus();
ClickActivateWnd();
if(ignoremouseup) {
KillRepeat();
ignoreclick = false;
ignoremouseup = false;
}
if(!ignoreclick)
GtkButtonEvent(msecs(clicktime) < 250 ? DOUBLE : DOWN);
clicktime = msecs();
break;
/* case GDK_2BUTTON_PRESS:
if(!ignoreclick)
GtkButtonEvent(DOUBLE);
break;
*/ case GDK_BUTTON_RELEASE:
if(ignoreclick)
EndIgnore();
else
GtkButtonEvent(UP);
break;
case GDK_SCROLL: {
GtkMouseEvent(MOUSEWHEEL, MOUSEWHEEL, CurrentEvent.value);
break;
}
case GDK_KEY_PRESS:
pressed = true;
case GDK_KEY_RELEASE:
kv = CurrentEvent.value;
if(kv >= 0 && kv < 65536) {
LLOG("keyval " << FormatIntHex(kv) << ' ' << (char)kv);
if(kv >= 'a' && kv <= 'z')
kv = kv - 'a' + 'A';
static Tuple2<int, int> cv[] = {
{ GDKEY(BackSpace), K_BACKSPACE },
{ GDKEY(Tab), K_TAB },
{ GDKEY(ISO_Left_Tab), K_TAB },
{ GDKEY(Return), K_ENTER },
{ GDKEY(Escape), K_ESCAPE },
{ GDKEY(space), K_SPACE },
{ GDKEY(Control_L), K_CTRL_KEY },
{ GDKEY(Control_R), K_CTRL_KEY },
{ GDKEY(Shift_L), K_SHIFT_KEY },
{ GDKEY(Shift_R), K_SHIFT_KEY },
{ GDKEY(Alt_L), K_ALT_KEY },
{ GDKEY(Alt_R), K_ALT_KEY },
{ GDKEY(KP_Space), K_SPACE },
{ GDKEY(KP_Tab), K_TAB },
{ GDKEY(KP_Enter), K_ENTER },
{ GDKEY(KP_F1), K_F1 },
{ GDKEY(KP_F2), K_F2 },
{ GDKEY(KP_F3), K_F3 },
{ GDKEY(KP_F4), K_F4 },
{ GDKEY(KP_Home), K_HOME },
{ GDKEY(KP_Left), K_LEFT },
{ GDKEY(KP_Up), K_UP },
{ GDKEY(KP_Right), K_RIGHT },
{ GDKEY(KP_Down), K_DOWN },
{ GDKEY(KP_Page_Up), K_PAGEUP },
{ GDKEY(KP_Page_Down), K_PAGEDOWN },
{ GDKEY(KP_End), K_END },
{ GDKEY(KP_Begin), K_HOME },
{ GDKEY(KP_Insert), K_INSERT },
{ GDKEY(KP_Delete), K_DELETE },
};
Tuple2<int, int> *x = FindTuple(cv, __countof(cv), kv);
if(x)
kv = x->b;
else
kv += K_DELTA;
if(GetShift() && kv != K_SHIFT_KEY)
kv |= K_SHIFT;
if(GetCtrl() && kv != K_CTRL_KEY)
kv |= K_CTRL;
if(GetAlt() && kv != K_ALT_KEY)
kv |= K_ALT;
LLOG(GetKeyDesc(kv) << ", pressed: " << pressed << ", count: " << CurrentEvent.count);
#ifdef GDK_WINDOWING_X11
if(pressed)
for(int i = 0; i < hotkey.GetCount(); i++) {
if(hotkey[i] && keyhot[i] == (dword)kv) {
hotkey[i]();
return;
}
}
#endif
DispatchKey(!pressed * K_KEYUP + kv, CurrentEvent.count);
}
break;
case EVENT_TEXT: {
WString h = CurrentEvent.value;
for(int i = 0; i < h.GetCount(); i++) // TODO: Add compression
DispatchKey(h[i], 1);
break;
}
case GDK_DELETE: {
TopWindow *w = dynamic_cast<TopWindow *>(this);
if(w) {
if(IsEnabled()) {
IgnoreMouseUp();
w->WhenClose();
}
}
return;
}
case GDK_CONFIGURE: {
Rect rect = CurrentEvent.value;
if(GetRect() != rect)
SetWndRect(rect);
}
break;
default:
return;
}
if(_this)
_this->PostInput();
}
