Beispiel #1
0
already_AddRefed<IDBFileRequest>
IDBFileHandle::GetMetadata(const IDBFileMetadataParameters& aParameters,
                           ErrorResult& aRv)
{
  MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");

  // Common state checking
  if (!CheckState(aRv)) {
    return nullptr;
  }

  // Do nothing if the window is closed
  if (!CheckWindow()) {
    return nullptr;
  }

  nsRefPtr<MetadataParameters> params =
    new MetadataParameters(aParameters.mSize, aParameters.mLastModified);
  if (!params->IsConfigured()) {
    aRv.ThrowTypeError(MSG_METADATA_NOT_CONFIGURED);
    return nullptr;
  }

  nsRefPtr<FileRequestBase> fileRequest = GenerateFileRequest();

  nsRefPtr<MetadataHelper> helper =
    new MetadataHelper(this, fileRequest, params);

  if (NS_WARN_IF(NS_FAILED(helper->Enqueue()))) {
    aRv.Throw(NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR);
    return nullptr;
  }

  return fileRequest.forget().downcast<IDBFileRequest>();
}
Beispiel #2
0
/*****************************
 *
 * Routine to add an item to the dialog box
 * The pointer to the item is copied to the dlg struct,
 * the item itself may not be freed until the dlg is done with
 *
 ****************************/
void DoCreateDlg(t_dlg *dlg)
{
  XSizeHints           hints;
  XSetWindowAttributes attr;
  unsigned long Val;

  attr.border_pixel=dlg->x11->fg;
  attr.background_pixel=dlg->bg;
  attr.override_redirect=False;
  attr.save_under=True;
  attr.cursor=XCreateFontCursor(dlg->x11->disp,XC_hand2);
  Val=CWBackPixel | CWBorderPixel | CWOverrideRedirect | CWSaveUnder |
    CWCursor;
  dlg->win.self=XCreateWindow(dlg->x11->disp,dlg->wDad,
			      dlg->win.x,dlg->win.y,
			      dlg->win.width,dlg->win.height,
			      dlg->win.bwidth,CopyFromParent,
			      InputOutput,CopyFromParent,
			      Val,&attr);
  dlg->x11->RegisterCallback(dlg->x11,dlg->win.self,dlg->wDad,
			     DlgCB,dlg);
  dlg->x11->SetInputMask(dlg->x11,dlg->win.self, 
			 ExposureMask | ButtonPressMask | KeyPressMask);

  if (!CheckWindow(dlg->win.self))
    exit(1);
  hints.x=dlg->win.x;
  hints.y=dlg->win.y;
  hints.flags=PPosition;
  XSetStandardProperties(dlg->x11->disp,dlg->win.self,dlg->title,
			 dlg->title,None,NULL,0,&hints);
}
Beispiel #3
0
nsresult
FileHandleBase::OpenInputStream(bool aWholeFile, uint64_t aStart,
                                uint64_t aLength, nsIInputStream** aResult)
{
  MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
  MOZ_ASSERT(mRequestMode == PARALLEL,
             "Don't call me in other than parallel mode!");

  // Common state checking
  ErrorResult error;
  if (!CheckState(error)) {
    return error.StealNSResult();
  }

  // Do nothing if the window is closed
  if (!CheckWindow()) {
    return NS_OK;
  }

  nsRefPtr<OpenStreamHelper> helper =
    new OpenStreamHelper(this, aWholeFile, aStart, aLength);

  nsresult rv = helper->Enqueue();
  NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR);

  nsCOMPtr<nsIInputStream>& result = helper->Result();
  NS_ENSURE_TRUE(result, NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR);

  result.forget(aResult);
  return NS_OK;
}
Beispiel #4
0
    static PyObject *
WindowGetattro(PyObject *self, PyObject *nameobj)
{
    WindowObject *this = (WindowObject *)(self);

    char *name = "";
    if (PyUnicode_Check(nameobj))
	name = _PyUnicode_AsString(nameobj);


    if (CheckWindow(this))
	return NULL;

    if (strcmp(name, "buffer") == 0)
	return (PyObject *)BufferNew(this->win->w_buffer);
    else if (strcmp(name, "cursor") == 0)
    {
	pos_T *pos = &this->win->w_cursor;

	return Py_BuildValue("(ll)", (long)(pos->lnum), (long)(pos->col));
    }
    else if (strcmp(name, "height") == 0)
	return Py_BuildValue("l", (long)(this->win->w_height));
#ifdef FEAT_VERTSPLIT
    else if (strcmp(name, "width") == 0)
	return Py_BuildValue("l", (long)(W_WIDTH(this->win)));
#endif
    else if (strcmp(name,"__members__") == 0)
	return Py_BuildValue("[sss]", "buffer", "cursor", "height");
    else
	return PyObject_GenericGetAttr(self, nameobj);
}
Beispiel #5
0
already_AddRefed<FileRequestBase>
FileHandleBase::WriteInternal(nsIInputStream* aInputStream,
                              uint64_t aInputLength, bool aAppend,
                              ErrorResult& aRv)
{
  MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");

  DebugOnly<ErrorResult> error;
  MOZ_ASSERT(CheckStateForWrite(error));
  MOZ_ASSERT_IF(!aAppend, mLocation != UINT64_MAX);
  MOZ_ASSERT(aInputStream);
  MOZ_ASSERT(aInputLength);
  MOZ_ASSERT(CheckWindow());

  nsRefPtr<FileRequestBase> fileRequest = GenerateFileRequest();

  uint64_t location = aAppend ? UINT64_MAX : mLocation;

  nsRefPtr<WriteHelper> helper =
    new WriteHelper(this, fileRequest, location, aInputStream, aInputLength);

  if (NS_WARN_IF(NS_FAILED(helper->Enqueue()))) {
    aRv.Throw(NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR);
    return nullptr;
  }

  if (aAppend) {
    mLocation = UINT64_MAX;
  }
  else {
    mLocation += aInputLength;
  }

  return fileRequest.forget();
}
Beispiel #6
0
already_AddRefed<FileRequestBase>
FileHandleBase::Flush(ErrorResult& aRv)
{
  MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");

  // State checking for write
  if (!CheckStateForWrite(aRv)) {
    return nullptr;
  }

  // Do nothing if the window is closed
  if (!CheckWindow()) {
    return nullptr;
  }

  nsRefPtr<FileRequestBase> fileRequest = GenerateFileRequest();

  nsRefPtr<FlushHelper> helper = new FlushHelper(this, fileRequest);

  if (NS_WARN_IF(NS_FAILED(helper->Enqueue()))) {
    aRv.Throw(NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR);
    return nullptr;
  }

  return fileRequest.forget();
}
Beispiel #7
0
already_AddRefed<FileRequestBase>
FileHandleBase::Read(uint64_t aSize, bool aHasEncoding,
                     const nsAString& aEncoding, ErrorResult& aRv)
{
  MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");

  // State and argument checking for read
  if (!CheckStateAndArgumentsForRead(aSize, aRv)) {
    return nullptr;
  }

  // Do nothing if the window is closed
  if (!CheckWindow()) {
    return nullptr;
  }

  nsRefPtr<FileRequestBase> fileRequest = GenerateFileRequest();

  nsRefPtr<ReadHelper> helper;
  if (aHasEncoding) {
    helper = new ReadTextHelper(this, fileRequest, mLocation, aSize, aEncoding);
  } else {
    helper = new ReadHelper(this, fileRequest, mLocation, aSize);
  }

  if (NS_WARN_IF(NS_FAILED(helper->Init())) ||
      NS_WARN_IF(NS_FAILED(helper->Enqueue()))) {
    aRv.Throw(NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR);
    return nullptr;
  }

  mLocation += aSize;

  return fileRequest.forget();
}
Beispiel #8
0
    static PyObject *
WindowGetattr(PyObject *self, char *name)
{
    WindowObject *this = (WindowObject *)(self);

    if (CheckWindow(this))
	return NULL;

    if (strcmp(name, "buffer") == 0)
	return (PyObject *)BufferNew(this->win->w_buffer);
    else if (strcmp(name, "cursor") == 0)
    {
	pos_T *pos = &this->win->w_cursor;

	return Py_BuildValue("(ll)", (long)(pos->lnum), (long)(pos->col));
    }
    else if (strcmp(name, "height") == 0)
	return Py_BuildValue("l", (long)(this->win->w_height));
#ifdef FEAT_VERTSPLIT
    else if (strcmp(name, "width") == 0)
	return Py_BuildValue("l", (long)(W_WIDTH(this->win)));
#endif
    else if (strcmp(name,"__members__") == 0)
	return Py_BuildValue("[sss]", "buffer", "cursor", "height");
    else
	return Py_FindMethod(WindowMethods, self, name);
}
Beispiel #9
0
/*
** Called during each update of the main measure.
**
*/
void PlayerITunes::UpdateData()
{
	if ((m_Initialized || CheckWindow()) && m_State != STATE_STOPPED)
	{
		long position = 0;
		m_iTunes->get_PlayerPosition(&position);
		m_Position = (UINT)position;
	}
}
Beispiel #10
0
bool ventrilo_chat::Send(const std::string&strText)
{
	#ifdef OS_WINDOWS_
	if (CheckWindow())
	{
		if (!bMumble)
		{
			SendMessage(hwndMessage,WM_SETTEXT,0,(LPARAM)strText.c_str());
			SendMessage(hwndSend,BM_CLICK,0,0);
		}
		else
		{
			// To the start of the box
			//SetForegroundWindow(hwndMessage);
			SendMessage(hwndMessage, WM_LBUTTONDOWN, 0, (LPARAM)0);
			SendMessage(hwndMessage, WM_ACTIVATE, WA_ACTIVE, (LPARAM)hwndMessage);
			SendMessage(hwndMessage, WM_KEYDOWN, VK_HOME, (LPARAM)0);
			SendMessage(hwndMessage, WM_KEYUP, VK_HOME, (LPARAM)0);
			for (unsigned int i=0;i<500;++i)
			{
				// Delete everything
				SendMessage(hwndMessage, WM_KEYDOWN, VK_DELETE, (LPARAM)0);
				SendMessage(hwndMessage, WM_KEYUP, VK_DELETE, (LPARAM)0);
			}

			for (std::string::const_iterator it=strText.begin();it!=strText.end();++it)
			{
				SendMessage(hwndMessage, WM_CHAR, *it, (LPARAM)0);
			}
			SendMessage(hwndMessage, WM_KEYDOWN, VK_RETURN, (LPARAM)0);
			SendMessage(hwndMessage, WM_KEYUP, VK_RETURN, (LPARAM)0);
		}
	}
	std::cout << "Sending Text: " << strText << std::endl;
	#endif

	std::string::size_type posStart=0;
	std::string::size_type posEnd;
	std::string strEscapedText;

	while(true)
	{
		posEnd=strText.find('"',posStart);
		if (posEnd == std::string::npos)
			strEscapedText += strText.substr(posStart);
		else
			strEscapedText += strText.substr(posStart,posEnd-posStart);
		if (posEnd == std::string::npos)
			break;
		strEscapedText += "\\\"";
		posStart=posEnd+1;
	}	
	std::string strOutput=std::string("./scripts/send_voice_message.sh \"") + strEscapedText + "\""; // security issue if this text can have ; and such
	system(strOutput.c_str());
	std::cout << strEscapedText << std::endl;
	return true;
}
Beispiel #11
0
    static PyObject *
WindowGetattr(PyObject *self, char *name)
{
    PyObject *r;

    if (CheckWindow((WindowObject *)(self)))
	return NULL;

    r = WindowAttr((WindowObject *)(self), name);
    if (r || PyErr_Occurred())
	return r;
    else
	return Py_FindMethod(WindowMethods, self, name);
}
Beispiel #12
0
void AddDlgItem(t_dlg *dlg, t_dlgitem *item)
{
#define EnterLeaveMask (EnterWindowMask | LeaveWindowMask)
#define UserMask (ButtonPressMask | KeyPressMask)
    static unsigned long InputMask[edlgNR] = {
        ExposureMask | UserMask | EnterLeaveMask, /* edlgBN */
        ExposureMask | UserMask | EnterLeaveMask, /* edlgRB */
        ExposureMask,                             /* edlgGB */
        ExposureMask | UserMask | EnterLeaveMask, /* edlgCB */
        0,                                        /* edlgPM */
        ExposureMask,                             /* edlgST */
        ExposureMask | UserMask | EnterLeaveMask  /* edlgET */
    };

    if (!dlg->win.self)
    {
        DoCreateDlg(dlg);
    }
    srenew(dlg->dlgitem, dlg->nitem+1);
    if (!item)
    {
        gmx_fatal(FARGS, "dlgitem not allocated");
    }
    item->win.self =
        XCreateSimpleWindow(dlg->x11->disp, dlg->win.self, item->win.x, item->win.y,
                            item->win.width, item->win.height,
                            item->win.bwidth, dlg->x11->fg, dlg->x11->bg);
    CheckWindow(item->win.self);

    dlg->x11->RegisterCallback(dlg->x11, item->win.self, dlg->win.self,
                               DlgCB, dlg);
    dlg->x11->SetInputMask(dlg->x11, item->win.self, InputMask[item->type]);

    switch (item->type)
    {
        case edlgPM:
            XSetWindowBackgroundPixmap(dlg->x11->disp, item->win.self, item->u.pixmap.pm);
            break;
        default:
            break;
    }
    dlg->dlgitem[dlg->nitem] = item;

    dlg->nitem++;
}
Beispiel #13
0
already_AddRefed<FileRequestBase>
FileHandleBase::Truncate(const Optional<uint64_t>& aSize, ErrorResult& aRv)
{
  MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");

  // State checking for write
  if (!CheckStateForWrite(aRv)) {
    return nullptr;
  }

  // Getting location and additional state checking for truncate
  uint64_t location;
  if (aSize.WasPassed()) {
    // Just in case someone calls us from C++
    MOZ_ASSERT(aSize.Value() != UINT64_MAX, "Passed wrong size!");
    location = aSize.Value();
  } else {
    if (mLocation == UINT64_MAX) {
      aRv.Throw(NS_ERROR_DOM_FILEHANDLE_NOT_ALLOWED_ERR);
      return nullptr;
    }
    location = mLocation;
  }

  // Do nothing if the window is closed
  if (!CheckWindow()) {
    return nullptr;
  }

  nsRefPtr<FileRequestBase> fileRequest = GenerateFileRequest();

  nsRefPtr<TruncateHelper> helper =
    new TruncateHelper(this, fileRequest, location);

  if (NS_WARN_IF(NS_FAILED(helper->Enqueue()))) {
    aRv.Throw(NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR);
    return nullptr;
  }

  if (aSize.WasPassed()) {
    mLocation = aSize.Value();
  }

  return fileRequest.forget();
}
Beispiel #14
0
/*
** Called during each update of the main measure.
**
*/
void PlayerSpotify::UpdateData()
{
	if (m_Initialized || CheckWindow())
	{
		// Parse title and artist from window title
		WCHAR buffer[256];
		if (GetWindowText(m_Window, buffer, 256) > 10)
		{
			std::wstring title = &buffer[10];  // Skip "Spotify - "

			std::wstring::size_type pos = title.find(L" \u2013 ");
			if (pos != std::wstring::npos)
			{
				std::wstring artist(title, 0, pos);
				pos += 3;  // Skip " - "
				std::wstring track(title, pos);

				if (track != m_Title || artist != m_Artist)
				{
					m_State = STATE_PLAYING;
					m_Title = track;
					m_Artist = artist;
					++m_TrackCount;

					if (m_Measures & MEASURE_LYRICS)
					{
						FindLyrics();
					}
				}
				return;
			}
		}
		else if (IsWindow(m_Window))
		{
			m_State = STATE_PAUSED;
		}
		else
		{
			ClearData();
			m_Initialized = false;
		}
	}
}
Beispiel #15
0
static PyObject *
WindowGetattro(PyObject *self, PyObject *nameobj)
{
	PyObject *r;

	GET_ATTR_STRING(name, nameobj);

	if ((r = WindowAttrValid((WindowObject *)(self), name)))
		return r;

	if (CheckWindow((WindowObject *)(self)))
		return NULL;

	r = WindowAttr((WindowObject *)(self), name);
	if (r || PyErr_Occurred())
		return r;
	else
		return PyObject_GenericGetAttr(self, nameobj);
}
Beispiel #16
0
BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
					 )
{
	switch (ul_reason_for_call)
	{
	case DLL_PROCESS_ATTACH:
		CheckWindow();		
		break;
	case DLL_THREAD_ATTACH:
		break;
	case DLL_THREAD_DETACH:
		break;
	case DLL_PROCESS_DETACH:
		UnHook();
		break;
	}
	return TRUE;
}
Beispiel #17
0
bool ventrilo_chat::GetText()
{
	#ifdef OS_WINDOWS_
	if (!bMumble)
	{
		if (CheckWindow())
		{
			unsigned int uLength=SendMessage(hwndChat,WM_GETTEXTLENGTH,0,0);
			++uLength;
			if (uLength > vcBuffer.capacity())
				vcBuffer.reserve(uLength);
			vcBuffer.resize(uLength);
			if (!vcBuffer.empty())
				vcBuffer.resize(SendMessage(hwndChat,WM_GETTEXT,(WPARAM)uLength,(LPARAM)&vcBuffer[0]));
			
			return true;
		}
	}
	#endif
	return false;
}
Beispiel #18
0
/*
** Called during each update of the main measure.
**
*/
void CPlayerAIMP::UpdateData()
{
	if (!m_Initialized)
	{
		if (m_LastTitleSize != 0)
		{
			m_LastFileSize = 0;
			m_LastTitleSize = 0;
		}

		if (!CheckWindow()) return;
	}

	// If initialized
	m_State = (StateType)SendMessage(m_Window, WM_AIMP_COMMAND, WM_AIMP_STATUS_GET, AIMP_STS_Player);
	if (m_State == STATE_STOPPED)
	{
		// Make sure AIMP is still active
		if (!IsWindow(m_Window))
		{
			m_Initialized = false;
			ClearData();

			if (m_FileMap) UnmapViewOfFile(m_FileMap);
			if (m_FileMapHandle) CloseHandle(m_FileMapHandle);
		}
		else if (m_State != STATE_STOPPED)
		{
			ClearData(false);
			m_LastFileSize = 0;
			m_LastTitleSize = 0;
		}

		// Don't continue if AIMP has quit or is stopped
		return;
	}

	m_Position = SendMessage(m_Window, WM_AIMP_COMMAND, WM_AIMP_STATUS_GET, AIMP_STS_POS);
	m_Volume = SendMessage(m_Window, WM_AIMP_COMMAND, WM_AIMP_STATUS_GET, AIMP_STS_VOLUME);

	AIMP2FileInfo* info = (AIMP2FileInfo*)m_FileMap;
	if (info->cbSizeOf > 0 &&
		info->nFileSize != m_LastFileSize	||	// Avoid reading the same file
		info->nTitleLen != m_LastTitleSize)
	{
		m_LastFileSize = info->nFileSize;
		m_LastTitleSize = info->nTitleLen;

		// 44 is sizeof(AIMP2FileInfo) / 2 (due to WCHAR being 16-bit).
		// Written explicitly due to size differences in 32bit/64bit.
		LPCTSTR stringData = (LPCTSTR)m_FileMap;
		stringData += 44;

		m_Album.assign(stringData, info->nAlbumLen);

		stringData += info->nAlbumLen;
		m_Artist.assign(stringData, info->nArtistLen);

		stringData += info->nArtistLen;
		stringData += info->nDateLen;
		std::wstring filepath(stringData, info->nFileNameLen);

		stringData += info->nFileNameLen;
		stringData += info->nGenreLen;
		m_Title.assign(stringData, info->nTitleLen);

		m_Duration = info->nDuration / 1000;
		m_Number = (UINT)info->nTrackID;

		m_Shuffle = (bool)SendMessage(m_Window, WM_AIMP_COMMAND, WM_AIMP_STATUS_GET, AIMP_STS_SHUFFLE);
		m_Repeat = (bool)SendMessage(m_Window, WM_AIMP_COMMAND, WM_AIMP_STATUS_GET, AIMP_STS_REPEAT);

		// Get rating through the AIMP Winamp API
		m_Rating = SendMessage(m_WinampWindow, WM_WA_IPC, 0, IPC_GETRATING);

		if (filepath != m_FilePath)
		{
			m_FilePath = filepath;
			++m_TrackCount;

			if (m_Measures & MEASURE_COVER) FindCover();

			if (m_Measures & MEASURE_LYRICS) FindLyrics();
		}
	}
}
Beispiel #19
0
/*
** Called during each update of the main measure.
**
*/
void CPlayerWinamp::UpdateData()
{
	if (m_Initialized || CheckWindow())
	{
		int playing = SendMessage(m_Window, WM_WA_IPC, 0, IPC_ISPLAYING);
		if (playing == 0)
		{
			// Make sure Winamp is still active
			if (!IsWindow(m_Window))
			{
				m_Initialized = false;
				ClearData();

				if (m_WinampHandle) CloseHandle(m_WinampHandle);
			}
			else if (m_State != STATE_STOPPED)
			{
				ClearData(false);
			}

			// Don't continue if Winamp has quit or is stopped
			return;
		}
		else
		{
			m_State = (playing == 1) ? STATE_PLAYING : STATE_PAUSED;
			m_Position = SendMessage(m_Window, WM_WA_IPC, 0, IPC_GETOUTPUTTIME) / 1000;		// ms to secs
			m_Volume = (SendMessage(m_Window, WM_WA_IPC, -666, IPC_SETVOLUME) * 100) / 255;	// 0 - 255 to 0 - 100
		}

		WCHAR wBuffer[MAX_PATH];
		char cBuffer[MAX_PATH];

		if (m_UseUnicodeAPI)
		{
			if (!ReadProcessMemory(m_WinampHandle, m_WinampAddress, &wBuffer, sizeof(wBuffer), NULL))
			{
				// Failed to read memory
				return;
			}
		}
		else
		{
			// MediaMonkey doesn't support wide IPC messages
			int pos = SendMessage(m_Window, WM_WA_IPC, 0, IPC_GETLISTPOS);
			LPCVOID address = (LPCVOID)SendMessage(m_Window, WM_WA_IPC, pos, IPC_GETPLAYLISTFILE);

			if (!ReadProcessMemory(m_WinampHandle, address, &cBuffer, sizeof(cBuffer), NULL))
			{
				// Failed to read memory
				return;
			}

			mbstowcs(wBuffer, cBuffer, MAX_PATH);
		}

		if (wcscmp(wBuffer, m_FilePath.c_str()) != 0)
		{
			++m_TrackCount;
			m_FilePath = wBuffer;
			m_PlayingStream = (m_FilePath.find(L"://") != std::wstring::npos);

			if (!m_PlayingStream)
			{
				int duration = SendMessage(m_Window, WM_WA_IPC, 1, IPC_GETOUTPUTTIME);
				m_Duration = (duration != -1) ? duration : 0;

				m_Rating = SendMessage(m_Window, WM_WA_IPC, 0, IPC_GETRATING);
				m_Shuffle = (bool)SendMessage(m_Window, WM_WA_IPC, 0, IPC_GET_SHUFFLE);
				m_Repeat = (bool)SendMessage(m_Window, WM_WA_IPC, 0, IPC_GET_REPEAT);

				TagLib::FileRef fr(wBuffer, false);
				TagLib::Tag* tag = fr.tag();
				if (tag)
				{
					m_Artist = tag->artist().toWString();
					m_Album = tag->album().toWString();
					m_Title = tag->title().toWString();
					m_Number = tag->track();
					m_Year = tag->year();

					if (m_Measures & MEASURE_LYRICS)
					{
						FindLyrics();
					}
				}
				else if (m_Measures & MEASURE_LYRICS)
				{
					m_Lyrics.clear();
				}

				// Find cover if needed
				if (m_Measures & MEASURE_COVER)
				{
					if (tag && CCover::GetEmbedded(fr, m_TempCoverPath))
					{
						// Got everything, return
						m_CoverPath = m_TempCoverPath;
						return;
					}

					std::wstring trackFolder = CCover::GetFileFolder(m_FilePath);
					if (tag && !m_Album.empty())
					{
						// Winamp stores covers usually as %album%.jpg
						std::wstring file = m_Album;
						std::wstring::size_type end = file.length();
						for (std::wstring::size_type pos = 0; pos < end; ++pos)
						{
							// Replace reserved chars according to Winamp specs
							switch (file[pos])
							{
							case L'?':
							case L'*':
							case L'|':
								file[pos] = L'_';
								break;

							case L'/':
							case L'\\':
							case L':':
								file[pos] = L'-';
								break;

							case L'\"':
								file[pos] = L'\'';
								break;

							case L'<':
								file[pos] = L'(';
								break;

							case L'>':
								file[pos] = L')';
								break;
							}
						}

						if (CCover::GetLocal(file, trackFolder, m_CoverPath))
						{
							// %album% art file found
							return;
						}
					}

					if (!CCover::GetLocal(L"cover", trackFolder, m_CoverPath) &&
						!CCover::GetLocal(L"folder", trackFolder, m_CoverPath))
					{
						// Nothing found
						m_CoverPath.clear();
					}
				}

				if (tag)
				{
					return;
				}
			}
			else
			{
				m_Rating = 0;
				m_Duration = 0;
				m_CoverPath.clear();
			}
		}
		else if (!m_PlayingStream)
		{
			if (m_Duration == 0)
			{
				int duration = SendMessage(m_Window, WM_WA_IPC, 1, IPC_GETOUTPUTTIME);
				m_Duration = (duration != -1) ? duration : 0;
			}

			return;
		}

		// TagLib couldn't parse the file or Winamp is playing a stream, try to get title
		if (m_UseUnicodeAPI)
		{
			LPCVOID address = (LPCVOID)SendMessage(m_Window, WM_WA_IPC, 0, IPC_GET_PLAYING_TITLE);
			ReadProcessMemory(m_WinampHandle, address, &wBuffer, sizeof(wBuffer), NULL);
		}
		else
		{
			int pos = SendMessage(m_Window, WM_WA_IPC, 0, IPC_GETLISTPOS);
			LPCVOID address = (LPCVOID)SendMessage(m_Window, WM_WA_IPC, pos, IPC_GETPLAYLISTTITLE);
			ReadProcessMemory(m_WinampHandle, address, &cBuffer, sizeof(cBuffer), NULL);
			mbstowcs(wBuffer, cBuffer, MAX_PATH);
		}

		std::wstring title = wBuffer;
		std::wstring::size_type pos = title.find(L" - ");
		if (pos != std::wstring::npos)
		{
			m_Artist.assign(title, 0, pos);
			pos += 3;  // Skip " - "
			m_Title.assign(title, pos, title.length() - pos);
			m_Album.clear();

			if (m_PlayingStream)
			{
				// Remove crap from title if playing radio
				pos = m_Title.find(L" (");
				if (pos != std::wstring::npos)
				{
					m_Title.resize(pos);
				}
			}
		}
		else
		{
			m_Title = title;
			m_Artist.clear();
			m_Album.clear();
		}
	}
}
Beispiel #20
0
Window
XRemoteClient::FindBestWindow(const char *aProgram, const char *aUsername,
                              const char *aProfile)
{
  Window root = RootWindowOfScreen(DefaultScreenOfDisplay(mDisplay));
  Window bestWindow = 0;
  Window root2, parent, *kids;
  unsigned int nkids;

  // Get a list of the children of the root window, walk the list
  // looking for the best window that fits the criteria.
  if (!XQueryTree(mDisplay, root, &root2, &parent, &kids, &nkids)) {
    PR_LOG(sRemoteLm, PR_LOG_DEBUG,
           ("XQueryTree failed in XRemoteClient::FindBestWindow"));
    return 0;
  }

  if (!(kids && nkids)) {
    PR_LOG(sRemoteLm, PR_LOG_DEBUG, ("root window has no children"));
    return 0;
  }

  // We'll walk the list of windows looking for a window that best
  // fits the criteria here.

  for (unsigned int i = 0; i < nkids; i++) {
    Atom type;
    int format;
    unsigned long nitems, bytesafter;
    unsigned char *data_return = 0;
    Window w;
    w = kids[i];
    // find the inner window with WM_STATE on it
    w = CheckWindow(w);

    int status = XGetWindowProperty(mDisplay, w, mMozVersionAtom,
                                    0, (65536 / sizeof (long)),
                                    False, XA_STRING,
                                    &type, &format, &nitems, &bytesafter,
                                    &data_return);

    if (!data_return)
      continue;

    double version = PR_strtod((char*) data_return, nullptr);
    XFree(data_return);

    if (!(version >= 5.1 && version < 6))
      continue;

    data_return = 0;

    if (status != Success || type == None)
      continue;

    // If someone passed in a program name, check it against this one
    // unless it's "any" in which case, we don't care.  If someone did
    // pass in a program name and this window doesn't support that
    // protocol, we don't include it in our list.
    if (aProgram && strcmp(aProgram, "any")) {
        status = XGetWindowProperty(mDisplay, w, mMozProgramAtom,
                                    0, (65536 / sizeof(long)),
                                    False, XA_STRING,
                                    &type, &format, &nitems, &bytesafter,
                                    &data_return);
        
        // If the return name is not the same as what someone passed in,
        // we don't want this window.
        if (data_return) {
            if (strcmp(aProgram, (const char *)data_return)) {
                XFree(data_return);
                continue;
            }

            // This is actually the success condition.
            XFree(data_return);
        }
        else {
            // Doesn't support the protocol, even though the user
            // requested it.  So we're not going to use this window.
            continue;
        }
    }

    // Check to see if it has the user atom on that window.  If there
    // is then we need to make sure that it matches what we have.
    const char *username;
    if (aUsername) {
      username = aUsername;
    }
    else {
      username = PR_GetEnv("LOGNAME");
    }

    if (username) {
        status = XGetWindowProperty(mDisplay, w, mMozUserAtom,
                                    0, (65536 / sizeof(long)),
                                    False, XA_STRING,
                                    &type, &format, &nitems, &bytesafter,
                                    &data_return);

        // if there's a username compare it with what we have
        if (data_return) {
            // If the IDs aren't equal, we don't want this window.
            if (strcmp(username, (const char *)data_return)) {
                XFree(data_return);
                continue;
            }

            XFree(data_return);
        }
    }

    // Check to see if there's a profile name on this window.  If
    // there is, then we need to make sure it matches what someone
    // passed in.
    if (aProfile) {
        status = XGetWindowProperty(mDisplay, w, mMozProfileAtom,
                                    0, (65536 / sizeof(long)),
                                    False, XA_STRING,
                                    &type, &format, &nitems, &bytesafter,
                                    &data_return);

        // If there's a profile compare it with what we have
        if (data_return) {
            // If the profiles aren't equal, we don't want this window.
            if (strcmp(aProfile, (const char *)data_return)) {
                XFree(data_return);
                continue;
            }

            XFree(data_return);
        }
    }

    // Check to see if the window supports the new command-line passing
    // protocol, if that is requested.

    // If we got this far, this is the best window.  It passed
    // all the tests.
    bestWindow = w;
    break;
  }

  if (kids)
    XFree((char *) kids);

  return bestWindow;
}
Beispiel #21
0
void InjectorProc(void *injectorModule, unsigned int dataSize, const void *data)
{
	util::dcout << "In inject proc." << std::endl;

#if 0
	util::dcout << "Waiting for debugger ..." << std::endl;

	if(IsDebuggerPresent() == FALSE)
	{
		while(IsDebuggerPresent() == FALSE)
		{
			Sleep(100);
		}

		DebugBreak();
	}

	util::dcout << "Debugger attached." << std::endl;
#endif

	HWND targetWindow = GetTargetWindow();
	if(targetWindow == NULL)
	{
		util::dcout << "Cannot find window !" << std::endl;

		return;
	}

	CheckWindow(targetWindow);

	OpenGLDrawData oglData;
	oglData.window = targetWindow;
	if(!InitOpenGLContext(oglData))
	{
		return;
	}
	InitOpenGL(oglData);

	MemoryDC memoryDC(oglData.width, oglData.height);
	oglData.memoryDC = &memoryDC;
	Init(oglData);

	wglMakeCurrent(NULL, NULL);
	g_oglData = &oglData;

	//MakeWindowFullyTransparent(targetWindow);
	WNDPROC originalWndProc = (WNDPROC)GetWindowLongPtr(targetWindow, GWLP_WNDPROC);
	g_originalWndProc = originalWndProc;
	SetWindowLongPtr(targetWindow, GWLP_WNDPROC, (LONG_PTR)HookWndProc);
	InvalidateRect(targetWindow, NULL, TRUE);

	//DrawLoop(oglData);
	//DrawFrame(oglData);
	Sleep(30000);

	wglMakeCurrent(oglData.oglDC, oglData.oglContext);
	DeInit(oglData);
	FreeOpenGLContext(oglData);

	SetWindowLongPtr(targetWindow, GWLP_WNDPROC, (LONG_PTR)originalWndProc);
	//MakeWindowUndo(targetWindow);
	InvalidateRect(targetWindow, NULL, TRUE);

	util::dcout << "Exiting inject proc." << std::endl;
}
JSBool
WrapObject(JSContext *cx, JSObject *scope, jsval v, jsval *vp)
{
  // This might be redundant if called from XPC_SJOW_Construct, but it should
  // be cheap in that case.
  JSObject *objToWrap = UnsafeUnwrapSecurityWrapper(cx, JSVAL_TO_OBJECT(v));
  if (!objToWrap ||
      JS_TypeOfValue(cx, OBJECT_TO_JSVAL(objToWrap)) == JSTYPE_XML) {
    return ThrowException(NS_ERROR_INVALID_ARG, cx);
  }

  // Prevent script created Script objects from ever being wrapped
  // with XPCSafeJSObjectWrapper, and never let the eval function
  // object be directly wrapped.

  if (objToWrap->getClass() == &js_ScriptClass ||
      (JS_ObjectIsFunction(cx, objToWrap) &&
       JS_GetFunctionFastNative(cx, JS_ValueToFunction(cx, v)) ==
       XPCWrapper::sEvalNative)) {
    return ThrowException(NS_ERROR_INVALID_ARG, cx);
  }

  XPCWrappedNativeScope *xpcscope =
    XPCWrappedNativeScope::FindInJSObjectScope(cx, scope);
  NS_ASSERTION(xpcscope, "what crazy scope are we in?");

  XPCWrappedNative *wrappedNative;
  WrapperType type = xpcscope->GetWrapperFor(cx, objToWrap, SJOW,
                                             &wrappedNative);

  // NB: We allow XOW here because we're as restrictive as it is (and we know
  // we're same origin here).
  if (type != NONE && type != XOW && !(type & SJOW)) {
    return ThrowException(NS_ERROR_INVALID_ARG, cx);
  }

  SLIM_LOG_WILL_MORPH(cx, objToWrap);
  if (IS_SLIM_WRAPPER(objToWrap) && !MorphSlimWrapper(cx, objToWrap)) {
    return ThrowException(NS_ERROR_FAILURE, cx);
  }

  XPCWrappedNative *wn =
    XPCWrappedNative::GetWrappedNativeOfJSObject(cx, objToWrap);
  if (wn) {
    CheckWindow(wn);
  }

  JSObject *wrapperObj =
    JS_NewObjectWithGivenProto(cx, js::Jsvalify(&SJOWClass), nsnull, scope);

  if (!wrapperObj) {
    // JS_NewObjectWithGivenProto already threw.
    return JS_FALSE;
  }

  *vp = OBJECT_TO_JSVAL(wrapperObj);
  if (!JS_SetReservedSlot(cx, wrapperObj, XPCWrapper::sWrappedObjSlot,
                          OBJECT_TO_JSVAL(objToWrap)) ||
      !JS_SetReservedSlot(cx, wrapperObj, XPCWrapper::sFlagsSlot, JSVAL_ZERO)) {
    return JS_FALSE;
  }

  return JS_TRUE;
}
Beispiel #23
0
int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	nCurAppRunMode=afxAppRunMode;
	if (CMDIFrameWnd::OnCreate(lpCreateStruct) == -1)
		return -1;
	



	CExtCmdManager::g_bDisableCmdIfNoHandler=0;


	UINT nMainToolBarID=IDR_MAINFRAME;
	if(nCurAppRunMode==CONFIG_MODE)
	{
		SetTitle("2—: онфигуратор");
		nMainToolBarID=IDR_CONFIGTOOLBAR;
	}

	csProfileName=GetTitle()+"N05";
#ifdef _DEBUG
	csProfileName+="D";
#endif



	CWinApp * pApp = ::AfxGetApp();


	g_CmdManager->ProfileSetup(
		csProfileName,
		GetSafeHwnd()
		);
	

	//ћеню
/*	m_wndMenuBar.SetMdiWindowPopupName( _T("Window") );
	if( !m_wndMenuBar.Create("√лавное меню",
							 this,
							 IDC_MAIN_MENU))
	{
		TRACE0( _T( "Failed to create menubar\n" ) );
		return -1;
	}
*/

	if (!m_wndStatusBar.Create(this) ||
		!m_wndStatusBar.SetIndicators(indicators,
		  sizeof(indicators)/sizeof(UINT)))
	{
		TRACE0("Failed to create status bar\n");
		return -1;      // fail to create
	}
	pStatusBar=&m_wndStatusBar;


	//√лавна¤ панель
	if( !m_ToolMain.Create(
			_T("ќбща¤ панель инструментов"),
			this,
			IDR_MAIN_TOOLBAR
			)
		||
		!m_ToolMain.LoadToolBar(nMainToolBarID)
		)
	{
		TRACE0("Failed to create toolbar\n");
		return -1;      // fail to create
	}
	//ѕанель инструментов модул¤
	if( !m_ToolModule.Create(
			_T("ѕанель инструментов модул¤"),
			this,
			IDR_MODULE
			)
		||
		!m_ToolModule.LoadToolBar(IDR_MODULE)
		)
	{
		TRACE0("Failed to create toolbar\n");
		return -1;      // fail to create
	}

	//ѕанель инструментов формы
	if(nCurAppRunMode==CONFIG_MODE)
	{
		if( !m_ToolEdit.Create(
				_T("ѕанель инструментов формы"),
				this,
				IDR_EDITBAR
				)
			||
			!m_ToolEdit.LoadToolBar(IDR_EDITBAR)
			)
		{
			TRACE0("Failed to create toolbar\n");
			return -1;      // fail to create
		}
	}

	//—оздаем контейнер окна сообщений
	if(	!m_ParentMessageBar.Create(
			_T("ќкно сообщений"),
			this,
			ID_VIEWMESSAGEWINDOW
			)
		)
	{
		TRACE0("Failed to create m_ParentMessageBar\n");
		return -1;		// fail to create
	}
	//—оздаем само окно сообщений
	if( !m_MessageBar.Create(
			WS_CHILD|WS_VISIBLE|WS_VSCROLL|WS_HSCROLL
				|ES_MULTILINE|ES_LEFT|ES_WANTRETURN,

			CRect(0,0,0,0),
			&m_ParentMessageBar,
			m_ParentMessageBar.GetDlgCtrlID()
			)
		)
	{
		TRACE0("Failed to create m_MessageBar\n");
		return -1;		// fail to create
	}
	m_MessageBar.Init();





	if(nCurAppRunMode==CONFIG_MODE)
	{
		//—оздаем контейнер отладочного окна
		if(	!m_ParentDebugMessageBar.Create(
				_T("ќкно отладки"),
				this,
				ID_VIEWDEBUGMESSAGEWINDOW
				)
			) 
		{
			TRACE0("Failed to create m_ParentDebugMessageBar\n");
			return -1;		// fail to create
		}
		if( !m_DebugMessageBar.Create(
				WS_VISIBLE|WS_CHILD|LVS_SHAREIMAGELISTS,
				CRect(0,50,50,200),
				&m_ParentDebugMessageBar,
				m_ParentDebugMessageBar.GetDlgCtrlID()
				)
			)
		{
			TRACE0("Failed to create m_DebugMessageBar\n");
			return -1;		// fail to create
		}
		m_DebugMessageBar.Init();
		pDebugMessageBar=&m_DebugMessageBar;

		
		//—оздаем контейнер окна стека вызова
		if(	!m_ParentStackBar.Create(
				_T("—тек вызова"),
				this,
				ID_VIEW_STACK
				)
			)
		{
			TRACE0("Failed to create m_ParentStackBar\n");
			return -1;		// fail to create
		}
		if( !m_StackBar.Create(
				WS_VISIBLE|WS_CHILD|LVS_SHAREIMAGELISTS,
				CRect(0,0,50,200),
				&m_ParentStackBar,
				m_ParentStackBar.GetDlgCtrlID()
				)
			)
		{
			TRACE0("Failed to create m_StackBar\n");
			return -1;		// fail to create
		}

		m_StackBar.Init();
		pDebugStackBar=&m_StackBar;
		


		//—оздаем контейнер окна свойств
		if(	!m_ParentPropertyBar.Create(
				_T("ќкно свойств"),
				this,
				ID_PROPERTYBAR
				)
			)
		{
			TRACE0("Failed to create m_ParentPropertyBar\n");
			return -1;		// fail to create
		}
		//—оздаем окно свойств
		if( !m_PropertyBar.Create(
			CRect(0,0,50,50),
			&m_ParentPropertyBar,
			IDC_OI,
			0x50010000
				)
			)
		{
			TRACE0("Failed to create m_PropertyBar\n");
			return -1;		// fail to create
		}
		m_PropertyBar.SetBorderStyle(CObjectInspector::bsSingle);
		m_PropertyBar.SetImageList(GetImageList());
	}





	if( !m_ComboHelpSearch.Create(WS_CHILD | WS_VISIBLE | CBS_DROPDOWN,
								  CRect( 0, 0, 200, 480 ),
								  &m_ToolMain,
								  ID_HELP_SEARCH_COMBO) || 
		!m_ToolMain.SetButtonCtrl(                                           
										m_ToolMain.CommandToIndex(
										m_ComboHelpSearch.GetDlgCtrlID()) ,
										&m_ComboHelpSearch) )
	{
		TRACE0( "Failed to create help search combobox\n" );
		return -1;
	}
			
	m_ComboHelpSearch.SetItemHeight( -1, 16 );

	m_ComboHelpSearch.SetFont( &g_PaintManager->m_FontNormal );
	g_CmdManager->CmdGetPtr(csProfileName,m_ComboHelpSearch.GetDlgCtrlID())-> m_sMenuText
							   = _T( "Search help system" );



	m_wndDocSelector.Create(NULL, "ѕанель окон", WS_VISIBLE | WS_CHILD | WS_CLIPSIBLINGS | 
							CBRS_TOP, CRect(0,0,0,0), this, IDS_DOC_SELECTOR);
	m_wndDocSelector.SetBarStyle( CBRS_ALIGN_BOTTOM);

	
	


    //m_wndMenuBar.EnableDocking(CBRS_ALIGN_ANY);
	m_ToolMain.EnableDocking(CBRS_ALIGN_ANY);
	m_ToolModule.EnableDocking(CBRS_ALIGN_ANY);
	if(nCurAppRunMode==CONFIG_MODE)
		m_ToolEdit.EnableDocking(CBRS_ALIGN_ANY);
	m_ParentMessageBar.EnableDocking(CBRS_ALIGN_ANY);

	if(nCurAppRunMode==CONFIG_MODE)
	{
		m_ParentDebugMessageBar.EnableDocking(CBRS_ALIGN_ANY);
		m_ParentStackBar.EnableDocking(CBRS_ALIGN_ANY);
		m_ParentPropertyBar.EnableDocking(CBRS_ALIGN_ANY);
	}


	if( !CExtControlBar::FrameEnableDocking(this) )
	{
		ASSERT( FALSE );
		return -1;
	}


	//DockControlBar(&m_wndMenuBar,AFX_IDW_DOCKBAR_TOP);
	DockControlBar(&m_ToolMain);
	DockControlBar(&m_ToolModule,AFX_IDW_DOCKBAR_BOTTOM);
	if(nCurAppRunMode==CONFIG_MODE)
		DockControlBar(&m_ToolEdit,AFX_IDW_DOCKBAR_BOTTOM);


	RecalcLayout();

	m_ParentMessageBar.SetInitDesiredSizeHorizontal( CSize(80,80) );
	m_ParentMessageBar.DockControlBar(AFX_IDW_DOCKBAR_BOTTOM,1,this,false);

	if(nCurAppRunMode==CONFIG_MODE)
	{
		m_ParentDebugMessageBar.SetInitDesiredSizeHorizontal( CSize(80,80) );
		m_ParentDebugMessageBar.DockControlBar(AFX_IDW_DOCKBAR_BOTTOM,2,this,false);

		m_ParentStackBar.SetInitDesiredSizeHorizontal( CSize(80,80) );
		m_ParentStackBar.DockControlBar(AFX_IDW_DOCKBAR_RIGHT,1,this,false);

		m_ParentPropertyBar.SetInitDesiredSizeVertical( CSize(180,80) );
		m_ParentPropertyBar.DockControlBar(AFX_IDW_DOCKBAR_RIGHT,1,this,false);

//		m_ParentPropertyBar.SetInitDesiredSizeHorizontal( CSize(180,80) );
//		m_ParentPropertyBar.SetInitDesiredSizeFloating( CSize(380,380) );
//		m_ParentPropertyBar.FloatControlBar();

//		m_ParentPropertyBar.AutoHideModeGet();
	}







/*	g_CmdManager->SetBasicCommands(
	csProfileName,
	g_statBasicCommands);
*/
		
	RecalcLayout();
	
	CExtControlBar::ProfileBarStateLoad(
		this,
		pApp->m_pszRegistryKey,
		csProfileName,
		"Save",
		&m_dataFrameWP
		);


	//¬осстанавливаем стиль
	CString csStyle=AfxGetApp()->GetProfileString(csProfileName, "Style");
	//if(csStyle!="XP")
	//	OnViewLikeOffice2k();
	OnViewLikeOffice2k();


	//передача ошибок в окно сообщений конфигуратора
	//if(nCurAppRunMode==CONFIG_MODE)
	//или отладка
	MyDDE.Create(MAKEINTRESOURCE(IDD_MYDATAEXCHANGE_DIALOG),this);


	CheckWindow(m_ToolMain);
	CheckWindow(m_ToolModule);
	if(nCurAppRunMode==CONFIG_MODE)
	{
		CheckWindow(m_ToolEdit);
		CheckWindow(m_ParentDebugMessageBar);
		CheckWindow(m_ParentStackBar);
		CheckWindow(m_ParentPropertyBar);
	}
	CheckWindow(m_ParentMessageBar);


	//**************************
	// Install the tab view here
	//VERIFY(m_MDIClient.SubclassMDIClient(this));

//	m_ToolMain.InsertButton();



	return 0;
}
JSBool
WrapObject(JSContext *cx, JSObject *parent, jsval *vp, XPCWrappedNative* wn)
{
  NS_ASSERTION(XPCPerThreadData::IsMainThread(cx),
               "Can't do this off the main thread!");

  // Our argument should be a wrapped native object, but the caller may have
  // passed it in as an optimization.
  JSObject *wrappedObj;
  if (JSVAL_IS_PRIMITIVE(*vp) ||
      !(wrappedObj = JSVAL_TO_OBJECT(*vp)) ||
      wrappedObj->getClass() == &XOWClass) {
    return JS_TRUE;
  }

  if (!wn &&
      !(wn = XPCWrappedNative::GetAndMorphWrappedNativeOfJSObject(cx, wrappedObj))) {
    return JS_TRUE;
  }

  CheckWindow(wn);

  // The parent must be the inner global object for its scope.
  parent = JS_GetGlobalForObject(cx, parent);
  OBJ_TO_INNER_OBJECT(cx, parent);
  if (!parent) {
    return JS_FALSE;
  }

  XPCWrappedNativeWithXOW *wnxow = nsnull;
  if (wn->NeedsXOW()) {
    JSObject *innerWrappedObj = wrappedObj;
    OBJ_TO_INNER_OBJECT(cx, innerWrappedObj);
    if (!innerWrappedObj) {
      return JS_FALSE;
    }

    if (innerWrappedObj == parent) {
      wnxow = static_cast<XPCWrappedNativeWithXOW *>(wn);
      JSObject *xow = wnxow->GetXOW();
      if (xow) {
        *vp = OBJECT_TO_JSVAL(xow);
        return JS_TRUE;
      }
    }
  }

  XPCWrappedNative *parentwn =
    XPCWrappedNative::GetWrappedNativeOfJSObject(cx, parent);
  XPCWrappedNativeScope *parentScope;
  if (NS_LIKELY(parentwn)) {
    parentScope = parentwn->GetScope();
  } else {
    parentScope = XPCWrappedNativeScope::FindInJSObjectScope(cx, parent);
  }

  JSObject *outerObj = nsnull;
  WrappedNative2WrapperMap *map = parentScope->GetWrapperMap();

  outerObj = map->Find(wrappedObj);
  if (outerObj) {
    NS_ASSERTION(outerObj->getClass() == &XOWClass,
                 "What crazy object are we getting here?");
    *vp = OBJECT_TO_JSVAL(outerObj);

    if (wnxow) {
      // NB: wnxow->GetXOW() must have returned false.
      SetFlags(cx, outerObj, AddFlags(GetFlags(cx, outerObj), FLAG_IS_CACHED));
      wnxow->SetXOW(outerObj);
    }

    return JS_TRUE;
  }

  outerObj = JS_NewObjectWithGivenProto(cx, js::Jsvalify(&XOWClass), nsnull,
                                        parent);
  if (!outerObj) {
    return JS_FALSE;
  }

  jsval flags = INT_TO_JSVAL(wnxow ? FLAG_IS_CACHED : 0);
  if (!JS_SetReservedSlot(cx, outerObj, sWrappedObjSlot, *vp) ||
      !JS_SetReservedSlot(cx, outerObj, sFlagsSlot, flags) ||
      !JS_SetReservedSlot(cx, outerObj, XPC_XOW_ScopeSlot,
                          PRIVATE_TO_JSVAL(parentScope))) {
    return JS_FALSE;
  }

  *vp = OBJECT_TO_JSVAL(outerObj);

  map->Add(wn->GetScope()->GetWrapperMap(), wrappedObj, outerObj);
  if(wnxow) {
    wnxow->SetXOW(outerObj);
  }

  return JS_TRUE;
}