Esempio n. 1
0
void
StateGraphViewerPanel::
OnMouseOverDisplayable(MouseOverDisplayableEvent const &Ev)
{
  // Remove highlighting from the existing value (if any).
  if (auto const Prev = MouseOver.get()) {
    if (llvm::isa<DisplayableValue>(Prev)) {
      if (auto Access = CurrentAccess->getAccess())
        Notifier->createNotify<ConEvHighlightValue>(nullptr, CurrentAccess);
    }
    else if (llvm::isa<DisplayableDereference>(Prev)) {
      if (auto Access = CurrentAccess->getAccess())
        Notifier->createNotify<ConEvHighlightValue>(nullptr, CurrentAccess);
    }
    else if (llvm::isa<DisplayableFunctionState>(Prev)) {
      Notifier->createNotify<ConEvHighlightDecl>(nullptr);
    }
    else if (llvm::isa<DisplayableLocalState>(Prev)) {
      Notifier->createNotify<ConEvHighlightDecl>(nullptr);
    }
    else if (llvm::isa<DisplayableParamState>(Prev)) {
      Notifier->createNotify<ConEvHighlightDecl>(nullptr);
    }
    else if (llvm::isa<DisplayableGlobalVariable>(Prev)) {
      Notifier->createNotify<ConEvHighlightDecl>(nullptr);
    }
    else if (auto const DA = llvm::dyn_cast<DisplayableReferencedArea>(Prev)) {
      if (auto Access = CurrentAccess->getAccess()) {
        auto const Start = DA->getAreaStart();
        auto const MMalloc = CurrentProcess->getDynamicMemoryAllocation(Start);
        if (MMalloc.assigned<seec::cm::MallocState>()) {
          auto const &Malloc = MMalloc.get<seec::cm::MallocState>();
          if (Malloc.getAllocatorStmt())
            Notifier->createNotify<ConEvHighlightStmt>(nullptr);
        }
      }
    }
  }

  MouseOver = Ev.getDisplayableShared();

  auto const Node = MouseOver.get();

  if (!Node) {
    if (Recording)
      Recording->recordEventL("StateGraphViewer.MouseOverNone");
  }
  else if (auto const DV = llvm::dyn_cast<DisplayableValue>(Node)) {
    if (auto Access = CurrentAccess->getAccess()) {
      Notifier->createNotify<ConEvHighlightValue>(&(DV->getValue()),
                                                  CurrentAccess);
    }

    if (Recording) {
      std::vector<std::unique_ptr<IAttributeReadOnly>> Attrs;
      addAttributesForValue(Attrs, DV->getValue());
      Recording->recordEventV("StateGraphViewer.MouseOverValue", Attrs);
    }
  }
  else if (auto const DD = llvm::dyn_cast<DisplayableDereference>(Node)) {
    if (auto Access = CurrentAccess->getAccess()) {
      Notifier->createNotify<ConEvHighlightValue>(&(DD->getPointer()),
                                                  CurrentAccess);
    }

    if (Recording) {
      std::vector<std::unique_ptr<IAttributeReadOnly>> Attrs;
      addAttributesForValue(Attrs, DD->getPointer());
      Recording->recordEventV("StateGraphViewer.MouseOverDereference", Attrs);
    }
  }
  else if (auto const DF = llvm::dyn_cast<DisplayableFunctionState>(Node)) {
    auto const Decl = DF->getFunctionState().getFunctionDecl();
    Notifier->createNotify<ConEvHighlightDecl>(Decl);

    if (Recording) {
      auto const &FS = DF->getFunctionState();
      Recording->recordEventL("StateGraphViewer.MouseOverFunctionState",
                              make_attribute("function", FS.getNameAsString()));
    }
  }
  else if (auto const DL = llvm::dyn_cast<DisplayableLocalState>(Node)) {
    auto const Decl = DL->getLocalState().getDecl();
    Notifier->createNotify<ConEvHighlightDecl>(Decl);

    if (Recording) {
      // TODO
    }
  }
  else if (auto const DP = llvm::dyn_cast<DisplayableParamState>(Node)) {
    auto const Decl = DP->getParamState().getDecl();
    Notifier->createNotify<ConEvHighlightDecl>(Decl);

    if (Recording) {
      // TODO
    }
  }
  else if (auto const DG = llvm::dyn_cast<DisplayableGlobalVariable>(Node)) {
    auto const Decl = DG->getGlobalVariable().getClangValueDecl();
    Notifier->createNotify<ConEvHighlightDecl>(Decl);

    if (Recording) {
      // TODO
    }
  }
  else if (auto const DA = llvm::dyn_cast<DisplayableReferencedArea>(Node)) {
    if (auto Access = CurrentAccess->getAccess()) {
      auto const Start = DA->getAreaStart();
      auto const MayMalloc = CurrentProcess->getDynamicMemoryAllocation(Start);
      if (MayMalloc.assigned<seec::cm::MallocState>()) {
        auto const &Malloc = MayMalloc.get<seec::cm::MallocState>();
        if (auto const S = Malloc.getAllocatorStmt())
          Notifier->createNotify<ConEvHighlightStmt>(S);
      }
    }

    if (Recording) {
      Recording->recordEventL("StateGraphViewer.MouseOverReferencedArea",
                              make_attribute("start", DA->getAreaStart()),
                              make_attribute("end", DA->getAreaEnd()));
    }
  }
  else {
    wxLogDebug("Mouse over unknown Displayable.");

    if (Recording) {
      Recording->recordEventL("StateGraphViewer.MouseOverUnknown");
    }
  }
}
Esempio n. 2
0
raBid::raBid(const wxWindow* parent): wxPanel((wxWindow*)parent) {
	int i = 0;
	int j = 0;
	int best_width = 0;
	int temp_width = 0;
	int temp_height = 0;

	m_game = NULL;
	m_min_bid = 0;

	// Initializing the value of all the buttons to NULL
	for(i = 0; i < raBID_TOTAL_BTNS; ++i)
		m_buttons[i] = NULL;

	m_button_all = NULL;
	m_button_pass = NULL;

	// Calculate the best width for the buttons
	// The best width should be able to contain all bids from 14
	// to 28 and the strings "All" and "Pass"

	best_width = 0;
	for(i = 0 ; i < raBID_TOTAL_BTNS; i++) {
		this->GetTextExtent(wxString::Format(wxT("%d"), i + 14),
							&temp_width, &temp_height);
		best_width = std::max(best_width, temp_width);
	}

	this->GetTextExtent(wxT("All"), &temp_width, &temp_height);
	best_width = std::max(best_width, temp_width);
	this->GetTextExtent(wxT("Pass"), &temp_width, &temp_height);
	best_width = std::max(best_width, temp_width);

	wxLogDebug(wxString::Format(wxT("Best width %d"), best_width));

#ifdef __WXMSW__
	this->SetWindowStyle(wxRAISED_BORDER);
#endif

	m_main_panel = new wxPanel(this);
	if(!m_main_panel) {
		wxLogError(wxString::Format(wxT("Failed to create main panel. %s:%d"), wxT(__FILE__), __LINE__));
		return;
	}

#ifdef __WXMSW__
	m_main_panel->SetWindowStyle(wxSUNKEN_BORDER);
#endif

	m_main_panel->SetBackgroundColour(*wxWHITE);
	m_main_sizer = new wxGridSizer(0, 0, 0, 0);


	// TODO : Add error checks
	m_main_panel_sizer = new wxBoxSizer(wxVERTICAL);

	m_head_panel = new wxPanel(m_main_panel);
	//m_head_panel->SetWindowStyle(wxRAISED_BORDER);
	m_head_panel->SetBackgroundColour(raCLR_HEAD_DARK);
	m_head_panel->SetForegroundColour(*wxWHITE);

	m_bold_font = m_head_panel->GetFont();
	m_bold_font.SetWeight(wxFONTWEIGHT_BOLD);
	m_head_panel->SetFont(m_bold_font);

	m_head_panel_sizer = new wxGridSizer(0, 0, 0, 0);
	m_head_panel_text = new wxStaticText(m_head_panel, -1, wxT("Enter Bid"));
	m_head_panel_sizer->Add(m_head_panel_text, 0,
							wxALIGN_CENTER_HORIZONTAL| wxALIGN_CENTER_VERTICAL|wxALL, 2);

	m_head_panel->SetSizer(m_head_panel_sizer);

	m_bidbtn_panel = new wxPanel(m_main_panel);
	//m_bidbtn_panel->SetWindowStyle(wxSUNKEN_BORDER);
	m_bidbtn_panel_sizer = new wxGridSizer(5, 3, 0, 0);

	for(i = 0; i < raBID_BTN_ROWS; i++) {
		for(j = 0; j < raBID_BTN_COLS; j++) {
			m_buttons[(i * raBID_BTN_COLS) + j] = new wxButton(m_bidbtn_panel,
					raBID_BTN_ID_START + (i * raBID_BTN_COLS) + j,
					wxString::Format(wxT("%d"), (i * raBID_BTN_COLS) + j + 14),
					wxDefaultPosition, wxSize(best_width, -1));
			m_bidbtn_panel_sizer->Add(m_buttons[(i * raBID_BTN_COLS) + j], 0,
									  wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxEXPAND|wxALL, 1);
			//m_buttons[(i * raBID_BTN_COLS) + j]->SetSize(10, 20);
			//m_buttons[(i * raBID_BTN_COLS) + j]->SetWindowStyle(wxNO_BORDER);
			m_buttons[(i * raBID_BTN_COLS) + j]->SetEventHandler(this->GetEventHandler());
		}
	}

	m_bidbtn_panel->SetSizer(m_bidbtn_panel_sizer);
	m_bidbtn_panel_sizer->Fit(m_bidbtn_panel);

	// Create panel, assosiated sizer to hold the buttons
	// to bid "All" and "Pass"

	m_btns_panel = new wxPanel(m_main_panel);
	m_btns_panel_sizer = new wxGridSizer(1, 2, 0, 0);

	m_button_all = new wxButton(m_btns_panel, raBID_BTN_ID_ALL, wxT("All"));
	m_button_pass = new wxButton(m_btns_panel, raBID_BTN_ID_PASS, wxT("Pass"));

	//m_button_all->Disable();

	//m_button_all->SetWindowStyle(wxNO_BORDER);
	//m_button_pass->SetWindowStyle(wxNO_BORDER);

	m_button_all->SetEventHandler(this->GetEventHandler());
	m_button_pass->SetEventHandler(this->GetEventHandler());

	m_btns_panel_sizer->Add(m_button_all, 0,
							wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxEXPAND|wxALL, 1);
	m_btns_panel_sizer->Add(m_button_pass, 0,
							wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxEXPAND|wxALL, 1);

	m_btns_panel->SetSizer(m_btns_panel_sizer);
	m_btns_panel_sizer->Fit(m_btns_panel);

	m_main_panel_sizer->Add(m_head_panel, 0, wxEXPAND | wxALL, raBID_PNL_RELIEF);
	m_main_panel_sizer->Add(m_bidbtn_panel, 0, wxEXPAND, 0);
#ifdef __WXMSW__
	m_main_panel_sizer->Add(m_btns_panel, 0, wxEXPAND | wxBOTTOM, raBID_PNL_RELIEF * 3);
#else
	m_main_panel_sizer->Add(m_btns_panel, 0, wxEXPAND, 0);
#endif

	m_main_panel->SetSizer(m_main_panel_sizer);
	m_main_panel_sizer->Fit(m_main_panel);

	m_main_sizer->Add(m_main_panel, 0, wxEXPAND, 0);

	this->SetSizer(m_main_sizer);
	m_main_sizer->Fit(this);

	this->GetEventHandler()->Connect(raBID_BTN_ID_START, raBID_BTN_ID_START + raBID_TOTAL_BTNS - 1,
									 wxEVT_COMMAND_BUTTON_CLICKED,wxCommandEventHandler(raBid::OnButtonClick));
}
Esempio n. 3
0
bool wxAnimation::Load(wxInputStream &stream, wxAnimationType type)
{
    UnRef();

    char anim_type[12];
    switch (type)
    {
    case wxANIMATION_TYPE_GIF:
        strcpy(anim_type, "gif");
        break;

    case wxANIMATION_TYPE_ANI:
        strcpy(anim_type, "ani");
        break;

    default:
        anim_type[0] = '\0';
        break;
    }

    // create a GdkPixbufLoader
    GError *error = NULL;
    GdkPixbufLoader *loader;
    if (type != wxANIMATION_TYPE_INVALID && type != wxANIMATION_TYPE_ANY)
        loader = gdk_pixbuf_loader_new_with_type(anim_type, &error);
    else
        loader = gdk_pixbuf_loader_new();

    if (!loader)
    {
        wxLogDebug(wxT("Could not create the loader for '%s' animation type"), anim_type);
        return false;
    }

    // connect to loader signals
    g_signal_connect(loader, "area-updated", G_CALLBACK(gdk_pixbuf_area_updated), this);

    guchar buf[2048];
    while (stream.IsOk())
    {
        // read a chunk of data
        stream.Read(buf, sizeof(buf));

        // fetch all data into the loader
        if (!gdk_pixbuf_loader_write(loader, buf, stream.LastRead(), &error))
        {
            gdk_pixbuf_loader_close(loader, &error);
            wxLogDebug(wxT("Could not write to the loader"));
            return false;
        }
    }

    // load complete
    if (!gdk_pixbuf_loader_close(loader, &error))
    {
        wxLogDebug(wxT("Could not close the loader"));
        return false;
    }

    // wait until we get the last area_updated signal
    return true;
}
Esempio n. 4
0
CGKeyCode wxCharCodeWXToOSX(wxKeyCode code)
{
    CGKeyCode keycode;
    
    switch (code)
    {
        // Clang warns about switch values not of the same type as (enumerated)
        // switch controlling expression. This is generally useful but here we
        // really want to be able to use letters and digits without making them
        // part of wxKeyCode enum.
#ifdef __clang__
    #pragma clang diagnostic push
    #pragma clang diagnostic ignored "-Wswitch"
#endif // __clang__

        case 'a': case 'A':   keycode = kVK_ANSI_A; break;
        case 'b': case 'B':   keycode = kVK_ANSI_B; break;
        case 'c': case 'C':   keycode = kVK_ANSI_C; break;
        case 'd': case 'D':   keycode = kVK_ANSI_D; break;
        case 'e': case 'E':   keycode = kVK_ANSI_E; break;
        case 'f': case 'F':   keycode = kVK_ANSI_F; break;
        case 'g': case 'G':   keycode = kVK_ANSI_G; break;
        case 'h': case 'H':   keycode = kVK_ANSI_H; break;
        case 'i': case 'I':   keycode = kVK_ANSI_I; break;
        case 'j': case 'J':   keycode = kVK_ANSI_J; break;
        case 'k': case 'K':   keycode = kVK_ANSI_K; break;
        case 'l': case 'L':   keycode = kVK_ANSI_L; break;
        case 'm': case 'M':   keycode = kVK_ANSI_M; break;
        case 'n': case 'N':   keycode = kVK_ANSI_N; break;
        case 'o': case 'O':   keycode = kVK_ANSI_O; break;
        case 'p': case 'P':   keycode = kVK_ANSI_P; break;
        case 'q': case 'Q':   keycode = kVK_ANSI_Q; break;
        case 'r': case 'R':   keycode = kVK_ANSI_R; break;
        case 's': case 'S':   keycode = kVK_ANSI_S; break;
        case 't': case 'T':   keycode = kVK_ANSI_T; break;
        case 'u': case 'U':   keycode = kVK_ANSI_U; break;
        case 'v': case 'V':   keycode = kVK_ANSI_V; break;
        case 'w': case 'W':   keycode = kVK_ANSI_W; break;
        case 'x': case 'X':   keycode = kVK_ANSI_X; break;
        case 'y': case 'Y':   keycode = kVK_ANSI_Y; break;
        case 'z': case 'Z':   keycode = kVK_ANSI_Z; break;
            
        case '0':             keycode = kVK_ANSI_0; break;
        case '1':             keycode = kVK_ANSI_1; break;
        case '2':             keycode = kVK_ANSI_2; break;
        case '3':             keycode = kVK_ANSI_3; break;
        case '4':             keycode = kVK_ANSI_4; break;
        case '5':             keycode = kVK_ANSI_5; break;
        case '6':             keycode = kVK_ANSI_6; break;
        case '7':             keycode = kVK_ANSI_7; break;
        case '8':             keycode = kVK_ANSI_8; break;
        case '9':             keycode = kVK_ANSI_9; break;

#ifdef __clang__
    #pragma clang diagnostic pop
#endif // __clang__
            
        case WXK_BACK:        keycode = kVK_Delete; break;
        case WXK_TAB:         keycode = kVK_Tab; break;
        case WXK_RETURN:      keycode = kVK_Return; break;
        case WXK_ESCAPE:      keycode = kVK_Escape; break;
        case WXK_SPACE:       keycode = kVK_Space; break;
        case WXK_DELETE:      keycode = kVK_ForwardDelete; break;
            
        case WXK_SHIFT:       keycode = kVK_Shift; break;
        case WXK_ALT:         keycode = kVK_Option; break;
        case WXK_RAW_CONTROL: keycode = kVK_Control; break;
        case WXK_CONTROL:     keycode = kVK_Command; break;
            
        case WXK_CAPITAL:     keycode = kVK_CapsLock; break;
        case WXK_END:         keycode = kVK_End; break;
        case WXK_HOME:        keycode = kVK_Home; break;
        case WXK_LEFT:        keycode = kVK_LeftArrow; break;
        case WXK_UP:          keycode = kVK_UpArrow; break;
        case WXK_RIGHT:       keycode = kVK_RightArrow; break;
        case WXK_DOWN:        keycode = kVK_DownArrow; break;
            
        case WXK_HELP:        keycode = kVK_Help; break;
            
            
        case WXK_NUMPAD0:     keycode = kVK_ANSI_Keypad0; break;
        case WXK_NUMPAD1:     keycode = kVK_ANSI_Keypad1; break;
        case WXK_NUMPAD2:     keycode = kVK_ANSI_Keypad2; break;
        case WXK_NUMPAD3:     keycode = kVK_ANSI_Keypad3; break;
        case WXK_NUMPAD4:     keycode = kVK_ANSI_Keypad4; break;
        case WXK_NUMPAD5:     keycode = kVK_ANSI_Keypad5; break;
        case WXK_NUMPAD6:     keycode = kVK_ANSI_Keypad6; break;
        case WXK_NUMPAD7:     keycode = kVK_ANSI_Keypad7; break;
        case WXK_NUMPAD8:     keycode = kVK_ANSI_Keypad8; break;
        case WXK_NUMPAD9:     keycode = kVK_ANSI_Keypad9; break;
        case WXK_F1:          keycode = kVK_F1; break;
        case WXK_F2:          keycode = kVK_F2; break;
        case WXK_F3:          keycode = kVK_F3; break;
        case WXK_F4:          keycode = kVK_F4; break;
        case WXK_F5:          keycode = kVK_F5; break;
        case WXK_F6:          keycode = kVK_F6; break;
        case WXK_F7:          keycode = kVK_F7; break;
        case WXK_F8:          keycode = kVK_F8; break;
        case WXK_F9:          keycode = kVK_F9; break;
        case WXK_F10:         keycode = kVK_F10; break;
        case WXK_F11:         keycode = kVK_F11; break;
        case WXK_F12:         keycode = kVK_F12; break;
        case WXK_F13:         keycode = kVK_F13; break;
        case WXK_F14:         keycode = kVK_F14; break;
        case WXK_F15:         keycode = kVK_F15; break;
        case WXK_F16:         keycode = kVK_F16; break;
        case WXK_F17:         keycode = kVK_F17; break;
        case WXK_F18:         keycode = kVK_F18; break;
        case WXK_F19:         keycode = kVK_F19; break;
        case WXK_F20:         keycode = kVK_F20; break;
            
        case WXK_PAGEUP:      keycode = kVK_PageUp; break;
        case WXK_PAGEDOWN:    keycode = kVK_PageDown; break;
            
        case WXK_NUMPAD_DELETE:    keycode = kVK_ANSI_KeypadClear; break;
        case WXK_NUMPAD_EQUAL:     keycode = kVK_ANSI_KeypadEquals; break;
        case WXK_NUMPAD_MULTIPLY:  keycode = kVK_ANSI_KeypadMultiply; break;
        case WXK_NUMPAD_ADD:       keycode = kVK_ANSI_KeypadPlus; break;
        case WXK_NUMPAD_SUBTRACT:  keycode = kVK_ANSI_KeypadMinus; break;
        case WXK_NUMPAD_DECIMAL:   keycode = kVK_ANSI_KeypadDecimal; break;
        case WXK_NUMPAD_DIVIDE:    keycode = kVK_ANSI_KeypadDivide; break;
            
        default:
            wxLogDebug( "Unrecognised keycode %d", code );
            keycode = static_cast<CGKeyCode>(-1);
    }
    
    return keycode;
}
Esempio n. 5
0
bool BundleManager::DownloadDir(const wxString& url, const wxFileName& path, wxProgressDialog& dlg) {
	// Get list of files and folders
	RemoteProfile rp;
	vector<cxFileInfo> fiList;
	CURLcode errorCode = m_remoteThread.GetRemoteListWait(url, rp, fiList);
	if (errorCode != CURLE_OK) goto error;

	// Download files and folders
	{
		unsigned int retryCount = 0;
		for (vector<cxFileInfo>::const_iterator p = fiList.begin(); p != fiList.end(); ++p) {
			if (p->m_isDir) {
				// Create subdir
				wxFileName dir = path;
				dir.AppendDir(p->m_name);
				wxMkdir(dir.GetPath());

				const wxString dirName = p->m_name + wxT('/');
				if (!dlg.Pulse(dirName)) return false;

				// Download contents
				const wxString dirUrl = url + dirName;
				if (!DownloadDir(dirUrl, dir, dlg)) return false;
			}
			else {
				wxString filename = p->m_name;
#ifdef __WXMSW__
				filename = UrlEncode::EncodeFilename(filename); // Make filename safe for win
#endif
				wxFileName filePath = path;
				filePath.SetFullName(filename);
				const wxString pathStr = filePath.GetFullPath();

				if (!dlg.Pulse(filename)) return false;

				// Download file
				const wxString fileUrl = url + p->m_name;
				errorCode = m_remoteThread.Download(fileUrl, pathStr, rp);
				
				// Check for errors
				if (errorCode != CURLE_OK) goto error;

				// There has been some cases where the download has ended
				// up with an empty file but no error. As a workaround
				// we give it one more try and then return an error.
				if (filePath.GetSize() == 0 && p->m_size != 0) {
					if (retryCount == 0) {
						wxLogDebug(wxT("Received empty file! Retrying download"));
						++retryCount;
						--p;
						continue;
					}
					else {
						errorCode = CURLE_PARTIAL_FILE;
						goto error;
					}
				}

				// Set modDate
				filePath.SetTimes(NULL, &p->m_modDate, NULL);

				retryCount = 0;
			}
		}
	}

	return true;

error:
	wxMessageBox(m_remoteThread.GetErrorText(errorCode), _("Download Error"), wxICON_ERROR|wxOK, this);
	return false;
}
Esempio n. 6
0
void GetLanguages(wxArrayString &langCodes, wxArrayString &langNames)
{
    wxArrayString tempNames;
    wxArrayString tempCodes;
    LangHash localLanguageName;
    LangHash reverseHash;
    LangHash tempHash;

    // MM: Use only ASCII characters here to avoid problems with
    //     charset conversion on Linux platforms
    localLanguageName[wxT("ar")] = wxT("Arabic");
    localLanguageName[wxT("bg")] = wxT("Balgarski");
    localLanguageName[wxT("bs")] = wxT("Bosnian");
    localLanguageName[wxT("ca")] = wxT("Catalan");
    localLanguageName[wxT("cs")] = wxT("Czech");
    localLanguageName[wxT("da")] = wxT("Dansk");
    localLanguageName[wxT("de")] = wxT("Deutsch");
    localLanguageName[wxT("el")] = wxT("Ellinika");
    localLanguageName[wxT("en")] = wxT("English");
    localLanguageName[wxT("es")] = wxT("Espanol");
    localLanguageName[wxT("eu")] = wxT("Euskara");
    localLanguageName[wxT("fi")] = wxT("Suomi");
    localLanguageName[wxT("fr")] = wxT("Francais");
    localLanguageName[wxT("ga")] = wxT("Gaeilge");
    localLanguageName[wxT("id")] = wxT("Bahasa Indonesia"); // aka Indonesian
    localLanguageName[wxT("it")] = wxT("Italiano");
    localLanguageName[wxT("ja")] = wxT("Nihongo");
    localLanguageName[wxT("ka")] = wxT("Georgian");
    localLanguageName[wxT("km")] = wxT("Khmer");
    localLanguageName[wxT("lo")] = wxT("Lao"); // aka Laothian
    localLanguageName[wxT("lt")] = wxT("Lietuviu");
    localLanguageName[wxT("he")] = wxT("Hebrew");
    localLanguageName[wxT("hu")] = wxT("Magyar");
    localLanguageName[wxT("mk")] = wxT("Makedonski");
    localLanguageName[wxT("nl")] = wxT("Nederlands");
    localLanguageName[wxT("nb")] = wxT("Norsk");
    localLanguageName[wxT("pl")] = wxT("Polski");
    localLanguageName[wxT("pt")] = wxT("Portugues");
    localLanguageName[wxT("pt_BR")] = wxT("Portugues (Brasil)");
    localLanguageName[wxT("ru")] = wxT("Russky");
    localLanguageName[wxT("sl")] = wxT("Slovenscina");
    localLanguageName[wxT("sv")] = wxT("Svenska");
    localLanguageName[wxT("tr")] = wxT("Turkce");
    localLanguageName[wxT("uk")] = wxT("Ukrainska");
    localLanguageName[wxT("[email protected]")] = wxT("Valencian (southern Catalan)");
    localLanguageName[wxT("vi")] = wxT("Vietnamese");
    localLanguageName[wxT("zh")] = wxT("Chinese (Simplified)");
    localLanguageName[wxT("zh_TW")] = wxT("Chinese (Traditional)");

    wxArrayString audacityPathList = wxGetApp().audacityPathList;
    wxGetApp().AddUniquePathToPathList(wxString::Format(wxT("%s/share/locale"),
                                       wxT(INSTALL_PREFIX)),
                                       audacityPathList);
    int i;
    for(i=wxLANGUAGE_UNKNOWN; i<wxLANGUAGE_USER_DEFINED; i++) {
        const wxLanguageInfo *info = wxLocale::GetLanguageInfo(i);

        if (!info)
            continue;

        wxString fullCode = info->CanonicalName;
        wxString code = fullCode.Left(2);
        wxString name = info->Description;

        // Logic: Languages codes are sometimes hierarchical, with a
        // general language code and then a subheading.  For example,
        // zh_TW for Traditional Chinese and zh_CN for Simplified
        // Chinese - but just zh for Chinese in general.  First we look
        // for the full code, like zh_TW.  If that doesn't exist, we
        // look for a code corresponding to the first two letters.
        // Note that if the language for a fullCode exists but we only
        // have a name for the short code, we will use the short code's
        // name but associate it with the full code.  This allows someone
        // to drop in a new language and still get reasonable behavior.

        if (fullCode.Length() < 2)
            continue;

        if (localLanguageName[code] != wxT("")) {
            name = localLanguageName[code];
        }
        if (localLanguageName[fullCode] != wxT("")) {
            name = localLanguageName[fullCode];
        }

        if (TranslationExists(audacityPathList, fullCode)) {
            code = fullCode;
        }

        if (tempHash[code] != wxT(""))
            continue;

        if (TranslationExists(audacityPathList, code) || code==wxT("en")) {
            tempCodes.Add(code);
            tempNames.Add(name);
            tempHash[code] = name;

            /* for debugging */
            wxLogDebug(wxT("code=%s name=%s fullCode=%s name=%s -> %s\n"),
                       code.c_str(), localLanguageName[code].c_str(),
                       fullCode.c_str(), localLanguageName[fullCode].c_str(),
                       name.c_str());
        }
    }


    // JKC: Adding language for simplified audacity.
    {
        wxString code;
        wxString name;
        code = wxT("en-simple");
        name = wxT("Simplified");
        if (TranslationExists(audacityPathList, code) ) {
            tempCodes.Add(code);
            tempNames.Add(name);
            tempHash[code] = name;

            /* for debugging
            printf(wxT("code=%s name=%s fullCode=%s name=%s -> %s\n"),
                   code.c_str(), localLanguageName[code].c_str(),
                   fullCode.c_str(), localLanguageName[fullCode].c_str(),
                   name.c_str());
            */
        }
    }


    // Sort

    unsigned int j;
    for(j=0; j<tempNames.GetCount(); j++)
        reverseHash[tempNames[j]] = tempCodes[j];

    tempNames.Sort();

    for(j=0; j<tempNames.GetCount(); j++) {
        langNames.Add(tempNames[j]);
        langCodes.Add(reverseHash[tempNames[j]]);
    }
}
Esempio n. 7
0
void wxHandheldInstallCtrl::InsertUserDestinations( handheld_dest_array_type& handheld_dest_array )
{
    wxLogDebug( wxT( "Entering wxHandheldInstallCtrl::InsertUserDestinations()" ) );
    if ( handheld_dest_array.IsEmpty() ) {
        return;
    }

    // Insert by rows, starting at index zero. Achieve by getting number
    // of items in listctrl.
    int             row_to_insert;
    wxString        ram_or_card_string;
    wxString		is_usb_pause_string;
    wxArrayString   row_cells_contents;
    wxArrayInt      matching_row_numbers;
    // Insert them
    for ( size_t n = 0; n < handheld_dest_array.GetCount(); n++ ) 
    {
        row_to_insert =  m_usersListCtrl->GetItemCount();
            // Convert our handheld_target_storage_mode to the string in the column
            if( handheld_dest_array[ n ]->handheld_target_storage_mode == plkrHANDHELD_TARGET_STORAGE_MODE_SD_CARD )
            {
                ram_or_card_string = _( "SD Card" );
            } 
            else if( handheld_dest_array[ n ]->handheld_target_storage_mode == plkrHANDHELD_TARGET_STORAGE_MODE_MEMORY_STICK ) 
            {
                ram_or_card_string = _( "M.Stick" );
            } 
            else if( handheld_dest_array[ n ]->handheld_target_storage_mode == plkrHANDHELD_TARGET_STORAGE_MODE_COMPACT_FLASH )
            {
                ram_or_card_string = _( "CF Card" );
            } 
            else 
            {
                // All others are RAM.
                ram_or_card_string = _( "RAM" );
            }
            // Convert our is_usb_pause to the string in the column
            if( handheld_dest_array[ n ]->is_usb_pause == 1 )
            {
                is_usb_pause_string = _( "Yes" );
            } 
            else 
            {
                is_usb_pause_string = _( "No" ); 
            }
        // Only insert it if that user/RAM combo doesn't doesn't already exists in the
        // Empty matches from last iteration
        matching_row_numbers.Empty();
        row_cells_contents.Empty();
        
        // Make the row cell contents to look for:
        // NOTE: these must be added in the order of the columns!
        row_cells_contents.Add( handheld_dest_array[ n ]->user_name );
        row_cells_contents.Add( ram_or_card_string );
        // The card directory column goes in here
        row_cells_contents.Add( is_usb_pause_string );
        
        // Look to see if there is matching rows...
        m_usersListCtrl->find_matching_rows( row_cells_contents, &matching_row_numbers );
        // ...and if there isn't any matches...
        if ( matching_row_numbers.IsEmpty() ) 
        {
            // ..then insert row:
            m_usersListCtrl->InsertItem( row_to_insert, handheld_dest_array[ n ]->user_name, m_usersListCtrlImageId );
            m_usersListCtrl->SetItem( row_to_insert, RAM_OR_CARD_COLUMN, ram_or_card_string );
            // The 3rd column, DIRECTORY_ON_CARD_COLUMN, would go here.
            m_usersListCtrl->SetItem( row_to_insert, IS_USB_PAUSE_COLUMN, is_usb_pause_string );
        }
    }
    // Clear arrays to free memory
    matching_row_numbers.Clear();
    row_cells_contents.Clear();
    wxLogDebug( wxT( "Finished wxHandheldInstallCtrl::InsertUserDestinations()" ) );
}
long wxExecute( const wxString& command, int flags, wxProcess *process )
{
    wxCHECK_MSG( !command.empty(), 0, wxT("can't exec empty command") );
    wxLogDebug(wxString(wxT("Launching: ")) + command);

#if wxUSE_THREADS
    // fork() doesn't mix well with POSIX threads: on many systems the program
    // deadlocks or crashes for some reason. Probably our code is buggy and
    // doesn't do something which must be done to allow this to work, but I
    // don't know what yet, so for now just warn the user (this is the least we
    // can do) about it
    wxASSERT_MSG( wxThread::IsMain(),
                    _T("wxExecute() can be called only from the main thread") );
#endif // wxUSE_THREADS

    int argc = 0;
    wxChar *argv[WXEXECUTE_NARGS];
    wxString argument;
    const wxChar *cptr = command.c_str();
    wxChar quotechar = wxT('\0'); // is arg quoted?
    bool escaped = false;

    // split the command line in arguments
    do
    {
        argument=wxT("");
        quotechar = wxT('\0');

        // eat leading whitespace:
        while ( wxIsspace(*cptr) )
            cptr++;

        if ( *cptr == wxT('\'') || *cptr == wxT('"') )
            quotechar = *cptr++;

        do
        {
            if ( *cptr == wxT('\\') && ! escaped )
            {
                escaped = true;
                cptr++;
                continue;
            }

            // all other characters:
            argument += *cptr++;
            escaped = false;

            // have we reached the end of the argument?
            if ( (*cptr == quotechar && ! escaped)
                 || (quotechar == wxT('\0') && wxIsspace(*cptr))
                 || *cptr == wxT('\0') )
            {
                wxASSERT_MSG( argc < WXEXECUTE_NARGS,
                              wxT("too many arguments in wxExecute") );

                argv[argc] = new wxChar[argument.length() + 1];
                wxStrcpy(argv[argc], argument.c_str());
                argc++;

                // if not at end of buffer, swallow last character:
                if(*cptr)
                    cptr++;

                break; // done with this one, start over
            }
        } while(*cptr);
    } while(*cptr);
    argv[argc] = NULL;

    long lRc;
#if defined(__DARWIN__)
    // wxMacExecute only executes app bundles.
    // It returns an error code if the target is not an app bundle, thus falling
    // through to the regular wxExecute for non app bundles.
    lRc = wxMacExecute(argv, flags, process);
    if( lRc != ((flags & wxEXEC_SYNC) ? -1 : 0))
        return lRc;
#endif

    // do execute the command
    lRc = wxExecute(argv, flags, process);

    // clean up
    argc = 0;
    while( argv[argc] )
        delete [] argv[argc++];

    return lRc;
}
Esempio n. 9
0
// ----------------------------------------------------------------------------
// wxHIDDevice::Create
//
//  nClass is the HID Page such as
//      kHIDPage_GenericDesktop
//  nType is the HID Usage such as
//      kHIDUsage_GD_Joystick,kHIDUsage_GD_Mouse,kHIDUsage_GD_Keyboard
//  nDev is the device number to use
//
// ----------------------------------------------------------------------------
bool wxHIDDevice::Create (int nClass, int nType, int nDev)
{
    //Create the mach port
    if(IOMasterPort(bootstrap_port, &m_pPort) != kIOReturnSuccess)
    {
        wxLogSysError(wxT("Could not create mach port"));
        return false;
    }

    //Dictionary that will hold first
    //the matching dictionary for determining which kind of devices we want,
    //then later some registry properties from an iterator (see below)
    //
    //The call to IOServiceMatching filters down the
    //the services we want to hid services (and also eats the
    //dictionary up for us (consumes one reference))
    CFMutableDictionaryRef pDictionary = IOServiceMatching(kIOHIDDeviceKey);
    if(pDictionary == NULL)
    {
        wxLogSysError( wxT("IOServiceMatching(kIOHIDDeviceKey) failed") );
        return false;
    }

    //Here we'll filter down the services to what we want
    if (nType != -1)
    {
        CFNumberRef pType = CFNumberCreate(kCFAllocatorDefault,
                                    kCFNumberIntType, &nType);
        CFDictionarySetValue(pDictionary, CFSTR(kIOHIDPrimaryUsageKey), pType);
        CFRelease(pType);
    }
    if (nClass != -1)
    {
        CFNumberRef pClass = CFNumberCreate(kCFAllocatorDefault,
                                    kCFNumberIntType, &nClass);
        CFDictionarySetValue(pDictionary, CFSTR(kIOHIDPrimaryUsagePageKey), pClass);
        CFRelease(pClass);
    }

    //Now get the matching services
    io_iterator_t pIterator;
    if( IOServiceGetMatchingServices(m_pPort,
                        pDictionary, &pIterator) != kIOReturnSuccess )
    {
        wxLogSysError(wxT("No Matching HID Services"));
        return false;
    }

    //Were there any devices matched?
    if(pIterator == 0)
        return false; // No devices found

    //Now we iterate through them
    io_object_t pObject;
    while ( (pObject = IOIteratorNext(pIterator)) != 0)
    {
        if(--nDev != 0)
        {
            IOObjectRelease(pObject);
            continue;
        }

        if ( IORegistryEntryCreateCFProperties
             (
                pObject,
                &pDictionary,
                kCFAllocatorDefault,
                kNilOptions
             ) != KERN_SUCCESS )
        {
            wxLogDebug(wxT("IORegistryEntryCreateCFProperties failed"));
        }

        //
        // Now we get the attributes of each "product" in the iterator
        //

        //Get [product] name
        CFStringRef cfsProduct = (CFStringRef)
            CFDictionaryGetValue(pDictionary, CFSTR(kIOHIDProductKey));
        m_szProductName =
            wxCFStringRef( wxCFRetain(cfsProduct)
                               ).AsString();

        //Get the Product ID Key
        CFNumberRef cfnProductId = (CFNumberRef)
            CFDictionaryGetValue(pDictionary, CFSTR(kIOHIDProductIDKey));
        if (cfnProductId)
        {
            CFNumberGetValue(cfnProductId, kCFNumberIntType, &m_nProductId);
        }

        //Get the Vendor ID Key
        CFNumberRef cfnVendorId = (CFNumberRef)
            CFDictionaryGetValue(pDictionary, CFSTR(kIOHIDVendorIDKey));
        if (cfnVendorId)
        {
            CFNumberGetValue(cfnVendorId, kCFNumberIntType, &m_nManufacturerId);
        }

        //
        // End attribute getting
        //

        //Create the interface (good grief - long function names!)
        SInt32 nScore;
        IOCFPlugInInterface** ppPlugin;
        if(IOCreatePlugInInterfaceForService(pObject,
                                             kIOHIDDeviceUserClientTypeID,
                                             kIOCFPlugInInterfaceID, &ppPlugin,
                                             &nScore) !=  kIOReturnSuccess)
        {
            wxLogSysError(wxT("Could not create HID Interface for product"));
            return false;
        }

        //Now, the final thing we can check before we fall back to asserts
        //(because the dtor only checks if the device is ok, so if anything
        //fails from now on the dtor will delete the device anyway, so we can't break from this).

        //Get the HID interface from the plugin to the mach port
        if((*ppPlugin)->QueryInterface(ppPlugin,
                               CFUUIDGetUUIDBytes(kIOHIDDeviceInterfaceID),
                               (void**) &m_ppDevice) != S_OK)
        {
            wxLogSysError(wxT("Could not get device interface from HID interface"));
            return false;
        }

        //release the plugin
        (*ppPlugin)->Release(ppPlugin);

        //open the HID interface...
        if ( (*m_ppDevice)->open(m_ppDevice, 0) != S_OK )
        {
            wxLogDebug(wxT("HID device: open failed"));
        }

        //
        //Now the hard part - in order to scan things we need "cookies"
        //
        CFArrayRef cfaCookies = (CFArrayRef)CFDictionaryGetValue(pDictionary,
                                 CFSTR(kIOHIDElementKey));
        BuildCookies(cfaCookies);

        //cleanup
        CFRelease(pDictionary);
        IOObjectRelease(pObject);

        //iterator cleanup
        IOObjectRelease(pIterator);

        return true;
    }

    //iterator cleanup
    IOObjectRelease(pIterator);

    return false; //no device
}//end Create()
Esempio n. 10
0
bool MyPicsApp::OnInit()
{    
    wxImage::AddHandler( new wxJPEGHandler );
    wxImage::AddHandler( new wxICOHandler );

    // extract the applications resources to files, so we can use them.
    // we could have just put all
    // the resources in the .zip file, but then how would i have 
    // demostrated the other ExtractXXX functions? :)

    // extract all resources of same type (in this case imagess 
    // pecified as type "image" in the .rc file),in one call, 
    // u can specify any type you want, but if you
    // use a number, make shure its an unsigned int OVER 255.
    // Also note that the exCount param passed here is optional.
    int exCount=0;
    bool resOk = m_Resources.ExtractResources(wxT("image"), &exCount);
    if(resOk)
    {
        wxLogDebug(wxT("%d files extracted to %s using ExtractResources()"),
        exCount, m_Resources.GetResourceDir());
    }

    // extract a single resource file "wxmswres.h" of type "txtfile"
    // note that the resource name sould be the same in the .rc file
    // as the desired extracted file name INCLUDING EXTENSION, same
    // goes for ExtractResources()
    resOk = resOk && m_Resources.ExtractResource(wxT("wxmswres.h"),
        wxT("txtfile"));

    if(resOk)
    {
        wxLogDebug(wxT("resource file wxmswres.h extracted to %s using ExtractResource()"),
            m_Resources.GetResourceDir());
    }

    // extract resources contained in a zip file, in this case, the .mo 
    // catalog files, compressed to reduce .exe size
    exCount=0;
    resOk = resOk && m_Resources.ExtractZipResources(wxT("langcats"),
        wxT("zipfile"), &exCount);
    if(resOk)
    {
        wxLogDebug(wxT("%d files extracted to %s using ExtractZipResources()"),
            exCount, m_Resources.GetResourceDir());
    }

    // if the ExtractXXX functions returned true, the resources were
    // extracted successfully, but still you can check if some
    // resource is actually there using this function
    if(m_Resources.RcExtracted(wxT("wx_es.mo")))
        wxLogDebug(wxT("guess what??, wx_ex.mo was extracted successfully"));

    if(!resOk)
    {
        // oops! something went wrong, we better quit here
        wxMessageBox(_("Failed to extract the app´s resources.\nTerminating app..."),
            _("Fatal Error"), wxOK | wxCENTRE | wxICON_ERROR);
        return false;
    }

    // ask user for application language
    DlgLang dlg(NULL);
    wxString langName = dlg.GetSelLanguage();

    // now set the locale & load the app & standar wxWidgets catalogs
    // (previously extracted), but only if selected language was spanish, 
    // since wxWidgets & strings in source code are in english
    
    // set lookup path to our resource dir first!! , or wxLocale
    // will NOT find the catalogs & fail!
    m_Locale.AddCatalogLookupPathPrefix(m_Resources.GetResourceDir());

    bool iInitOk = false; bool cInitOk = false;
    int langId = langName==_("Spanish") ? 
        wxLANGUAGE_SPANISH_MODERN : wxLANGUAGE_ENGLISH_US;

    iInitOk= m_Locale.Init(langId, wxLOCALE_CONV_ENCODING);
    if(!iInitOk)
        wxLogDebug(wxT("Failed to initialize locale!"));

    if(iInitOk && langId == wxLANGUAGE_SPANISH_MODERN)
    {
        cInitOk = m_Locale.AddCatalog(wxT("wx_es"));
        cInitOk = cInitOk && m_Locale.AddCatalog(wxT("mypics_es"));
    }
    if(!cInitOk)
        wxLogDebug(wxT("Failed to load one or more catalogs!"));

    // create the app´s main window (go look at MyFrame´s creation code)
    MyFrame* pFrame = new MyFrame(NULL);
    pFrame->Maximize();
    pFrame->Show();
    SetTopWindow(pFrame);
    return true;
}
Esempio n. 11
0
void SjPlayer::DoReceiveSignal(int signal, uintptr_t extraLong)
{
	if( !m_impl->InitXine() ) {
		return; // error
	}

	if( signal == THREAD_PREPARE_NEXT )
	{
		// find out the next url to play
		wxString	newUrl;
		//long		newQueueId = 0;
		long		newQueuePos = m_queue.GetCurrPos();

		// try to get next url from queue
		newQueuePos = m_queue.GetNextPos(SJ_PREVNEXT_REGARD_REPEAT);
		if( newQueuePos == -1 )
		{
			// try to enqueue auto-play url
			g_mainFrame->m_autoCtrl.DoAutoPlayIfEnabled(false /*ignoreTimeouts*/);
			newQueuePos = m_queue.GetNextPos(SJ_PREVNEXT_REGARD_REPEAT);

			if( newQueuePos == -1 )
			{
				// no chance, there is nothing more to play ...
				if( signal == THREAD_OUT_OF_DATA )
				{
					Stop();
					SendSignalToMainThread(IDMODMSG_PLAYER_STOPPED_BY_EOQ);
				}
				return;
			}
		}
		newUrl = m_queue.GetUrlByPos(newQueuePos);
		//newQueueId = m_queue.GetIdByPos(newQueuePos);

		// has the URL just failed? try again in the next message look
		wxLogDebug(wxT(" ... SjPlayer::ReceiveSignal(): new URL is \"%s\""), newUrl.c_str());

		if( m_failedUrls.Index( newUrl ) != wxNOT_FOUND )
		{
			wxLogDebug(wxT(" ... SjPlayer::ReceiveSignal(): the URL has failed before, starting over."));
			m_queue.SetCurrPos(newQueuePos);
			SendSignalToMainThread(signal); // start over
			return;
		}

		// try to create the next stream
        if( m_impl->m_currStream ) {
			delete m_impl->m_currStream;
			m_impl->m_currStream = NULL;
		}
		m_impl->m_currStream = new SjXineStream(m_impl, newUrl);
		if( !m_impl->m_currStream->XinePlay() ) {
			wxLogDebug(wxT(" ... SjPlayer::ReceiveSignal(): cannot create the new stream."));
			delete m_impl->m_currStream;
			m_impl->m_currStream = NULL;
		}

		// realize the new position in the UI
		m_queue.SetCurrPos(newQueuePos);
		SendSignalToMainThread(IDMODMSG_TRACK_ON_AIR_CHANGED);
	}
}
Esempio n. 12
0
wxString PCB_BASE_FRAME::SelectFootprint( EDA_DRAW_FRAME* aWindow,
                                          const wxString& aLibraryName,
                                          const wxString& aMask,
                                          const wxString& aKeyWord,
                                          FP_LIB_TABLE*   aTable )
{
    static wxString oldName;    // Save the name of the last module loaded.

    wxString        fpname;
    wxString        msg;
    wxArrayString   libraries;

    std::vector< wxArrayString > rows;

    wxASSERT( aTable != NULL );

    MList.ReadFootprintFiles( aTable, !aLibraryName ? NULL : &aLibraryName );

    if( MList.GetErrorCount() )
    {
        MList.DisplayErrors( this );
        return wxEmptyString;
    }

    if( MList.GetCount() == 0 )
    {
        wxString tmp;

        for( unsigned i = 0;  i < libraries.GetCount();  i++ )
        {
            tmp += libraries[i] + wxT( "\n" );
        }

        msg.Printf( _( "No footprints could be read from library file(s):\n\n%s\nin any of "
                       "the library search paths.  Verify your system is configured properly "
                       "so the footprint libraries can be found." ), GetChars( tmp ) );
        DisplayError( aWindow, msg );
        return wxEmptyString;
    }

    if( !aKeyWord.IsEmpty() )       // Create a list of modules found by keyword.
    {
        for( unsigned ii = 0; ii < MList.GetCount(); ii++ )
        {
            if( KeyWordOk( aKeyWord, MList.GetItem( ii ).GetKeywords() ) )
            {
                wxArrayString   cols;
                cols.Add( MList.GetItem( ii ).GetFootprintName() );
                cols.Add( MList.GetItem( ii ).GetNickname() );
                rows.push_back( cols );
            }
        }
    }
    else if( !aMask.IsEmpty() )     // Create a list of modules found by pattern
    {
        for( unsigned ii = 0; ii < MList.GetCount(); ii++ )
        {
            const wxString& candidate = MList.GetItem( ii ).GetFootprintName();

            if( WildCompareString( aMask, candidate, false ) )
            {
                wxArrayString   cols;
                cols.Add( MList.GetItem( ii ).GetFootprintName() );
                cols.Add( MList.GetItem( ii ).GetNickname() );
                rows.push_back( cols );
            }
        }
    }
    else                            // Create the full list of modules
    {
        for( unsigned ii = 0; ii < MList.GetCount(); ii++ )
        {
            wxArrayString   cols;
            cols.Add( MList.GetItem( ii ).GetFootprintName() );
            cols.Add( MList.GetItem( ii ).GetNickname() );
            rows.push_back( cols );
        }
    }

    if( !rows.empty() )
    {
        wxArrayString headers;

        headers.Add( _( "Footprint" ) );
        headers.Add( _( "Library" ) );

        msg.Printf( _( "Footprints [%d items]" ), (int) rows.size() );

        EDA_LIST_DIALOG dlg( aWindow, msg, headers, rows, oldName, DisplayCmpDoc );

        if( dlg.ShowModal() == wxID_OK )
        {
            fpname = dlg.GetTextSelection();

            fpname = dlg.GetTextSelection( 1 ) + wxT( ":" ) + fpname;

            SkipNextLeftButtonReleaseEvent();
        }
        else
            fpname.Empty();
    }
    else
    {
        DisplayError( aWindow, _( "No footprint found." ) );
        fpname.Empty();
    }

    if( fpname != wxEmptyString )
        oldName = fpname;

    wxLogDebug( wxT( "Footprint '%s' was selected." ), GetChars( fpname ) );

    return fpname;
}
Esempio n. 13
0
MODULE* PCB_BASE_FRAME::LoadModuleFromLibrary( const wxString& aLibrary,
                                               FP_LIB_TABLE*   aTable,
                                               bool            aUseFootprintViewer,
                                               wxDC*           aDC )
{
    MODULE*     module = NULL;
    wxPoint     curspos = GetCrossHairPosition();
    wxString    moduleName, keys;
    wxString    libName = aLibrary;
    bool        allowWildSeach = true;

    static wxArrayString HistoryList;
    static wxString      lastComponentName;

    // Ask for a component name or key words
    DIALOG_GET_COMPONENT dlg( this, HistoryList, _( "Load Footprint" ), aUseFootprintViewer );

    dlg.SetComponentName( lastComponentName );

    if( dlg.ShowModal() == wxID_CANCEL )
        return NULL;

    if( dlg.m_GetExtraFunction )
    {
        // SelectFootprintFromLibBrowser() returns the "full" footprint name, i.e.
        // <lib_name>/<footprint name> or FPID format "lib_name:fp_name:rev#"
        moduleName = SelectFootprintFromLibBrowser();
    }
    else
    {
        moduleName = dlg.GetComponentName();
    }

    if( moduleName.IsEmpty() )  // Cancel command
    {
        m_canvas->MoveCursorToCrossHair();
        return NULL;
    }

    if( dlg.IsKeyword() )                          // Selection by keywords
    {
        allowWildSeach = false;
        keys = moduleName;
        moduleName = SelectFootprint( this, libName, wxEmptyString, keys, aTable );

        if( moduleName.IsEmpty() )                 // Cancel command
        {
            m_canvas->MoveCursorToCrossHair();
            return NULL;
        }
    }
    else if( moduleName.Contains( wxT( "?" ) )
           || moduleName.Contains( wxT( "*" ) ) )  // Selection wild card
    {
        allowWildSeach = false;
        moduleName     = SelectFootprint( this, libName, moduleName, wxEmptyString, aTable );

        if( moduleName.IsEmpty() )
        {
            m_canvas->MoveCursorToCrossHair();
            return NULL;                           // Cancel command.
        }
    }

    FPID fpid;

    wxCHECK_MSG( fpid.Parse( moduleName ) < 0, NULL,
                 wxString::Format( wxT( "Could not parse FPID string '%s'." ),
                                   GetChars( moduleName ) ) );

    try
    {
        module = loadFootprint( fpid );
    }
    catch( const IO_ERROR& ioe )
    {
        wxLogDebug( wxT( "An error occurred attemping to load footprint '%s'.\n\nError: %s" ),
                    fpid.Format().c_str(), GetChars( ioe.errorText ) );
    }

    if( !module && allowWildSeach )                // Search with wild card
    {
        allowWildSeach = false;

        wxString wildname = wxChar( '*' ) + moduleName + wxChar( '*' );
        moduleName = wildname;

        moduleName = SelectFootprint( this, libName, moduleName, wxEmptyString, aTable );

        if( moduleName.IsEmpty() )
        {
            m_canvas->MoveCursorToCrossHair();
            return NULL;    // Cancel command.
        }
        else
        {
            FPID fpid;

            wxCHECK_MSG( fpid.Parse( moduleName ) < 0, NULL,
                         wxString::Format( wxT( "Could not parse FPID string '%s'." ),
                                           GetChars( moduleName ) ) );

            try
            {
                module = loadFootprint( fpid );
            }
            catch( const IO_ERROR& ioe )
            {
                wxLogDebug( wxT( "An error occurred attemping to load footprint '%s'.\n\nError: %s" ),
                            fpid.Format().c_str(), GetChars( ioe.errorText ) );
            }
        }
    }

    SetCrossHairPosition( curspos );
    m_canvas->MoveCursorToCrossHair();

    if( module )
    {
        GetBoard()->Add( module, ADD_APPEND );

        lastComponentName = moduleName;
        AddHistoryComponentName( HistoryList, moduleName );

        module->SetFlags( IS_NEW );
        module->SetLink( 0 );

        if( IsGalCanvasActive() )
            module->SetPosition( wxPoint( 0, 0 ) ); // cursor in GAL may not be initialized at the moment
        else
            module->SetPosition( curspos );

        module->SetTimeStamp( GetNewTimeStamp() );
        GetBoard()->m_Status_Pcb = 0;

        // Put it on FRONT layer,
        // (Can be stored flipped if the lib is an archive built from a board)
        if( module->IsFlipped() )
            module->Flip( module->GetPosition() );

        // Place it in orientation 0,
        // even if it is not saved with orientation 0 in lib
        // (Can happen if the lib is an archive built from a board)
        Rotate_Module( NULL, module, 0, false );

        RecalculateAllTracksNetcode();

        if( aDC )
            module->Draw( m_canvas, aDC, GR_OR );
    }

    return module;
}
Esempio n. 14
0
void StateGraphViewerPanel::OnContextMenu(wxContextMenuEvent &Ev)
{
  if (!MouseOver)
    return;
  
  UErrorCode Status = U_ZERO_ERROR;
  auto const TextTable = seec::getResource("TraceViewer",
                                           getLocale(),
                                           Status,
                                           "StateGraphViewer");
  if (U_FAILURE(Status)) {
    wxLogDebug("Couldn't get StateGraphViewer resources.");
    return;
  }
  
  auto const TheNode = MouseOver.get();
  
  if (auto const DV = llvm::dyn_cast<DisplayableValue>(TheNode)) {
    auto const ValuePtr = &(DV->getValue());
    
    wxMenu CM{};
    
    addValueNavigation(*this, CurrentAccess, CM, *ValuePtr, *CurrentProcess,
                       Recording);
    
    // Allow the user to select the Value's layout engine.
    std::unique_lock<std::mutex> LockLayoutHandler(LayoutHandlerMutex);
    auto const Engines = LayoutHandler->listLayoutEnginesSupporting(*ValuePtr);
    LockLayoutHandler.unlock();
    
    if (Engines.size() > 1) {
      auto SM = seec::makeUnique<wxMenu>();
      
      for (auto const E : Engines) {
        auto const LazyName = E->getName();
        if (!LazyName)
          continue;
        
        UErrorCode Status = U_ZERO_ERROR;
        auto const Name = LazyName->get(Status, getLocale());
        if (U_FAILURE(Status))
          continue;
        
        std::string UTF8Name;
        Name.toUTF8String(UTF8Name);
        
        auto const EngineID = reinterpret_cast<uintptr_t>(E);
        
        BindMenuItem(
          SM->Append(wxID_ANY, wxString{UTF8Name}),
          [=] (wxEvent &Ev) -> void {
            {
              std::lock_guard<std::mutex> LLH(this->LayoutHandlerMutex);
              this->LayoutHandler->setLayoutEngine(*ValuePtr, EngineID);
            }
            this->renderGraph();
          });
      }
      
      CM.AppendSubMenu(SM.release(),
                       seec::getwxStringExOrEmpty(TextTable,
                                                  "CMValueDisplayAs"));
    }
    
    PopupMenu(&CM);
  }
  else if (auto const DD = llvm::dyn_cast<DisplayableDereference>(TheNode)) {
    auto const ValOfPtr = &(DD->getPointer());
    
    wxMenu CM{};
    
    BindMenuItem(
      CM.Append(wxID_ANY,
                seec::getwxStringExOrEmpty(TextTable, "CMDereferenceUse")),
      [=] (wxEvent &Ev) -> void {
        {
          std::lock_guard<std::mutex> LLH(this->LayoutHandlerMutex);
          this->LayoutHandler->setAreaReference(*ValOfPtr);
        }
        this->renderGraph();
      });
    
    PopupMenu(&CM);
  }
  else if (auto const DF = llvm::dyn_cast<DisplayableFunctionState>(TheNode)) {
    wxMenu CM{};
    
    auto const FnPtr = &(DF->getFunctionState());
    
    BindMenuItem(
      CM.Append(wxID_ANY,
                seec::getwxStringExOrEmpty(TextTable,
                                           "CMFunctionRewindEntry")),
      [=] (wxEvent &Ev) -> void {
        raiseMovementEvent(*this, this->CurrentAccess,
          [=] (seec::cm::ProcessState &State) {
            return seec::cm::moveToFunctionEntry(*FnPtr);
          });
      });
    
    BindMenuItem(
      CM.Append(wxID_ANY,
                seec::getwxStringExOrEmpty(TextTable,
                                           "CMFunctionForwardExit")),
      [=] (wxEvent &Ev) -> void {
        raiseMovementEvent(*this, this->CurrentAccess,
          [=] (seec::cm::ProcessState &State) {
            return seec::cm::moveToFunctionFinished(*FnPtr);
          });
      });
    
    PopupMenu(&CM);
  }
  else if (auto const DA = llvm::dyn_cast<DisplayableReferencedArea>(TheNode)) {
    auto const Area = seec::MemoryArea(DA->getAreaStart(), DA->getAreaEnd());
    auto const ValOfPtr = &(DA->getPointer());
    
    wxMenu CM{};
    
    // Allow the user to select the Area's layout engine.
    std::unique_lock<std::mutex> LLH(LayoutHandlerMutex);
    auto const Engines = LayoutHandler->listLayoutEnginesSupporting(Area,
                                                                    *ValOfPtr);
    LLH.unlock();
    
    if (Engines.size() > 1) {
      auto SM = seec::makeUnique<wxMenu>();
      
      for (auto const E : Engines) {
        auto const LazyName = E->getName();
        if (!LazyName)
          continue;
        
        UErrorCode Status = U_ZERO_ERROR;
        auto const Name = LazyName->get(Status, getLocale());
        if (U_FAILURE(Status))
          continue;
        
        std::string UTF8Name;
        Name.toUTF8String(UTF8Name);
        
        auto const EngineID = reinterpret_cast<uintptr_t>(E);
        
        BindMenuItem(
          SM->Append(wxID_ANY, wxString{UTF8Name}),
          [=] (wxEvent &Ev) -> void {
            {
              std::lock_guard<std::mutex> LLH(this->LayoutHandlerMutex);
              this->LayoutHandler->setLayoutEngine(Area, *ValOfPtr, EngineID);
            }
            this->renderGraph();
          });
      }
      
      CM.AppendSubMenu(SM.release(),
                       seec::getwxStringExOrEmpty(TextTable,
                                                  "CMAreaDisplayAs"));
    }
    
    PopupMenu(&CM);
  }
  else {
    wxLogDebug("Unknown Displayable!");
  }
}
Esempio n. 15
0
bool wxGISRasterDataset::Open(void)
{
	if(m_bIsOpened)
		return true;

	wxCriticalSectionLocker locker(m_CritSect);


	m_poDataset = (GDALDataset *) GDALOpen( wgWX2MB(m_sPath.c_str()), GA_ReadOnly );
	if( m_poDataset == NULL )
		return false;

	int nXSize = m_poDataset->GetRasterXSize();
	int nYSize = m_poDataset->GetRasterYSize();

	bool bHasOverviews = false;


	char** papszFileList = m_poDataset->GetFileList();
    if( CSLCount(papszFileList) == 0 )
    {
        wxLogDebug(wxT( "Files: none associated" ));
    }
    else
    {
        wxLogDebug(wxT("Files: %s"), wgMB2WX(papszFileList[0]) );
        for(int i = 1; papszFileList[i] != NULL; i++ )
		{
			wxString sFileName = wgMB2WX(papszFileList[i]);
			if(sFileName.Find(wxT(".rrd")) != wxNOT_FOUND || sFileName.Find(wxT(".ovr")) != wxNOT_FOUND)
				bHasOverviews = true;
			wxLogDebug( wxT("       %s"), sFileName.c_str() );
		}
    }
    CSLDestroy( papszFileList );

	CPLSetConfigOption( "USE_RRD", "YES" );
	CPLSetConfigOption( "HFA_USE_RRD", "YES" );
	CPLSetConfigOption( "COMPRESS_OVERVIEW", "LZW" );

	bool bAskCreateOvr = false;
	if(!bHasOverviews && bAskCreateOvr)
	{
		int anOverviewList[5] = { 4, 8, 16, 32, 64 };
		CPLErr err = m_poDataset->BuildOverviews( "CUBIC", 5, anOverviewList, 0, NULL, GDALDummyProgress, NULL );
		//"NEAREST", "GAUSS", "CUBIC", "AVERAGE", "MODE", "AVERAGE_MAGPHASE" or "NONE" 
	}

	//GDALDriver* pDrv = m_poDataset->GetDriver();
	//const char* desc = pDrv->GetDescription();
	//wxLogDebug( wxT("Driver: %s/%s"), wgMB2WX(GDALGetDriverShortName( pDrv )), wgMB2WX(GDALGetDriverLongName( pDrv )) );

	//char** papszMetadata = m_poDataset->GetMetadata();
 //   if( CSLCount(papszMetadata) > 0 )
 //   {
 //       wxLogDebug( wxT( "Metadata:" ));
 //       for(int i = 0; papszMetadata[i] != NULL; i++ )
 //       {
 //           wxLogDebug( wxT( "  %s"), wgMB2WX(papszMetadata[i]) );
 //       }
 //   }

	///* -------------------------------------------------------------------- */
	///*      Report "IMAGE_STRUCTURE" metadata.                              */
	///* -------------------------------------------------------------------- */
 //   papszMetadata = m_poDataset->GetMetadata("IMAGE_STRUCTURE");
 //   if( CSLCount(papszMetadata) > 0 )
 //   {
 //       wxLogDebug( wxT( "Image Structure Metadata:" ));
 //       for(int i = 0; papszMetadata[i] != NULL; i++ )
 //       {
 //           wxLogDebug( wxT(  "  %s"), wgMB2WX(papszMetadata[i]) );
 //       }
 //   }

	///* -------------------------------------------------------------------- */
	///*      Report subdatasets.                                             */
	///* -------------------------------------------------------------------- */
 //   papszMetadata = m_poDataset->GetMetadata("SUBDATASETS");
 //   if( CSLCount(papszMetadata) > 0 )
 //   {
 //       wxLogDebug( wxT( "Subdatasets:" ));
 //       for(int i = 0; papszMetadata[i] != NULL; i++ )
 //       {
 //           wxLogDebug( wxT( "  %s"), wgMB2WX(papszMetadata[i]) );
 //       }
 //   }

	///* -------------------------------------------------------------------- */
	///*      Report geolocation.                                             */
	///* -------------------------------------------------------------------- */
 //   papszMetadata = m_poDataset->GetMetadata("GEOLOCATION");
 //   if( CSLCount(papszMetadata) > 0 )
 //   {
 //       wxLogDebug( wxT( "Geolocation:" ));
 //       for(int i = 0; papszMetadata[i] != NULL; i++ )
 //       {
 //           wxLogDebug( wxT( "  %s"), wgMB2WX(papszMetadata[i]) );
 //       }
 //   }

	///* -------------------------------------------------------------------- */
	///*      Report RPCs                                                     */
	///* -------------------------------------------------------------------- */
 //   papszMetadata = m_poDataset->GetMetadata("RPC");
 //   if( CSLCount(papszMetadata) > 0 )
 //   {
 //       wxLogDebug( wxT( "RPC Metadata:" ));
 //       for(int i = 0; papszMetadata[i] != NULL; i++ )
 //       {
 //           wxLogDebug( wxT( "  %s"), wgMB2WX(papszMetadata[i]) );
 //       }
 //   }

	//for(int nBand = 0; nBand < m_poDataset->GetRasterCount(); nBand++ )
 //   {
 //       double      dfMin, dfMax, adfCMinMax[2], dfNoData;
 //       int         bGotMin, bGotMax, bGotNodata, bSuccess;
 //       int         nBlockXSize, nBlockYSize, nMaskFlags;
 //       double      dfMean, dfStdDev;
 //       GDALColorTable*	hTable;
 //       CPLErr      eErr;

	//	GDALRasterBand* pBand = m_poDataset->GetRasterBand(nBand + 1);

 //       //if( bSample )
 //       //{
 //       //    float afSample[10000];
 //       //    int   nCount;

 //       //    nCount = GDALGetRandomRasterSample( hBand, 10000, afSample );
 //       //    printf( "Got %d samples.\n", nCount );
 //       //}
 //       
	//	pBand->GetBlockSize(&nBlockXSize, &nBlockYSize);
	//	wxLogDebug( wxT( "Band %d Block=%dx%d Type=%s, ColorInterp=%s"), nBand + 1, nBlockXSize, nBlockYSize, wgMB2WX(GDALGetDataTypeName(pBand->GetRasterDataType())), wgMB2WX(GDALGetColorInterpretationName(pBand->GetColorInterpretation())));

	//	wxString sDescription = wgMB2WX(pBand->GetDescription());
 //       wxLogDebug( wxT( "  Description = %s"), sDescription.c_str());

	//	dfMin = pBand->GetMinimum(&bGotMin);
	//	dfMax = pBand->GetMaximum(&bGotMax);
 //       if( bGotMin || bGotMax )
 //       {
 //           if( bGotMin )
 //               wxLogDebug( wxT( "Min=%.3f "), dfMin );
 //           if( bGotMax )
 //               wxLogDebug( wxT( "Max=%.3f "), dfMax );
 //       
	//		pBand->ComputeRasterMinMax(FALSE, adfCMinMax );
 //           wxLogDebug( wxT("  Computed Min/Max=%.3f,%.3f"), adfCMinMax[0], adfCMinMax[1] );
 //       }

 //       eErr = pBand->GetStatistics(TRUE, TRUE, &dfMin, &dfMax, &dfMean, &dfStdDev );
 //       if( eErr == CE_None )
 //       {
 //           wxLogDebug( wxT("  Minimum=%.3f, Maximum=%.3f, Mean=%.3f, StdDev=%.3f"), dfMin, dfMax, dfMean, dfStdDev );
 //       }

 //       //if( bReportHistograms )
 //       //{
 //       //    int nBucketCount, *panHistogram = NULL;

 //       //    eErr = GDALGetDefaultHistogram( hBand, &dfMin, &dfMax, 
 //       //                                    &nBucketCount, &panHistogram, 
 //       //                                    TRUE, GDALTermProgress, NULL );
 //       //    if( eErr == CE_None )
 //       //    {
 //       //        int iBucket;

 //       //        printf( "  %d buckets from %g to %g:\n  ",
 //       //                nBucketCount, dfMin, dfMax );
 //       //        for( iBucket = 0; iBucket < nBucketCount; iBucket++ )
 //       //            printf( "%d ", panHistogram[iBucket] );
 //       //        printf( "\n" );
 //       //        CPLFree( panHistogram );
 //       //    }
 //       //}

 //       //wxLogDebug( wxT("  Checksum=%d"), GDALChecksumImage(pBand, 0, 0, nXSize, nYSize));

	//	dfNoData = pBand->GetNoDataValue(&bGotNodata );
 //       if( bGotNodata )
 //       {
 //           wxLogDebug( wxT("  NoData Value=%.18g"), dfNoData );
 //       }

	//	if( pBand->GetOverviewCount() > 0 )
 //       {
	//		wxString sOut(wxT("  Overviews: " ));
 //           for(int iOverview = 0; iOverview < pBand->GetOverviewCount(); iOverview++ )
 //           {
 //               const char *pszResampling = NULL;

 //               if( iOverview != 0 )
 //                   sOut += wxT( ", " );

	//			GDALRasterBand*	pOverview = pBand->GetOverview( iOverview );
	//			sOut += wxString::Format(wxT("%dx%d"), pOverview->GetXSize(), pOverview->GetYSize());

	//			pszResampling = pOverview->GetMetadataItem("RESAMPLING", "" );
 //               if( pszResampling != NULL && EQUALN(pszResampling, "AVERAGE_BIT2", 12) )
 //                   sOut += wxT( "*" );
 //           }
 //           wxLogDebug(sOut);

 //  //         sOut = wxT( "  Overviews checksum: " );
 //  //         for(int iOverview = 0; iOverview < pBand->GetOverviewCount(); iOverview++ )
	//		//{
 //  //             if( iOverview != 0 )
 //  //                 sOut += wxT( ", " );

	//		//	GDALRasterBand*	pOverview = pBand->GetOverview( iOverview );
	//		//	sOut += GDALChecksumImage(pOverview, 0, 0, pOverview->GetXSize(), pOverview->GetYSize());
 //  //         }
 //  //         wxLogDebug(sOut);
	//	}

	//	if( pBand->HasArbitraryOverviews() )
 //       {
 //          wxLogDebug( wxT("  Overviews: arbitrary" ));
 //       }
 //       
	//	nMaskFlags = pBand->GetMaskFlags();
 //       if( (nMaskFlags & (GMF_NODATA|GMF_ALL_VALID)) == 0 )
 //       {
	//		GDALRasterBand* pMaskBand = pBand->GetMaskBand() ;

 //           wxLogDebug( wxT("  Mask Flags: " ));
 //           if( nMaskFlags & GMF_PER_DATASET )
 //               wxLogDebug( wxT("PER_DATASET " ));
 //           if( nMaskFlags & GMF_ALPHA )
 //               wxLogDebug( wxT("ALPHA " ));
 //           if( nMaskFlags & GMF_NODATA )
 //               wxLogDebug( wxT("NODATA " ));
 //           if( nMaskFlags & GMF_ALL_VALID )
 //              wxLogDebug( wxT("ALL_VALID " ));    

	//		if( pMaskBand != NULL && pMaskBand->GetOverviewCount() > 0 )
 //           {
 //               int		iOverview;

 //               wxLogDebug( wxT("  Overviews of mask band: " ));
 //               for( int nOverview = 0; nOverview < pMaskBand->GetOverviewCount(); nOverview++ )
 //               {
 //                   GDALRasterBand*	pOverview;

 //                   if( nOverview != 0 )
 //                       wxLogDebug( wxT(", " ));

	//				pOverview = pMaskBand->GetOverview( nOverview );
 //                   wxLogDebug( wxT("%dx%d"), pOverview->GetXSize(), pOverview->GetYSize());
 //               }
 //           }
 //       }

	//	if( strlen(pBand->GetUnitType()) > 0 )
 //       {
	//		wxLogDebug( wxT("  Unit Type: %s"),wgMB2WX( pBand->GetUnitType()) );
 //       }

	//	char **papszCategories = pBand->GetCategoryNames();
 //       if( papszCategories != NULL )
 //       {            
 //           int i;
 //           wxLogDebug( wxT("  Categories:" ));
 //           for( i = 0; papszCategories[i] != NULL; i++ )
 //               wxLogDebug( wxT("    %3d: %s"), i, wgMB2WX(papszCategories[i]) );
 //       }

	//	if( pBand->GetScale( &bSuccess ) != 1.0 || pBand->GetOffset( &bSuccess ) != 0.0 )
 //           wxLogDebug( wxT("  Offset: %.15g,   Scale:%.15g"), pBand->GetOffset( &bSuccess ), pBand->GetScale( &bSuccess ) );

	//	papszMetadata = pBand->GetMetadata();
 //       if( CSLCount(papszMetadata) > 0 )
 //       {
 //           wxLogDebug( wxT("  Metadata:" ));
 //           for( int i = 0; papszMetadata[i] != NULL; i++ )
 //           {
 //               wxLogDebug( wxT("    %s"), wgMB2WX(papszMetadata[i]) );
 //           }
 //       }

 //       papszMetadata = pBand->GetMetadata( "IMAGE_STRUCTURE" );
 //       if( CSLCount(papszMetadata) > 0 )
 //       {
 //           wxLogDebug( wxT("  Image Structure Metadata:" ));
 //           for( int i = 0; papszMetadata[i] != NULL; i++ )
 //           {
 //               wxLogDebug( wxT("    %s"), wgMB2WX(papszMetadata[i]));
 //           }
 //       }

	//	if( pBand->GetColorInterpretation() == GCI_PaletteIndex && (hTable = pBand->GetColorTable()) != NULL )
 //       {
 //           int			i;

	//		wxLogDebug( wxT("  Color Table (%s with %d entries)"), wgMB2WX(GDALGetPaletteInterpretationName(hTable->GetPaletteInterpretation())), hTable->GetColorEntryCount() );

	//		for( i = 0; i < hTable->GetColorEntryCount(); i++ )
 //           {
 //               GDALColorEntry	sEntry;

	//			hTable->GetColorEntryAsRGB(i, &sEntry );
 //               wxLogDebug( wxT("  %3d: %d,%d,%d,%d"), i, sEntry.c1, sEntry.c2, sEntry.c3, sEntry.c4 );
 //           }
 //       }

	//	if( pBand->GetDefaultRAT() != NULL )
 //       {
	//		const GDALRasterAttributeTable* pRAT = (const GDALRasterAttributeTable*)pBand->GetDefaultRAT();
	//		GDALRasterAttributeTable* pRATn = (GDALRasterAttributeTable*)pRAT;
	//		pRATn->DumpReadable();
 //       }
	//}

    //CPLCleanupTLS();

	m_psExtent = new OGREnvelope();
	double adfGeoTransform[6];	
	if(m_poDataset->GetGeoTransform( adfGeoTransform ) != CE_Fatal )
	{
		double inX[4];
		double inY[4];

		inX[0] = 0;
		inY[0] = 0;
		inX[1] = nXSize;
		inY[1] = 0;
		inX[2] = nXSize;
		inY[2] = nYSize;
		inX[3] = 0;
		inY[3] = nYSize;

		m_psExtent->MaxX = 0;
		m_psExtent->MaxY = 0;
		m_psExtent->MinX = 1000000000;
		m_psExtent->MinY = 1000000000;
		for(int i = 0; i < 4; i++)
		{
			double rX, rY;
			GDALApplyGeoTransform( adfGeoTransform, inX[i], inY[i], &rX, &rY );
			if(m_psExtent->MaxX < rX)
				m_psExtent->MaxX = rX;
			if(m_psExtent->MinX > rX)
				m_psExtent->MinX = rX;
			if(m_psExtent->MaxY < rY)
				m_psExtent->MaxY = rY;
			if(m_psExtent->MinY > rY)
				m_psExtent->MinY = rY;
		}
	}
	else
	{
		wxDELETE(m_psExtent);
		m_psExtent = NULL;
	}

//    if( poDataset->GetGeoTransform( adfGeoTransform ) == CE_None )
//    {
//        printf( "Origin = (%.6f,%.6f)\n",
//                adfGeoTransform[0], adfGeoTransform[3] );
//
//        printf( "Pixel Size = (%.6f,%.6f)\n",
//                adfGeoTransform[1], adfGeoTransform[5] );
//    }

	m_bIsOpened = true;
	return true;
}
Esempio n. 16
0
void DevicePrefs::OnHost(wxCommandEvent & e)
{
   // Bail if we have no hosts
   if (mHostNames.size() < 1)
      return;

   // Find the index for the host API selected
   int index = -1;
   wxString apiName = mHostNames[mHost->GetCurrentSelection()];
   int nHosts = Pa_GetHostApiCount();
   for (int i = 0; i < nHosts; ++i) {
      wxString name(Pa_GetHostApiInfo(i)->name, wxConvLocal);
      if (name == apiName) {
         index = i;
         break;
      }
   }
   // We should always find the host!
   if (index < 0) {
      wxLogDebug(wxT("DevicePrefs::OnHost(): API index not found"));
      return;
   }

   int nDevices = Pa_GetDeviceCount();

   if (nDevices == 0) {
      mHost->Clear();
      mHost->Append(_("No audio interfaces"), (void *) NULL);
      mHost->SetSelection(0);
   }

   const std::vector<DeviceSourceMap> &inMaps  = DeviceManager::Instance()->GetInputDeviceMaps();
   const std::vector<DeviceSourceMap> &outMaps = DeviceManager::Instance()->GetOutputDeviceMaps();

   wxArrayString playnames;
   wxArrayString recordnames;
   size_t i;
   int devindex;  /* temp variable to hold the numeric ID of each device in turn */
   wxString device;
   wxString recDevice;

   recDevice = mRecordDevice;
   if (this->mRecordSource != wxT(""))
      recDevice += wxString(": ", wxConvLocal) + mRecordSource;

   mRecord->Clear();
   for (i = 0; i < inMaps.size(); i++) {
      if (index == inMaps[i].hostIndex) {
         device   = MakeDeviceSourceString(&inMaps[i]);
         devindex = mRecord->Append(device);
         // We need to const cast here because SetClientData is a wx function
         // It is okay beause the original variable is non-const.
         mRecord->SetClientData(devindex, const_cast<DeviceSourceMap *>(&inMaps[i]));
         if (device == recDevice) {  /* if this is the default device, select it */
            mRecord->SetSelection(devindex);
         }
      }
   }

   mPlay->Clear();
   for (i = 0; i < outMaps.size(); i++) {
      if (index == outMaps[i].hostIndex) {
         device   = MakeDeviceSourceString(&outMaps[i]);
         devindex = mPlay->Append(device);
         mPlay->SetClientData(devindex, const_cast<DeviceSourceMap *>(&outMaps[i]));
         if (device == mPlayDevice) {  /* if this is the default device, select it */
            mPlay->SetSelection(devindex);
         }
      }
   }
   
   /* deal with not having any devices at all */
   if (mPlay->GetCount() == 0) {
      playnames.Add(_("No devices found"));
      mPlay->Append(playnames[0], (void *) NULL);
      mPlay->SetSelection(0);
   }
   if (mRecord->GetCount() == 0) {
      recordnames.Add(_("No devices found"));
      mRecord->Append(recordnames[0], (void *) NULL);
      mRecord->SetSelection(0);
   }

   /* what if we have no device selected? we should choose the default on 
    * this API, as defined by PortAudio. We then fall back to using 0 only if
    * that fails */
   if (mPlay->GetCount() && mPlay->GetSelection() == wxNOT_FOUND) {
      DeviceSourceMap *defaultMap = DeviceManager::Instance()->GetDefaultOutputDevice(index);
      if (defaultMap)
         mPlay->SetStringSelection(MakeDeviceSourceString(defaultMap));

      if (mPlay->GetSelection() == wxNOT_FOUND) {
         mPlay->SetSelection(0);
      }
   }

   if (mRecord->GetCount() && mRecord->GetSelection() == wxNOT_FOUND) {
      DeviceSourceMap *defaultMap = DeviceManager::Instance()->GetDefaultInputDevice(index);
      if (defaultMap)
         mRecord->SetStringSelection(MakeDeviceSourceString(defaultMap));

      if (mPlay->GetSelection() == wxNOT_FOUND) {
         mPlay->SetSelection(0);
      }
   }

   ShuttleGui S(this, eIsCreating);
   S.SetSizeHints(mPlay, mPlay->GetStrings());
   S.SetSizeHints(mRecord, mRecord->GetStrings());
   OnDevice(e);
}
Esempio n. 17
0
void wxMessageDialog::ReplaceStaticWithEdit()
{
    // check if the message box fits the display
    int nDisplay = wxDisplay::GetFromWindow(this);
    if ( nDisplay == wxNOT_FOUND )
        nDisplay = 0;
    const wxRect rectDisplay = wxDisplay(nDisplay).GetClientArea();

    if ( rectDisplay.Contains(GetRect()) )
    {
        // nothing to do
        return;
    }


    // find the static control to replace: normally there are two of them, the
    // icon and the text itself so search for all of them and ignore the icon
    // ones
    HWND hwndStatic = ::FindWindowEx(GetHwnd(), NULL, wxT("STATIC"), NULL);
    if ( ::GetWindowLong(hwndStatic, GWL_STYLE) & SS_ICON )
        hwndStatic = ::FindWindowEx(GetHwnd(), hwndStatic, wxT("STATIC"), NULL);

    if ( !hwndStatic )
    {
        wxLogDebug("Failed to find the static text control in message box.");
        return;
    }

    // set the right font for GetCharHeight() call below
    wxWindowBase::SetFont(GetMessageFont());

    // put the new edit control at the same place
    RECT rc = wxGetWindowRect(hwndStatic);
    ScreenRectToClient(GetHwnd(), rc);

    // but make it less tall so that the message box fits on the screen: we try
    // to make the message box take no more than 7/8 of the screen to leave
    // some space above and below it
    const int hText = (7*rectDisplay.height)/8 -
                      (
                         2*::GetSystemMetrics(SM_CYFIXEDFRAME) +
                         ::GetSystemMetrics(SM_CYCAPTION) +
                         5*GetCharHeight() // buttons + margins
                      );
    const int dh = (rc.bottom - rc.top) - hText; // vertical space we save
    rc.bottom -= dh;

    // and it also must be wider as it needs a vertical scrollbar (in order
    // to preserve the word wrap, otherwise the number of lines would change
    // and we want the control to look as similar as possible to the original)
    //
    // NB: you would have thought that 2*SM_CXEDGE would be enough but it
    //     isn't, somehow, and the text control breaks lines differently from
    //     the static one so fudge by adding some extra space
    const int dw = ::GetSystemMetrics(SM_CXVSCROLL) +
                        4*::GetSystemMetrics(SM_CXEDGE);
    rc.right += dw;


    // chop of the trailing new line(s) from the message box text, they are
    // ignored by the static control but result in extra lines and hence extra
    // scrollbar position in the edit one
    wxString text(wxGetWindowText(hwndStatic));
    for ( wxString::reverse_iterator i = text.rbegin(); i != text.rend(); ++i )
    {
        if ( *i != '\n' )
        {
            // found last non-newline char, remove everything after it and stop
            text.erase(i.base() + 1, text.end());
            break;
        }
    }

    // do create the new control
    HWND hwndEdit = ::CreateWindow
                      (
                        wxT("EDIT"),
                        wxTextBuffer::Translate(text).wx_str(),
                        WS_CHILD | WS_VSCROLL | WS_VISIBLE |
                        ES_MULTILINE | ES_READONLY | ES_AUTOVSCROLL,
                        rc.left, rc.top,
                        rc.right - rc.left, rc.bottom - rc.top,
                        GetHwnd(),
                        NULL,
                        wxGetInstance(),
                        NULL
                      );

    if ( !hwndEdit )
    {
        wxLogDebug("Creation of replacement edit control failed in message box");
        return;
    }

    // copy the font from the original control
    LRESULT hfont = ::SendMessage(hwndStatic, WM_GETFONT, 0, 0);
    ::SendMessage(hwndEdit, WM_SETFONT, hfont, 0);

    // and get rid of it
    ::DestroyWindow(hwndStatic);


    // shrink and centre the message box vertically and widen it box to account
    // for the extra scrollbar
    RECT rcBox = wxGetWindowRect(GetHwnd());
    const int hMsgBox = rcBox.bottom - rcBox.top - dh;
    rcBox.top = (rectDisplay.height - hMsgBox)/2;
    rcBox.bottom = rcBox.top + hMsgBox + (rectDisplay.height - hMsgBox)%2;
    rcBox.left -= dw/2;
    rcBox.right += dw - dw/2;
    SetWindowRect(GetHwnd(), rcBox);

    // and adjust all the buttons positions
    for ( unsigned n = 0; n < WXSIZEOF(ms_buttons); n++ )
    {
        const HWND hwndBtn = ::GetDlgItem(GetHwnd(), ms_buttons[n].id);
        if ( !hwndBtn )
            continue;   // it's ok, not all buttons are always present

        RECT rc = wxGetWindowRect(hwndBtn);
        rc.top -= dh;
        rc.bottom -= dh;
        rc.left += dw/2;
        rc.right += dw/2;
        MoveWindowToScreenRect(hwndBtn, rc);
    }
}
Esempio n. 18
0
void ConvertViewCtrlToTrackData(const wxListCtrl &listctrl, const std::map< wxString, long > &mapping, std::vector<lfmt::TrackData> &tracklist, wxDateTime offset)
{
    auto row_count = listctrl.GetItemCount();

    if (row_count < 1)
        return;

    // grab column indices from string-long-map which we have just for purpose of dynamic indices (ie. changing column order is easy)
    auto idx_artist = mapping.find("Artist")->second;
    auto idx_tname  = mapping.find("Trackname")->second;
    auto idx_album  = mapping.find("Album")->second;
    auto idx_time  = mapping.find("Time")->second;

    wxDateTime last_time = offset;

    // last track on the list is the most recentry track that was listened to;
    // moving up the list successive tracks will get earlier times
    for (int row = row_count-1; row >= 0; --row)
    {
        lfmt::TrackData td;

        // is there a better way of getting the info out of the listviewctrl?
        // it's questionable if I would have gotten it without the wxforum :(
        wxListItem item;
        item.SetId(row);
        item.SetMask(wxLIST_MASK_TEXT);

        // "unrolled loop" for all columns
        item.SetColumn(idx_artist);
        listctrl.GetItem(item);
        td.artist = item.GetText();

        item.SetColumn(idx_tname);
        listctrl.GetItem(item);
        td.trackname = item.GetText();

        item.SetColumn(idx_album);
        listctrl.GetItem(item);
        td.album = item.GetText();

        td.timestamp = last_time.GetTicks(); // set time *before* calculating the descendant
        item.SetColumn(idx_time);
        listctrl.GetItem(item);
        {
            // now calculate 'last_time' offset according to playtime of the current track
            // defaults to 3 minutes if we don't know the track's length
            wxArrayString time_str = wxStringTokenize(item.GetText(), ":");
            long minutes, seconds;
            bool success = true;
            success &= time_str[0].ToLong(&minutes);
            success &= time_str[1].ToLong(&seconds);

            if (success)
                last_time -= wxTimeSpan(0, minutes, seconds);
            else
            {
                wxLogWarning("Could not parse timespan " + item.GetText() + ". Assuming track length of 3 minutes.");
                last_time -= wxTimeSpan(0, 3, 0);
            }
        }

        tracklist.push_back(td);

        wxLogDebug("Converted track " + td.ToString() + " from row %d.", row);
    }
}
Esempio n. 19
0
void wxStackWalker::WalkFrom(const CONTEXT *pCtx, size_t skip)
{
    if ( !wxDbgHelpDLL::Init() )
    {
        // don't log a user-visible error message here because the stack trace
        // is only needed for debugging/diagnostics anyhow and we shouldn't
        // confuse the user by complaining that we couldn't generate it
        wxLogDebug(_T("Failed to get stack backtrace: %s"),
                   wxDbgHelpDLL::GetErrorMessage().c_str());
        return;
    }

    // according to MSDN, the first parameter should be just a unique value and
    // not process handle (although the parameter is prototyped as "HANDLE
    // hProcess") and actually it advises to use the process id and not handle
    // for Win9x, but then we need to use the same value in StackWalk() call
    // below which should be a real handle... so this is what we use
    const HANDLE hProcess = ::GetCurrentProcess();

    if ( !wxDbgHelpDLL::SymInitialize
                        (
                            hProcess,
                            NULL,   // use default symbol search path
                            TRUE    // load symbols for all loaded modules
                        ) )
    {
        wxDbgHelpDLL::LogError(_T("SymInitialize"));

        return;
    }

    CONTEXT ctx = *pCtx; // will be modified by StackWalk()

    DWORD dwMachineType;

    // initialize the initial frame: currently we can do it for x86 only
    STACKFRAME sf;
    wxZeroMemory(sf);

#ifdef _M_IX86
    sf.AddrPC.Offset       = ctx.Eip;
    sf.AddrPC.Mode         = AddrModeFlat;
    sf.AddrStack.Offset    = ctx.Esp;
    sf.AddrStack.Mode      = AddrModeFlat;
    sf.AddrFrame.Offset    = ctx.Ebp;
    sf.AddrFrame.Mode      = AddrModeFlat;

    dwMachineType = IMAGE_FILE_MACHINE_I386;
#else
    #error "Need to initialize STACKFRAME on non x86"
#endif // _M_IX86

    // iterate over all stack frames (but stop after 200 to avoid entering
    // infinite loop if the stack is corrupted)
    for ( size_t nLevel = 0; nLevel < 200; nLevel++ )
    {
        // get the next stack frame
        if ( !wxDbgHelpDLL::StackWalk
                            (
                                dwMachineType,
                                hProcess,
                                ::GetCurrentThread(),
                                &sf,
                                &ctx,
                                NULL,       // read memory function (default)
                                wxDbgHelpDLL::SymFunctionTableAccess,
                                wxDbgHelpDLL::SymGetModuleBase,
                                NULL        // address translator for 16 bit
                            ) )
        {
            if ( ::GetLastError() )
                wxDbgHelpDLL::LogError(_T("StackWalk"));

            break;
        }

        // don't show this frame itself in the output
        if ( nLevel >= skip )
        {
            wxStackFrame frame(nLevel - skip,
                               (void *)sf.AddrPC.Offset,
                               sf.AddrFrame.Offset);

            OnStackFrame(frame);
        }
    }

    // this results in crashes inside ntdll.dll when called from
    // exception handler ...
#if 0
    if ( !wxDbgHelpDLL::SymCleanup(hProcess) )
    {
        wxDbgHelpDLL::LogError(_T("SymCleanup"));
    }
#endif
}
Esempio n. 20
0
// returns number of tracks imported
int Importer::Import(wxString fName,
                     TrackFactory *trackFactory,
                     Track *** tracks,
                     Tags *tags,
                     wxString &errorMessage)
{
   AudacityProject *pProj = GetActiveProject();
   pProj->mbBusyImporting = true;

   ImportFileHandle *inFile = NULL;
   int numTracks = 0;

   wxString extension = fName.AfterLast(wxT('.'));

   // This list is used to call plugins in correct order
   ImportPluginList importPlugins;
   ImportPluginList::compatibility_iterator importPluginNode;

   // This list is used to remember plugins that should have been compatible with the file.
   ImportPluginList compatiblePlugins;
   
   // If user explicitly selected a filter,
   // then we should try importing via corresponding plugin first
   wxString type = gPrefs->Read(wxT("/LastOpenType"),wxT(""));
   
   // Not implemented (yet?)
   wxString mime_type = wxT("*");

   // First, add user-selected filter
   bool usersSelectionOverrides;
   gPrefs->Read(wxT("/ExtendedImport/OverrideExtendedImportByOpenFileDialogChoice"), &usersSelectionOverrides, false);

   wxLogDebug(wxT("LastOpenType is %s"),type.c_str());
   wxLogDebug(wxT("OverrideExtendedImportByOpenFileDialogChoice is %i"),usersSelectionOverrides);

   if (usersSelectionOverrides)
   {
      importPluginNode = mImportPluginList->GetFirst();
      while (importPluginNode)
      {
         ImportPlugin *plugin = importPluginNode->GetData();
         if (plugin->GetPluginFormatDescription().CompareTo(type) == 0)
         {
            // This plugin corresponds to user-selected filter, try it first.
            wxLogDebug(wxT("Inserting %s"),plugin->GetPluginStringID().c_str());
            importPlugins.Insert(plugin);
         }
         importPluginNode = importPluginNode->GetNext();
      }
   }

   wxLogMessage(wxT("File name is %s"),(const char *) fName.c_str());
   wxLogMessage(wxT("Mime type is %s"),(const char *) mime_type.Lower().c_str());

   for (size_t i = 0; i < mExtImportItems->Count(); i++)
   {
      ExtImportItem *item = &(*mExtImportItems)[i];
      bool matches_ext = false, matches_mime = false;
      wxLogDebug(wxT("Testing extensions"));
      for (size_t j = 0; j < item->extensions.Count(); j++)
      {
         wxLogDebug(wxT("%s"), (const char *) item->extensions[j].Lower().c_str());
         if (wxMatchWild (item->extensions[j].Lower(),fName.Lower(), false))
         {
            wxLogDebug(wxT("Match!"));
            matches_ext = true;
            break;
         }
      }
      if (item->extensions.Count() == 0)
      {
         wxLogDebug(wxT("Match! (empty list)"));
         matches_ext = true;
      }
      if (matches_ext)
         wxLogDebug(wxT("Testing mime types"));
      else
         wxLogDebug(wxT("Not testing mime types"));
      for (size_t j = 0; matches_ext && j < item->mime_types.Count(); j++)
      {
         if (wxMatchWild (item->mime_types[j].Lower(),mime_type.Lower(), false))
         {
            wxLogDebug(wxT("Match!"));
            matches_mime = true;
            break;
         }
      }
      if (item->mime_types.Count() == 0)
      {
         wxLogDebug(wxT("Match! (empty list)"));
         matches_mime = true;
      }
      if (matches_ext && matches_mime)
      {
         wxLogDebug(wxT("Complete match!"));
         for (size_t j = 0; j < item->filter_objects.Count() && (item->divider < 0 || (int) j < item->divider); j++)
         {
            // the filter_object can be NULL if a suitable importer was not found
            // this happens when we recompile with --without-ffmpeg and there
            // is still ffmpeg in prefs from previous --with-ffmpeg builds
            if (!(item->filter_objects[j]))
               continue;
            wxLogDebug(wxT("Inserting %s"),item->filter_objects[j]->GetPluginStringID().c_str());
            importPlugins.Append(item->filter_objects[j]);
         }
      }
   }

   // Add all plugins that support the extension
   importPluginNode = mImportPluginList->GetFirst();

   // Here we rely on the fact that the first plugin in mImportPluginList is libsndfile.
   // We want to save this for later insertion ahead of libmad, if libmad supports the extension.
   // The order of plugins in mImportPluginList is determined by the Importer constructor alone and
   // is not changed by user selection overrides or any other mechanism, but we include an assert
   // in case subsequent code revisions to the constructor should break this assumption that 
   // libsndfile is first. 
   ImportPlugin *libsndfilePlugin = importPluginNode->GetData();
   wxASSERT(libsndfilePlugin->GetPluginStringID().IsSameAs(wxT("libsndfile")));

   while (importPluginNode)
   {
      ImportPlugin *plugin = importPluginNode->GetData();
      // Make sure its not already in the list
      if (importPlugins.Find(plugin) == NULL)
      {
         if (plugin->SupportsExtension(extension))
         {
            // If libmad is accidentally fed a wav file which has been incorrectly
            // given an .mp3 extension then it can choke on the contents and crash.
            // To avoid this, put libsndfile ahead of libmad in the lists created for 
            // mp3 files, or for any of the extensions supported by libmad. 
            // A genuine .mp3 file will first fail an attempted import with libsndfile
            // but then get processed as desired by libmad.
            // But a wav file which bears an incorrect .mp3 extension will be successfully 
            // processed by libsndfile and thus avoid being submitted to libmad.
            if (plugin->GetPluginStringID().IsSameAs(wxT("libmad")))
            {
               // Make sure libsndfile is not already in the list
               if (importPlugins.Find(libsndfilePlugin) == NULL)
               {
                  wxLogDebug(wxT("Appending %s"),libsndfilePlugin->GetPluginStringID().c_str());
                  importPlugins.Append(libsndfilePlugin);
               }
            }
            wxLogDebug(wxT("Appending %s"),plugin->GetPluginStringID().c_str());
            importPlugins.Append(plugin);
         }
      }

      importPluginNode = importPluginNode->GetNext();
   }

   // Add remaining plugins, except for libmad, which should not be used as a fallback for anything.
   // Otherwise, if FFmpeg (libav) has not been installed, libmad will still be there near the 
   // end of the preference list importPlugins, where it will claim success importing FFmpeg file
   // formats unsuitable for it, and produce distorted results.
   importPluginNode = mImportPluginList->GetFirst();
   while (importPluginNode)
   {
      ImportPlugin *plugin = importPluginNode->GetData();
      if (!(plugin->GetPluginStringID().IsSameAs(wxT("libmad"))))
      {
         // Make sure its not already in the list
         if (importPlugins.Find(plugin) == NULL)
         {
            wxLogDebug(wxT("Appending %s"),plugin->GetPluginStringID().c_str());
            importPlugins.Append(plugin);
         }
      }

      importPluginNode = importPluginNode->GetNext();
   }

   importPluginNode = importPlugins.GetFirst();
   while(importPluginNode)
   {
      ImportPlugin *plugin = importPluginNode->GetData();
      // Try to open the file with this plugin (probe it)
      wxLogMessage(wxT("Opening with %s"),plugin->GetPluginStringID().c_str());
      inFile = plugin->Open(fName);
      if ( (inFile != NULL) && (inFile->GetStreamCount() > 0) )
      {
         wxLogMessage(wxT("Open(%s) succeeded"),(const char *) fName.c_str());
         // File has more than one stream - display stream selector
         if (inFile->GetStreamCount() > 1)                                                  
         {
            ImportStreamDialog ImportDlg(inFile, NULL, -1, _("Select stream(s) to import"));

            if (ImportDlg.ShowModal() == wxID_CANCEL)
            {
               delete inFile;
               pProj->mbBusyImporting = false;
               return 0;
            }
         }
         // One stream - import it by default
         else
            inFile->SetStreamUsage(0,TRUE);

         int res;
         
         res = inFile->Import(trackFactory, tracks, &numTracks, tags);

         delete inFile;

         if (res == eProgressSuccess || res == eProgressStopped)
         {
            // LOF ("list-of-files") has different semantics
            if (extension.IsSameAs(wxT("lof"), false))
            {
               pProj->mbBusyImporting = false;
               return 1;
            }

            if (numTracks > 0) 
            {
               // success!
               pProj->mbBusyImporting = false;
               return numTracks;
            }
         }

         if (res == eProgressCancelled || res == eProgressFailed)
         {
            pProj->mbBusyImporting = false;
            return 0;
         }

         // We could exit here since we had a match on the file extension,
         // but there may be another plug-in that can import the file and
         // that may recognize the extension, so we allow the loop to
         // continue.
      }
      importPluginNode = importPluginNode->GetNext();
   }
   wxLogError(wxT("Importer::Import: Opening failed."));

   // None of our plugins can handle this file.  It might be that
   // Audacity supports this format, but support was not compiled in.
   // If so, notify the user of this fact
   UnusableImportPluginList::compatibility_iterator unusableImporterNode
      = mUnusableImportPluginList->GetFirst();
   while(unusableImporterNode)
   {
      UnusableImportPlugin *unusableImportPlugin = unusableImporterNode->GetData();
      if( unusableImportPlugin->SupportsExtension(extension) )
      {
         errorMessage.Printf(_("This version of Audacity was not compiled with %s support."),
                             unusableImportPlugin->
                             GetPluginFormatDescription().c_str());
         pProj->mbBusyImporting = false;
         return 0;
      }
      unusableImporterNode = unusableImporterNode->GetNext();
   }

   /* warnings for unsupported data types */

#ifdef USE_MIDI
   // MIDI files must be imported, not opened
   if ((extension.IsSameAs(wxT("midi"), false))||(extension.IsSameAs(wxT("mid"), false))) {
      errorMessage.Printf(_("\"%s\" \nis a MIDI file, not an audio file. \nAudacity cannot open this type of file for playing, but you can\nedit it by clicking File > Import > MIDI."), fName.c_str());
      pProj->mbBusyImporting = false;
      return 0;
   }
#endif

   if (compatiblePlugins.GetCount() <= 0)
   {
      // if someone has sent us a .cda file, send them away
      if (extension.IsSameAs(wxT("cda"), false)) {
         /* i18n-hint: %s will be the filename */
         errorMessage.Printf(_("\"%s\" is an audio CD track. \nAudacity cannot open audio CDs directly. \nExtract (rip) the CD tracks to an audio format that \nAudacity can import, such as WAV or AIFF."), fName.c_str());
         pProj->mbBusyImporting = false;
         return 0;
      }
   
      // playlist type files
      if ((extension.IsSameAs(wxT("m3u"), false))||(extension.IsSameAs(wxT("ram"), false))||(extension.IsSameAs(wxT("pls"), false))) {
         errorMessage.Printf(_("\"%s\" is a playlist file. \nAudacity cannot open this file because it only contains links to other files. \nYou may be able to open it in a text editor and download the actual audio files."), fName.c_str());
         pProj->mbBusyImporting = false;
         return 0;
      }
      //WMA files of various forms
      if ((extension.IsSameAs(wxT("wma"), false))||(extension.IsSameAs(wxT("asf"), false))) {
         errorMessage.Printf(_("\"%s\" is a Windows Media Audio file. \nAudacity cannot open this type of file due to patent restrictions. \nYou need to convert it to a supported audio format, such as WAV or AIFF."), fName.c_str());
         pProj->mbBusyImporting = false;
         return 0;
      }
      //AAC files of various forms (probably not encrypted)
      if ((extension.IsSameAs(wxT("aac"), false))||(extension.IsSameAs(wxT("m4a"), false))||(extension.IsSameAs(wxT("m4r"), false))||(extension.IsSameAs(wxT("mp4"), false))) {
         errorMessage.Printf(_("\"%s\" is an Advanced Audio Coding file. \nAudacity cannot open this type of file. \nYou need to convert it to a supported audio format, such as WAV or AIFF."), fName.c_str());
         pProj->mbBusyImporting = false;
         return 0;
      }
      // encrypted itunes files
      if ((extension.IsSameAs(wxT("m4p"), false))) {
         errorMessage.Printf(_("\"%s\" is an encrypted audio file. \nThese typically are from an online music store. \nAudacity cannot open this type of file due to the encryption. \nTry recording the file into Audacity, or burn it to audio CD then \nextract the CD track to a supported audio format such as WAV or AIFF."), fName.c_str());
         pProj->mbBusyImporting = false;
         return 0;
      }
      // Real Inc. files of various sorts
      if ((extension.IsSameAs(wxT("ra"), false))||(extension.IsSameAs(wxT("rm"), false))||(extension.IsSameAs(wxT("rpm"), false))) {
         errorMessage.Printf(_("\"%s\" is a RealPlayer media file. \nAudacity cannot open this proprietary format. \nYou need to convert it to a supported audio format, such as WAV or AIFF."), fName.c_str());
         pProj->mbBusyImporting = false;
         return 0;
      }
   
      // Other notes-based formats
      if ((extension.IsSameAs(wxT("kar"), false))||(extension.IsSameAs(wxT("mod"), false))||(extension.IsSameAs(wxT("rmi"), false))) {
         errorMessage.Printf(_("\"%s\" is a notes-based file, not an audio file. \nAudacity cannot open this type of file. \nTry converting it to an audio file such as WAV or AIFF and \nthen import it, or record it into Audacity."), fName.c_str());
         pProj->mbBusyImporting = false;
         return 0;
      }
   
      // MusePack files
      if ((extension.IsSameAs(wxT("mp+"), false))||(extension.IsSameAs(wxT("mpc"), false))||(extension.IsSameAs(wxT("mpp"), false))) {
         errorMessage.Printf(_("\"%s\" is a Musepack audio file. \nAudacity cannot open this type of file. \nIf you think it might be an mp3 file, rename it to end with \".mp3\" \nand try importing it again. Otherwise you need to convert it to a supported audio \nformat, such as WAV or AIFF."), fName.c_str());
         pProj->mbBusyImporting = false;
         return 0;
      }
   
      // WavPack files
      if ((extension.IsSameAs(wxT("wv"), false))||(extension.IsSameAs(wxT("wvc"), false))) {
         errorMessage.Printf(_("\"%s\" is a Wavpack audio file. \nAudacity cannot open this type of file. \nYou need to convert it to a supported audio format, such as WAV or AIFF."), fName.c_str());
         pProj->mbBusyImporting = false;
         return 0;
      }
   
      // AC3 files
      if ((extension.IsSameAs(wxT("ac3"), false))) {
         errorMessage.Printf(_("\"%s\" is a Dolby Digital audio file. \nAudacity cannot currently open this type of file. \nYou need to convert it to a supported audio format, such as WAV or AIFF."), fName.c_str());
         pProj->mbBusyImporting = false;
         return 0;
      }
   
      // Speex files
      if ((extension.IsSameAs(wxT("spx"), false))) {
         errorMessage.Printf(_("\"%s\" is an Ogg Speex audio file. \nAudacity cannot currently open this type of file. \nYou need to convert it to a supported audio format, such as WAV or AIFF."), fName.c_str());
         pProj->mbBusyImporting = false;
         return 0;
      }
   
      // Video files of various forms
      if ((extension.IsSameAs(wxT("mpg"), false))||(extension.IsSameAs(wxT("mpeg"), false))||(extension.IsSameAs(wxT("avi"), false))||(extension.IsSameAs(wxT("wmv"), false))||(extension.IsSameAs(wxT("rv"), false))) {
         errorMessage.Printf(_("\"%s\" is a video file. \nAudacity cannot currently open this type of file. \nYou need to extract the audio to a supported format, such as WAV or AIFF."), fName.c_str());
         pProj->mbBusyImporting = false;
         return 0;
      }

      // we were not able to recognize the file type
      errorMessage.Printf(_("Audacity did not recognize the type of the file '%s'.\nIf it is uncompressed, try importing it using \"Import Raw\"."),fName.c_str());
   }
   else
   {
      // We DO have a plugin for this file, but import failed.
      wxString pluglist = wxEmptyString;

      importPluginNode = compatiblePlugins.GetFirst();
      while(importPluginNode)
      {
         ImportPlugin *plugin = importPluginNode->GetData();
         if (pluglist == wxEmptyString)
           pluglist = plugin->GetPluginFormatDescription();
         else
           pluglist = pluglist + wxT(", ") + plugin->GetPluginFormatDescription();
         importPluginNode = importPluginNode->GetNext();
      }

      errorMessage.Printf(_("Audacity recognized the type of the file '%s'.\nImporters supposedly supporting such files are:\n%s,\nbut none of them understood this file format."),fName.c_str(), pluglist.c_str());
   }

   pProj->mbBusyImporting = false;
   return 0;
}
Esempio n. 21
0
bool wxSpinCtrl::Create(wxWindow *parent,
                        wxWindowID id,
                        const wxString& value,
                        const wxPoint& pos,
                        const wxSize& size,
                        long style,
                        int min, int max, int initial,
                        const wxString& name)
{
    m_blockEvent = false;

    // this should be in ctor/init function but I don't want to add one to 2.8
    // to avoid problems with default ctor which can be inlined in the user
    // code and so might not get this fix without recompilation
    m_oldValue = INT_MIN;

    // before using DoGetBestSize(), have to set style to let the base class
    // know whether this is a horizontal or vertical control (we're always
    // vertical)
    style |= wxSP_VERTICAL;

    if ( (style & wxBORDER_MASK) == wxBORDER_DEFAULT )
#ifdef __WXWINCE__
        style |= wxBORDER_SIMPLE;
#else
        style |= wxBORDER_SUNKEN;
#endif

    SetWindowStyle(style);

    WXDWORD exStyle = 0;
    WXDWORD msStyle = MSWGetStyle(GetWindowStyle(), & exStyle) ;

    // propagate text alignment style to text ctrl
    if ( style & wxALIGN_RIGHT )
        msStyle |= ES_RIGHT;
    else if ( style & wxALIGN_CENTER )
        msStyle |= ES_CENTER;

    // calculate the sizes: the size given is the total size for both controls
    // and we need to fit them both in the given width (height is the same)
    wxSize sizeText(size), sizeBtn(size);
    sizeBtn.x = wxSpinButton::DoGetBestSize().x;
    if ( sizeText.x <= 0 )
    {
        // DEFAULT_ITEM_WIDTH is the default width for the text control
        sizeText.x = DEFAULT_ITEM_WIDTH + MARGIN_BETWEEN + sizeBtn.x;
    }

    sizeText.x -= sizeBtn.x + MARGIN_BETWEEN;
    if ( sizeText.x <= 0 )
    {
        wxLogDebug(wxT("not enough space for wxSpinCtrl!"));
    }

    wxPoint posBtn(pos);
    posBtn.x += sizeText.x + MARGIN_BETWEEN;

    // we must create the text control before the spin button for the purpose
    // of the dialog navigation: if there is a static text just before the spin
    // control, activating it by Alt-letter should give focus to the text
    // control, not the spin and the dialog navigation code will give focus to
    // the next control (at Windows level), not the one after it

    // create the text window

    m_hwndBuddy = (WXHWND)::CreateWindowEx
                    (
                     exStyle,                // sunken border
                     wxT("EDIT"),             // window class
                     NULL,                   // no window title
                     msStyle,                // style (will be shown later)
                     pos.x, pos.y,           // position
                     0, 0,                   // size (will be set later)
                     GetHwndOf(parent),      // parent
                     (HMENU)-1,              // control id
                     wxGetInstance(),        // app instance
                     NULL                    // unused client data
                    );

    if ( !m_hwndBuddy )
    {
        wxLogLastError(wxT("CreateWindow(buddy text window)"));

        return false;
    }


    // create the spin button
    if ( !wxSpinButton::Create(parent, id, posBtn, sizeBtn, style, name) )
    {
        return false;
    }

    wxSpinButtonBase::SetRange(min, max);

    // subclass the text ctrl to be able to intercept some events
    wxSetWindowUserData(GetBuddyHwnd(), this);
    m_wndProcBuddy = (WXFARPROC)wxSetWindowProc(GetBuddyHwnd(),
                                                wxBuddyTextWndProc);

    // set up fonts and colours  (This is nomally done in MSWCreateControl)
    InheritAttributes();
    if (!m_hasFont)
        SetFont(GetDefaultAttributes().font);

    // set the size of the text window - can do it only now, because we
    // couldn't call DoGetBestSize() before as font wasn't set
    if ( sizeText.y <= 0 )
    {
        int cx, cy;
        wxGetCharSize(GetHWND(), &cx, &cy, GetFont());

        sizeText.y = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
    }

    SetInitialSize(size);

    (void)::ShowWindow(GetBuddyHwnd(), SW_SHOW);

    // associate the text window with the spin button
    (void)::SendMessage(GetHwnd(), UDM_SETBUDDY, (WPARAM)m_hwndBuddy, 0);

    SetValue(initial);

    // Set the range in the native control
    SetRange(min, max);

    if ( !value.empty() )
    {
        SetValue(value);
        m_oldValue = (int) wxAtol(value);
    }
    else
    {
        SetValue(wxString::Format(wxT("%d"), initial));
        m_oldValue = initial;
    }

    // do it after finishing with m_hwndBuddy creation to avoid generating
    // initial wxEVT_COMMAND_TEXT_UPDATED message
    ms_allSpins.Add(this);

    return true;
}
Esempio n. 22
0
/* static */
bool
wxAcceleratorEntry::ParseAccel(const wxString& text, int *flagsOut, int *keyOut)
{
    // the parser won't like trailing spaces
    wxString label = text;
    label.Trim(true);

    // For compatibility with the old wx versions which accepted (and actually
    // even required) a TAB character in the string passed to this function we
    // ignore anything up to the first TAB. Notice however that the correct
    // input consists of just the accelerator itself and nothing else, this is
    // done for compatibility and compatibility only.
    int posTab = label.Find(wxT('\t'));
    if ( posTab == wxNOT_FOUND )
        posTab = 0;
    else
        posTab++;

    // parse the accelerator string
    int accelFlags = wxACCEL_NORMAL;
    wxString current;
    for ( size_t n = (size_t)posTab; n < label.length(); n++ )
    {
        if ( (label[n] == '+') || (label[n] == '-') )
        {
            if ( CompareAccelString(current, wxTRANSLATE("ctrl")) )
                accelFlags |= wxACCEL_CTRL;
            else if ( CompareAccelString(current, wxTRANSLATE("alt")) )
                accelFlags |= wxACCEL_ALT;
            else if ( CompareAccelString(current, wxTRANSLATE("shift")) )
                accelFlags |= wxACCEL_SHIFT;
            else if ( CompareAccelString(current, wxTRANSLATE("rawctrl")) )
                accelFlags |= wxACCEL_RAW_CTRL;
            else // not a recognized modifier name
            {
                // we may have "Ctrl-+", for example, but we still want to
                // catch typos like "Crtl-A" so only give the warning if we
                // have something before the current '+' or '-', else take
                // it as a literal symbol
                if ( current.empty() )
                {
                    current += label[n];

                    // skip clearing it below
                    continue;
                }
                else
                {
                    wxLogDebug(wxT("Unknown accel modifier: '%s'"),
                               current.c_str());
                }
            }

            current.clear();
        }
        else // not special character
        {
            current += (wxChar) wxTolower(label[n]);
        }
    }

    int keyCode;
    const size_t len = current.length();
    switch ( len )
    {
        case 0:
            wxLogDebug(wxT("No accel key found, accel string ignored."));
            return false;

        case 1:
            // it's just a letter
            keyCode = current[0U];

            // if the key is used with any modifiers, make it an uppercase one
            // because Ctrl-A and Ctrl-a are the same; but keep it as is if it's
            // used alone as 'a' and 'A' are different
            if ( accelFlags != wxACCEL_NORMAL )
                keyCode = wxToupper(keyCode);
            break;

        default:
            keyCode = IsNumberedAccelKey(current, wxTRANSLATE("F"),
                                         WXK_F1, 1, 12);
            if ( !keyCode )
            {
                for ( size_t n = 0; n < WXSIZEOF(wxKeyNames); n++ )
                {
                    const wxKeyName& kn = wxKeyNames[n];
                    if ( CompareAccelString(current, kn.name) )
                    {
                        keyCode = kn.code;
                        break;
                    }
                }
            }

            if ( !keyCode )
                keyCode = IsNumberedAccelKey(current, wxTRANSLATE("KP_"),
                                             WXK_NUMPAD0, 0, 9);
            if ( !keyCode )
                keyCode = IsNumberedAccelKey(current, wxTRANSLATE("SPECIAL"),
                                             WXK_SPECIAL1, 1, 20);

            if ( !keyCode )
            {
                wxLogDebug(wxT("Unrecognized accel key '%s', accel string ignored."),
                           current.c_str());
                return false;
            }
    }


    wxASSERT_MSG( keyCode, wxT("logic error: should have key code here") );

    if ( flagsOut )
        *flagsOut = accelFlags;
    if ( keyOut )
        *keyOut = keyCode;

    return true;
}
Esempio n. 23
0
int
wxFontMapperBase::NonInteractiveCharsetToEncoding(const wxString& charset)
{
    wxFontEncoding encoding = wxFONTENCODING_SYSTEM;

    // we're going to modify it, make a copy
    wxString cs = charset;

#if wxUSE_CONFIG && wxUSE_FILECONFIG
    // first try the user-defined settings
    wxFontMapperPathChanger path(this, FONTMAPPER_CHARSET_PATH);
    if ( path.IsOk() )
    {
        wxConfigBase *config = GetConfig();

        // do we have an encoding for this charset?
        long value = config->Read(charset, -1l);
        if ( value != -1 )
        {
            if ( value == wxFONTENCODING_UNKNOWN )
            {
                // don't try to find it, in particular don't ask the user
                return value;
            }

            if ( value >= 0 && value <= wxFONTENCODING_MAX )
            {
                encoding = (wxFontEncoding)value;
            }
            else
            {
                wxLogDebug(wxT("corrupted config data: invalid encoding %ld for charset '%s' ignored"),
                           value, charset.c_str());
            }
        }

        if ( encoding == wxFONTENCODING_SYSTEM )
        {
            // may be we have an alias?
            config->SetPath(FONTMAPPER_CHARSET_ALIAS_PATH);

            wxString alias = config->Read(charset);
            if ( !alias.empty() )
            {
                // yes, we do - use it instead
                cs = alias;
            }
        }
    }
#endif // wxUSE_CONFIG

    // if didn't find it there, try to recognize it ourselves
    if ( encoding == wxFONTENCODING_SYSTEM )
    {
        // trim any spaces
        cs.Trim(true);
        cs.Trim(false);

        // discard the optional quotes
        if ( !cs.empty() )
        {
            if ( cs[0u] == wxT('"') && cs.Last() == wxT('"') )
            {
                cs = wxString(cs.c_str(), cs.length() - 1);
            }
        }

        for ( size_t i = 0; i < WXSIZEOF(gs_encodingNames); ++i )
        {
            for ( const wxChar* const* encName = gs_encodingNames[i]; *encName; ++encName )
            {
                if ( cs.CmpNoCase(*encName) == 0 )
                    return gs_encodings[i];
            }
        }

        cs.MakeUpper();

        if ( cs.Left(3) == wxT("ISO") )
        {
            // the dash is optional (or, to be exact, it is not, but
            // several broken programs "forget" it)
            const wxChar *p = cs.c_str() + 3;
            if ( *p == wxT('-') )
                p++;

            unsigned int value;
            if ( wxSscanf(p, wxT("8859-%u"), &value) == 1 )
            {
                // make it 0 based and check that it is strictly positive in
                // the process (no such thing as iso8859-0 encoding)
                if ( (value-- > 0) &&
                     (value < wxFONTENCODING_ISO8859_MAX -
                              wxFONTENCODING_ISO8859_1) )
                {
                    // it's a valid ISO8859 encoding
                    value += wxFONTENCODING_ISO8859_1;
                    encoding = (wxFontEncoding)value;
                }
            }
        }
        else if ( cs.Left(4) == wxT("8859") )
        {
            const wxChar *p = cs.c_str();

            unsigned int value;
            if ( wxSscanf(p, wxT("8859-%u"), &value) == 1 )
            {
                // make it 0 based and check that it is strictly positive in
                // the process (no such thing as iso8859-0 encoding)
                if ( (value-- > 0) &&
                     (value < wxFONTENCODING_ISO8859_MAX -
                              wxFONTENCODING_ISO8859_1) )
                {
                    // it's a valid ISO8859 encoding
                    value += wxFONTENCODING_ISO8859_1;
                    encoding = (wxFontEncoding)value;
                }
            }
        }
        else // check for Windows charsets
        {
            size_t len;
            if ( cs.Left(7) == wxT("WINDOWS") )
            {
                len = 7;
            }
            else if ( cs.Left(2) == wxT("CP") )
            {
                len = 2;
            }
            else // not a Windows encoding
            {
                len = 0;
            }

            if ( len )
            {
                const wxChar *p = cs.c_str() + len;
                if ( *p == wxT('-') )
                    p++;

                unsigned int value;
                if ( wxSscanf(p, wxT("%u"), &value) == 1 )
                {
                    if ( value >= 1250 )
                    {
                        value -= 1250;
                        if ( value < wxFONTENCODING_CP12_MAX -
                                     wxFONTENCODING_CP1250 )
                        {
                            // a valid Windows code page
                            value += wxFONTENCODING_CP1250;
                            encoding = (wxFontEncoding)value;
                        }
                    }

                    switch ( value )
                    {
                        case 866:
                            encoding = wxFONTENCODING_CP866;
                            break;

                        case 874:
                            encoding = wxFONTENCODING_CP874;
                            break;

                        case 932:
                            encoding = wxFONTENCODING_CP932;
                            break;

                        case 936:
                            encoding = wxFONTENCODING_CP936;
                            break;

                        case 949:
                            encoding = wxFONTENCODING_CP949;
                            break;

                        case 950:
                            encoding = wxFONTENCODING_CP950;
                            break;
                    }
                }
            }
        }
        //else: unknown
    }

    return encoding;
}
Esempio n. 24
0
bool wxAnimation::Load(wxInputStream &stream, wxAnimationType type)
{
    UnRef();

    char anim_type[12];
    switch (type)
    {
    case wxANIMATION_TYPE_GIF:
        strcpy(anim_type, "gif");
        break;

    case wxANIMATION_TYPE_ANI:
        strcpy(anim_type, "ani");
        break;

    default:
        anim_type[0] = '\0';
        break;
    }

    // create a GdkPixbufLoader
    GError *error = NULL;
    GdkPixbufLoader *loader;
    if (type != wxANIMATION_TYPE_INVALID && type != wxANIMATION_TYPE_ANY)
        loader = gdk_pixbuf_loader_new_with_type(anim_type, &error);
    else
        loader = gdk_pixbuf_loader_new();

    if (!loader ||
        error != NULL)  // even if the loader was allocated, an error could have happened
    {
        wxLogDebug(wxT("Could not create the loader for '%s' animation type: %s"),
                   anim_type, error->message);
        return false;
    }

    // connect to loader signals
    g_signal_connect(loader, "area-updated", G_CALLBACK(gdk_pixbuf_area_updated), this);

    guchar buf[2048];
    bool data_written = false;
    while (stream.IsOk())
    {
        // read a chunk of data
        if (!stream.Read(buf, sizeof(buf)) &&
            stream.GetLastError() != wxSTREAM_EOF)   // EOF is OK for now
        {
            // gdk_pixbuf_loader_close wants the GError == NULL
            gdk_pixbuf_loader_close(loader, NULL);
            return false;
        }

        // fetch all data into the loader
        if (!gdk_pixbuf_loader_write(loader, buf, stream.LastRead(), &error))
        {
            wxLogDebug(wxT("Could not write to the loader: %s"), error->message);

            // gdk_pixbuf_loader_close wants the GError == NULL
            gdk_pixbuf_loader_close(loader, NULL);
            return false;
        }

        data_written = true;
    }

    if (!data_written)
    {
        wxLogDebug("Could not read data from the stream...");
        return false;
    }

    // load complete: gdk_pixbuf_loader_close will now check if the data we
    // wrote inside the pixbuf loader does make sense and will give an error
    // if it doesn't (because of a truncated file, corrupted data or whatelse)
    if (!gdk_pixbuf_loader_close(loader, &error))
    {
        wxLogDebug(wxT("Could not close the loader: %s"), error->message);
        return false;
    }

    // wait until we get the last area_updated signal
    return data_written;
}
Esempio n. 25
0
void mmStockDialog::OnHistoryDownloadButton(wxCommandEvent& /*event*/)
{
    /*
    Example stock history download:
    https://code.google.com/p/yahoo-finance-managed/wiki/csvHistQuotesDownload
    */

    if (m_stock->SYMBOL.IsEmpty())
        return;

    const wxDateTime& StartDate = Model_Stock::PURCHASEDATE(m_stock);
    wxDateTime EndDate = wxDate::Today();
    const wxTimeSpan time = EndDate - StartDate;
    long intervalMonths = EndDate.GetMonth() - StartDate.GetMonth()
        + 12 * (EndDate.GetYear() - StartDate.GetYear())
        - (EndDate.GetDay() < StartDate.GetDay());

    //Define frequency
    enum { DAILY, WEEKLY, MONTHLY };
    wxArrayString FreqStrs;
    FreqStrs.Add(_("Days"));
    FreqStrs.Add(_("Weeks"));
    if (intervalMonths > 0) FreqStrs.Add(_("Months"));

    int freq = wxGetSingleChoiceIndex(_("Specify type frequency of stock history")
        , _("Stock History Update"), FreqStrs);

    long interval = 0;
    switch (freq)
    {
    case DAILY: interval = time.GetDays(); break;
    case WEEKLY: interval = time.GetWeeks(); break;
    case MONTHLY: interval = intervalMonths; break;
    default: return;
    }

    int nrPrices = (int) wxGetNumberFromUser(_("Specify how many stock history prices download from purchase date")
        , wxString::Format(_("Number of %s:"), FreqStrs.Item(freq).Lower()), _("Stock History Update")
        , interval, 1L, 9999L, this, wxDefaultPosition);

    if (nrPrices <= 0)
    {
        mmShowErrorMessageInvalid(this, FreqStrs[freq]);
        return;
    }
    else
    {
        switch (freq)
        {
        case DAILY: EndDate = wxDate(StartDate).Add(wxDateSpan::Days(nrPrices)); break;
        case WEEKLY: EndDate = wxDate(StartDate).Add(wxDateSpan::Weeks(nrPrices)); break;
        case MONTHLY: EndDate = wxDate(StartDate).Add(wxDateSpan::Months(nrPrices)); break;
        default: break;
        }
    }

    if (EndDate > wxDate::Today())
    {
        mmShowWarningMessage(this, _("End date is in the future\nQuotes will be updated until today")
            , _("Stock History Error"));
        EndDate = wxDate::Today();
    }

    wxString CSVQuotes;
    wxString URL = mmex::weblink::YahooQuotesHistory;
    URL += m_stock->SYMBOL;
    URL += wxString::Format("&a=%i", StartDate.GetMonth());
    URL += wxString::Format("&b=%i", StartDate.GetDay());
    URL += wxString::Format("&c=%i", StartDate.GetYear());
    URL += wxString::Format("&d=%i", EndDate.GetMonth());
    URL += wxString::Format("&e=%i", EndDate.GetDay());
    URL += wxString::Format("&f=%i", EndDate.GetYear());
    switch (freq)
    {
    case DAILY: URL += "&g=d"; break;
    case WEEKLY: URL += "&g=w"; break;
    case MONTHLY: URL += "&g=m"; break;
        default: break;
    }
    URL += "&ignore=.csv";
    wxLogDebug("Start Date:%s End Date:%s URL:%s", StartDate.FormatISODate(), EndDate.FormatISODate(), URL);

    int err_code = site_content(URL, CSVQuotes);
    if (err_code != wxURL_NOERR)
    {
        if (err_code == -1) CSVQuotes = _("Stock history not found!");
        mmShowErrorMessage(this, CSVQuotes, _("Stock History Error"));
        return;
    }

    double dPrice;
    wxString dateStr;
    Model_StockHistory::Data *data;

    wxStringTokenizer tkz(CSVQuotes, "\r\n");
    Model_StockHistory::instance().Begin();
    while (tkz.HasMoreTokens())
    {
        wxStringTokenizer tkzSingleLine(tkz.GetNextToken(), ",");
        std::vector<wxString> tokens;
        while (tkzSingleLine.HasMoreTokens())
        {
            const wxString& token = tkzSingleLine.GetNextToken();
            tokens.push_back(token);
        }

        if (tokens[0].Contains("-"))
        {
            dateStr = tokens[0];
            tokens[6].ToDouble(&dPrice);

            if (Model_StockHistory::instance().find(
                    Model_StockHistory::SYMBOL(m_stock->SYMBOL),
                    Model_StockHistory::DB_Table_STOCKHISTORY_V1::DATE(dateStr)
                ).size() == 0
                && dPrice > 0)
            {
                data = Model_StockHistory::instance().create();
                data->SYMBOL = m_stock->SYMBOL;
                data->DATE = dateStr;
                data->VALUE = dPrice;
                data->UPDTYPE = Model_StockHistory::ONLINE;
                Model_StockHistory::instance().save(data);
            }
        }
    }
    Model_StockHistory::instance().Commit();
    showStockHistory();
}
Esempio n. 26
0
void frmScanforDevices::OnButtonScanClick(wxCommandEvent& event)
{
    bool bSlowAlgorithm = false;
    uint8_t val;
    uint8_t reg[256];
    CMDF mdf;
    wxString url;
    wxTreeItemId newitem;

    wxBusyCursor wait;
    
    bSlowAlgorithm = m_slowAlgorithm->GetValue();
    
    uint8_t scanFrom = vscp_readStringValue(m_ctrlEditFrom->GetValue());
    uint8_t scanTo = vscp_readStringValue(m_ctrlEditTo->GetValue());
    
    if ( scanFrom >=  scanTo ) {
        wxMessageBox(_("Node to scan from must be less then to"));
        return;
    }

    m_DeviceTree->DeleteAllItems();
    m_htmlWnd->SetPage( "<html><body></body></html>" );
    m_htmlWnd->Update();

    wxProgressDialog progressDlg(_("Scanning for VSCP devices"),
            _("Reading Registers"),
            2*(scanTo-scanFrom+1),
            this,
            wxPD_ELAPSED_TIME | wxPD_AUTO_HIDE  | wxPD_CAN_ABORT);

    wxTreeItemId rootItem = m_DeviceTree->AddRoot(_("Found device(s)"));
    m_DeviceTree->ExpandAll();

    // Fetch GUID for the interface
	if ( USE_TCPIP_INTERFACE == m_csw.getDeviceType() ) {
		fetchIterfaceGUID();
	}

    if ( bSlowAlgorithm ) {

        for ( int i = scanFrom; i <= scanTo; i++ ) {

            if (!progressDlg.Update(i, wxString::Format(_("Checking for device %d"), i))) {
                if (m_DeviceTree->GetCount()) {
                    wxTreeItemIdValue cookie;
                    wxTreeItemId item = m_DeviceTree->GetFirstChild(m_DeviceTree->GetRootItem(), cookie);
                    if ( item.IsOk() ) m_DeviceTree->SelectItem( item );
                }
                ::wxEndBusyCursor();
                break;
            }

            if ( USE_DLL_INTERFACE == m_csw.getDeviceType() ) {

                // Empty input queue
                canalMsg canalmsg;
                while ( m_csw.getDllInterface()->doCmdDataAvailable() ) {
                    if ( CANAL_ERROR_SUCCESS != m_csw.getDllInterface()->doCmdReceive( &canalmsg ) ) break;
                }

                if ( CANAL_ERROR_SUCCESS == 
                    m_csw.getDllInterface()->readLevel1Register( i, 0, 0xd0, &val ) ) {

                    newitem = m_DeviceTree->AppendItem(rootItem, wxString::Format(_("Node with nickname=%d"), i));
                    m_DeviceTree->ExpandAll();
                    memset(reg, 0, sizeof(reg));

                    scanElement *pElement = new scanElement;
                    if (NULL != pElement) {
                        pElement->m_bLoaded = false;
                        pElement->m_nodeid = i;
                        //pElement->m_html = str; 
                        memset(pElement->m_reg, 0, 256);
                        m_DeviceTree->SetItemData(newitem, pElement);
                    }
                }

            } 
            else if (USE_TCPIP_INTERFACE == m_csw.getDeviceType()) {

                cguid destguid;
                destguid = m_ifguid;
                destguid.setLSB(i);

                // Empty input queue
                m_csw.getTcpIpInterface()->doCmdClear();

                if ( CANAL_ERROR_SUCCESS ==  
                    m_csw.getTcpIpInterface()->readLevel2Register( 0xd0,
                                                                    0,
                                                                    &val,
                                                                    m_ifguid,
                                                                    &destguid ) ) {

                    newitem = m_DeviceTree->AppendItem(rootItem, wxString::Format(_("Node with nickname=%d"), i));
                    m_DeviceTree->ExpandAll();
                    
                    scanElement *pElement = new scanElement;
                    if (NULL != pElement) {
                        pElement->m_bLoaded = false;
                        pElement->m_nodeid = i;
                        //pElement->m_html = str; 
                        memset(pElement->m_reg, 0, 256);
                        m_DeviceTree->SetItemData(newitem, pElement);
                    }
                     
                }

            }

            ::wxSafeYield();

        } // for
    }
    else { // Fast Algorithm

        vscpEventEx eventex;

		if (USE_DLL_INTERFACE == m_csw.getDeviceType()) {

            // Empty input queue
            canalMsg canalmsg;
            while ( m_csw.getDllInterface()->doCmdDataAvailable() ) {
                if ( CANAL_ERROR_SUCCESS != m_csw.getDllInterface()->doCmdReceive( &canalmsg ) ) break;
            }

			// Send read register to all nodes.
			for ( int i = scanFrom; i <= scanTo; i++ ) {

#ifdef WIN32				
				progressDlg.Update(i, wxString::Format(_("Checking for device %d"), i));
#endif				

				eventex.vscp_class = VSCP_CLASS1_PROTOCOL;
				eventex.vscp_type = VSCP_TYPE_PROTOCOL_READ_REGISTER;
				eventex.sizeData = 2;		// nodeid + register to read
				eventex.data[ 0 ] = i;		// nodeid
				eventex.data[ 1 ] = 0xd0;	// Register to read
				m_csw.doCmdSend( &eventex );
                wxMilliSleep( 20 );

			}


			// Check for replies
			wxLongLong resendTime = ::wxGetLocalTimeMillis();
       
			std::list<int> found_list;
			bool bLevel2 = false;
			uint8_t cnt = 0; 
			while (true) {
            
				progressDlg.Pulse( wxString::Format(_("Found %d"), found_list.size()));

				while ( m_csw.doCmdDataAvailable() ) {           // Message available

					if ( CANAL_ERROR_SUCCESS == m_csw.doCmdReceive( &eventex ) ) { // Valid event                
#if 0                    
							{
                                wxString str;
                                str = wxString::Format(_("Received Event: class=%d type=%d size=%d data= "), 
                                                            eventex.vscp_class, 
                                                            eventex.vscp_type, 
                                                            eventex.sizeData );
                                for ( int ii = 0; ii < eventex.sizeData; ii++ ) {
                                    str += wxString::Format(_("%02X "), eventex.data[ii] );
                                }
								wxLogDebug(str);
							}
#endif                    
							// Level I Read reply?
							if ( ( VSCP_CLASS1_PROTOCOL == eventex.vscp_class ) &&
									( VSCP_TYPE_PROTOCOL_RW_RESPONSE == eventex.vscp_type ) ) {
								if ( 0xd0 == eventex.data[ 0 ] ) { // Requested register?
									// Add nickname to list 
									found_list.push_back( eventex.GUID[15] );
								}
							}

						} // valid event

					} // Event is available

					if ((::wxGetLocalTimeMillis() - resendTime) > 3000 ) {

						// Take away duplicates
						found_list.unique();
                
						wxTreeItemId newitem;
						for( std::list<int>::iterator list_iter = found_list.begin(); 
							    list_iter != found_list.end(); list_iter++) {
                    
							newitem = m_DeviceTree->AppendItem(rootItem, wxString::Format(_("Node with nickname=%d"), *list_iter));
							m_DeviceTree->ExpandAll();
                    
							scanElement *pElement = new scanElement;
							if (NULL != pElement) {
								pElement->m_bLoaded = false;
								pElement->m_nodeid = *list_iter;
								pElement->m_html = _("Right click on item to load info about node."); 
								memset(pElement->m_reg, 0, 256);
								m_DeviceTree->SetItemData(newitem, pElement);
							}
						}
						break;

					}

			} // while

		
		} // TCP/IP
		else if (USE_TCPIP_INTERFACE == m_csw.getDeviceType()) {

            // Empty input queue
            m_csw.getTcpIpInterface()->doCmdClear();
           
			// Read register at all nodes.
			for ( int i=scanFrom; i<=scanTo; i++ ) {
            
				cguid destguid;
				destguid.setLSB(i);
                
				eventex.head = VSCP_PRIORITY_NORMAL;
				eventex.timestamp = 0;
				eventex.obid = 0;
                
				// Check if a specific interface is used
				if ( !m_ifguid.isNULL() ) {

					progressDlg.Update(i, wxString::Format(_("Checking for device %d"), i));

					eventex.vscp_class = VSCP_CLASS2_LEVEL1_PROTOCOL;
					eventex.vscp_type = VSCP_TYPE_PROTOCOL_READ_REGISTER;

					memset(eventex.GUID, 0, 16);// We use GUID for interface 
					eventex.sizeData = 16 + 2;  // Interface GUID + nodeid + register to read

					m_ifguid.writeGUID(eventex.data);

					eventex.data[ 16 ] = i;     // nodeid
					eventex.data[ 17 ] = 0xd0;  // Register to read

					m_csw.doCmdSend( &eventex );
                    wxMilliSleep( 10 );

				}
                else {
                    wxMessageBox( _("No interface specified. Please select one") );   
                    goto error;
                }
			
			} // for
                

			// Check for replies
			wxLongLong resendTime = ::wxGetLocalTimeMillis();
       
			std::list<int> found_list;
			bool bLevel2 = false;
			uint8_t cnt = 0; 
			while (true) {
            
				progressDlg.Pulse( wxString::Format(_("Found %d"), found_list.size()));

                while ( m_csw.doCmdDataAvailable() ) {      // Message available

					if ( CANAL_ERROR_SUCCESS == m_csw.doCmdReceive( &eventex ) ) { // Valid event
                    
#if 0                    
							{
							wxString str;
								str = wxString::Format(_("Received Event: class=%d type=%d size=%d data=%d %d"), 
									eventex.vscp_class, eventex.vscp_type, eventex.sizeData, eventex.data[15], eventex.data[16] );
								wxLogDebug(str);
							}
#endif                    

						// Level I Read reply?
						if ( ( VSCP_CLASS1_PROTOCOL == eventex.vscp_class ) &&
								(VSCP_TYPE_PROTOCOL_RW_RESPONSE == eventex.vscp_type)) {
							if (eventex.data[ 0 ] == 0xd0) { // Requested register?
								// Add nickname to list 
								found_list.push_back( eventex.GUID[ 15 ] );
							} // Check for correct node
						}                        // Level II 512 Read reply?
						else if (/*!m_ifguid.isNULL() && !bLevel2 &&*/
								(VSCP_CLASS2_LEVEL1_PROTOCOL == eventex.vscp_class) &&
							(VSCP_TYPE_PROTOCOL_RW_RESPONSE == eventex.vscp_type)) {

							//if ( pdestGUID->isSameGUID( event.GUID ) ) {
							// Reg we requested?
							if (0xd0 == eventex.data[ 16 ] ) {
                            
								// Add nickname to list 
								found_list.push_back( eventex.GUID[ 15 ] );
							}
							//}

						}                        // Level II Read reply?
						else if (m_ifguid.isNULL() && bLevel2 &&
								(VSCP_CLASS2_PROTOCOL == eventex.vscp_class) &&
								(VSCP2_TYPE_PROTOCOL_READ_WRITE_RESPONSE == 
							eventex.vscp_type)) {

							// from us
							uint32_t retreg = (eventex.data[ 0 ] << 24) +
												(eventex.data[ 1 ] << 16) +
												(eventex.data[ 2 ] << 8) +
												eventex.data[ 3 ];

							// Register we requested?
							if (retreg == 0xffffffd0) {
								// Add nickname to list 
								found_list.push_back( eventex.data[ 15 ] );
							}
						}

					} // valid event

				} //Event is available

				if ((::wxGetLocalTimeMillis() - resendTime) > 3000 ) {

					// Take away duplicates
					found_list.unique();
                
					wxTreeItemId newitem;
					for ( std::list<int>::iterator list_iter = found_list.begin(); 
							list_iter != found_list.end(); list_iter++) {
                    
						newitem = m_DeviceTree->AppendItem(rootItem, wxString::Format(_("Node with nickname=%d"), *list_iter));
						m_DeviceTree->ExpandAll();
                    
						scanElement *pElement = new scanElement;
						if (NULL != pElement) {
							pElement->m_bLoaded = false;
							pElement->m_nodeid = *list_iter;
							pElement->m_html = _("Right click on item to load info about node. Double click to open configuration window."); 
							memset(pElement->m_reg, 0, 256);
							m_DeviceTree->SetItemData( newitem, pElement );
						}
					}
					break;
            
				} // while
        
			}
        
		} // TCP/IP i/f     
		    
        
    }  // fast

    if ( m_DeviceTree->GetCount() ) {
        m_DeviceTree->SelectItem( m_DeviceTree->GetRootItem() );
    }

error:

    Raise();
    event.Skip(false);
   
}
Esempio n. 27
0
void guiPrefs::ViewContact(wxTreeItemId& id)
{
  m_loadDone = false;
  bool localChange = m_aChange;
  AuthLoad* pMyLoader = wxGetApp().AccessLoader();
  
  if (!pMyLoader)
    return;
/*
  wxTextCtrl * pName = (wxTextCtrl *)FindWindow( ID_CON_EDIT_NAME );
  
  wxComboBox * pInfoChoice = (wxComboBox *)FindWindow( ID_CON_EDIT_INFO_LIST );
  
  wxTextCtrl * pInfoText = (wxTextCtrl *)FindWindow ( ID_CON_EDIT_INFO_TEXT ),
    * pNetScreenName = (wxTextCtrl *)FindWindow ( ID_CON_EDIT_NETS_SCREEN_NAME );
  
  wxListBox * pUserNets = (wxListBox *)FindWindow ( ID_CON_EDIT_NETS_USER ),
    * pAllNets = (wxListBox *)FindWindow ( ID_CON_EDIT_NETS_ALL );
  
  wxChoice * pPrefChoice = (wxChoice *)FindWindow ( ID_CON_EDIT_NET_PREF );
*/

  if (!id.IsOk())
  {
    wxLogDebug("id is invalid in void guiPrefs::ViewContact()");
    return;
  }

  wxString l_name = GetTree().GetItemText(id);
  m_sxName = l_name;

  if (!pMyLoader->UserExists(l_name.c_str()) )
  {
    wxLogDebug("User does NOT exist in void guiPrefs::ViewContact()");
    return;
  }

  vector<string> all_nets;

  if (!pMyLoader->GetAvailableNets(all_nets))
  {
    wxLogDebug("GetAvailableNets() returns false in void guiPrefs::ViewContact()");
    return;
  }

  if (!pMyLoader->GetInfo(l_name.c_str(), m_itemsStorage))
  {
    wxLogDebug("GetInfo returned false in void guiPrefs::ViewContact()");
    return;
  }

  if (!pMyLoader->GetNets(l_name.c_str(), m_netsStorage))
  {
    wxLogDebug("GetNets returned false in void guiPrefs::ViewContact()");
    return;
  }

#ifdef __WXDEBUG__

  if (!pName || !pInfoChoice || !pInfoText || !pUserNets || !pAllNets || !pNetScreenName || !pPrefChoice )
  {
    wxLogDebug("A pointer from FindWindow is NULL!");
    return;
  }

#endif
  
  pName->SetValue(l_name);
  map<string, string>::const_iterator it;
  
  pInfoChoice->Clear();

  for (it=m_itemsStorage.begin(); it!=m_itemsStorage.end();it++)
  {
    pInfoChoice->Append(it->first.c_str());
  }

  if (pInfoChoice->GetCount() > 0)
  {
    pInfoText->SetValue(m_itemsStorage.begin()->second.c_str());
    pInfoChoice->SetSelection(0);
    m_iLastItemSelection = 0;
  }
  else
      m_iLastItemSelection = -1;

  pUserNets->Clear();

  for (it=m_netsStorage.begin(); it!=m_netsStorage.end();it++)
  {
    pUserNets->Append(it->first.c_str());
  }

  if(pUserNets->GetCount() > 0)
  {
    pUserNets->SetSelection(0);
    pNetScreenName->SetValue(m_netsStorage.begin()->second.c_str());
    m_iLastNetSelection = 0;
  }
  else
    m_iLastNetSelection = -1;

  pAllNets->Clear();

  for (unsigned int i = 0; i < all_nets.size(); i++)
  {
	  pAllNets->Append(all_nets[i].c_str());
  }

  if (!localChange)
  {
//    ActivateSave(false);
  }
  m_loadDone = true;
}
Esempio n. 28
0
bool wxSpinCtrl::Create(wxWindow *parent,
                        wxWindowID id,
                        const wxString& value,
                        const wxPoint& pos,
                        const wxSize& size,
                        long style,
                        int min, int max, int initial,
                        const wxString& name)
{
    // before using DoGetBestSize(), have to set style to let the base class
    // know whether this is a horizontal or vertical control (we're always
    // vertical)
    style |= wxSP_VERTICAL;

    if ( (style & wxBORDER_MASK) == wxBORDER_DEFAULT )
#ifdef __WXWINCE__
        style |= wxBORDER_SIMPLE;
#else
        style |= wxBORDER_SUNKEN;
#endif

    SetWindowStyle(style);

    WXDWORD exStyle = 0;
    WXDWORD msStyle = MSWGetStyle(GetWindowStyle(), & exStyle) ;

    // Scroll text automatically if there is not enough space to show all of
    // it, this is better than not allowing to enter more digits at all.
    msStyle |= ES_AUTOHSCROLL;

    // propagate text alignment style to text ctrl
    if ( style & wxALIGN_RIGHT )
        msStyle |= ES_RIGHT;
    else if ( style & wxALIGN_CENTER )
        msStyle |= ES_CENTER;

    // calculate the sizes: the size given is the total size for both controls
    // and we need to fit them both in the given width (height is the same)
    wxSize sizeText(size), sizeBtn(size);
    sizeBtn.x = wxSpinButton::DoGetBestSize().x;
    if ( sizeText.x <= 0 )
    {
        // DEFAULT_ITEM_WIDTH is the default width for the text control
        sizeText.x = DEFAULT_ITEM_WIDTH + MARGIN_BETWEEN + sizeBtn.x;
    }

    sizeText.x -= sizeBtn.x + MARGIN_BETWEEN;
    if ( sizeText.x <= 0 )
    {
        wxLogDebug(wxS("wxSpinCtrl \"%s\": initial width %d is too small, ")
                   wxS("at least %d pixels needed."),
                   name, size.x, sizeBtn.x + MARGIN_BETWEEN + 1);
    }

    wxPoint posBtn(pos);
    posBtn.x += sizeText.x + MARGIN_BETWEEN;

    // we must create the text control before the spin button for the purpose
    // of the dialog navigation: if there is a static text just before the spin
    // control, activating it by Alt-letter should give focus to the text
    // control, not the spin and the dialog navigation code will give focus to
    // the next control (at Windows level), not the one after it

    // create the text window

    m_hwndBuddy = (WXHWND)::CreateWindowEx
                    (
                     exStyle,                // sunken border
                     wxT("EDIT"),             // window class
                     NULL,                   // no window title
                     msStyle,                // style (will be shown later)
                     pos.x, pos.y,           // position
                     0, 0,                   // size (will be set later)
                     GetHwndOf(parent),      // parent
                     (HMENU)-1,              // control id
                     wxGetInstance(),        // app instance
                     NULL                    // unused client data
                    );

    if ( !m_hwndBuddy )
    {
        wxLogLastError(wxT("CreateWindow(buddy text window)"));

        return false;
    }


    // create the spin button
    if ( !wxSpinButton::Create(parent, id, posBtn, sizeBtn, style, name) )
    {
        return false;
    }

    wxSpinButtonBase::SetRange(min, max);

    // subclass the text ctrl to be able to intercept some events
    gs_spinForTextCtrl[GetBuddyHwnd()] = this;

    m_wndProcBuddy = (WXFARPROC)wxSetWindowProc(GetBuddyHwnd(),
                                                wxBuddyTextWndProc);

    // set up fonts and colours  (This is nomally done in MSWCreateControl)
    InheritAttributes();
    if (!m_hasFont)
        SetFont(GetDefaultAttributes().font);

    // set the size of the text window - can do it only now, because we
    // couldn't call DoGetBestSize() before as font wasn't set
    if ( sizeText.y <= 0 )
    {
        int cx, cy;
        wxGetCharSize(GetHWND(), &cx, &cy, GetFont());

        sizeText.y = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
    }

    SetInitialSize(size);

    (void)::ShowWindow(GetBuddyHwnd(), SW_SHOW);

    // associate the text window with the spin button
    (void)::SendMessage(GetHwnd(), UDM_SETBUDDY, (WPARAM)m_hwndBuddy, 0);

    // If the initial text value is actually a number, it overrides the
    // "initial" argument specified later.
    long initialFromText;
    if ( value.ToLong(&initialFromText) )
        initial = initialFromText;

    // Set the range in the native control: notice that we must do it before
    // calling SetValue() to use the correct validity checks for the initial
    // value.
    SetRange(min, max);
    SetValue(initial);

    // Also set the text part of the control if it was specified independently
    // but don't generate an event for this, it would be unexpected.
    m_blockEvent = true;
    if ( !value.empty() )
        SetValue(value);
    m_blockEvent = false;

    return true;
}
Esempio n. 29
0
/* static */
wxDynamicLibraryDetailsArray wxDynamicLibrary::ListLoaded()
{
    wxDynamicLibraryDetailsArray dlls;

#ifdef __LINUX__
    // examine /proc/self/maps to find out what is loaded in our address space
    wxFFile file(_T("/proc/self/maps"));
    if ( file.IsOpened() )
    {
        // details of the module currently being parsed
        wxString pathCur;
        void *startCur = NULL,
             *endCur = NULL;

        char path[1024];
        char buf[1024];
        while ( fgets(buf, WXSIZEOF(buf), file.fp()) )
        {
            // format is: "start-end perm offset maj:min inode path", see proc(5)
            void *start,
                 *end;
            switch ( sscanf(buf, "%p-%p %*4s %*p %*02x:%*02x %*d %1024s\n",
                            &start, &end, path) )
            {
                case 2:
                    // there may be no path column
                    path[0] = '\0';
                    break;

                case 3:
                    // nothing to do, read everything we wanted
                    break;

                default:
                    // chop '\n'
                    buf[strlen(buf) - 1] = '\0';
                    wxLogDebug(_T("Failed to parse line \"%s\" in /proc/self/maps."),
                               buf);
                    continue;
            }

            wxASSERT_MSG( start >= endCur,
                          _T("overlapping regions in /proc/self/maps?") );

            wxString pathNew = wxString::FromAscii(path);
            if ( pathCur.empty() )
            {
                // new module start
                pathCur = pathNew;
                startCur = start;
                endCur = end;
            }
            else if ( pathCur == pathNew && endCur == end )
            {
                // continuation of the same module in the address space
                endCur = end;
            }
            else // end of the current module
            {
                dlls.Add(wxDynamicLibraryDetailsCreator::New(startCur,
                                                             endCur,
                                                             pathCur));
                pathCur.clear();
            }
        }
    }
#endif // __LINUX__

    return dlls;
}
Esempio n. 30
0
bool StateGraphViewerPanel::Create(wxWindow *Parent,
                                   ContextNotifier &WithNotifier,
                                   ActionRecord &WithRecording,
                                   ActionReplayFrame &WithReplay,
                                   wxWindowID ID,
                                   wxPoint const &Position,
                                   wxSize const &Size)
{
  if (!wxPanel::Create(Parent, ID, Position, Size))
    return false;
  
  Notifier = &WithNotifier;
  Recording = &WithRecording;
  
  // Enable vfs access to request information about the state.
  auto const ThisAddr = reinterpret_cast<uintptr_t>(this);
  auto const CallbackProto = std::string{"seec"} + std::to_string(ThisAddr);
  
  CallbackFS = new seec::CallbackFSHandler(CallbackProto);
  
  CallbackFS->addCallback("notify_hover",
    std::function<void (std::string const &)>{
      [this] (std::string const &NodeID) -> void {
        this->OnMouseOver(NodeID);
      }
    });
  
  CallbackFS->addCallback("notify_contextmenu",
    std::function<void (std::string const &)>{
      [this] (std::string const &Foo) -> void {
        this->RaiseContextMenu();
      }
    });
  
  CallbackFS->addCallback("log_debug",
    std::function<void (std::string const &)>{
      [] (std::string const &Message) -> void {
        wxLogDebug("%s", wxString{Message});
      }
    });

  Bind(wxEVT_CONTEXT_MENU,
       &StateGraphViewerPanel::OnContextMenu, this);
  Bind(SEEC_EV_MOUSE_OVER_DISPLAYABLE,
       &StateGraphViewerPanel::OnMouseOverDisplayable, this);

  wxFileSystem::AddHandler(CallbackFS);
  
  // Get our resources from ICU.
  UErrorCode Status = U_ZERO_ERROR;
  auto Resources = seec::getResource("TraceViewer",
                                     getLocale(),
                                     Status,
                                     "StateGraphViewer");
  
  if (!U_SUCCESS(Status))
    return false;
  
  auto Sizer = new wxBoxSizer(wxVERTICAL);
  
  // Setup the webview.
  WebView = wxWebView::New(this, wxID_ANY);
  if (!WebView) {
    wxLogDebug("wxWebView::New failed.");
    return false;
  }
  
  WebView->RegisterHandler(wxSharedPtr<wxWebViewHandler>
                                      (new wxWebViewFSHandler("icurb")));
  WebView->RegisterHandler(wxSharedPtr<wxWebViewHandler>
                                      (new wxWebViewFSHandler(CallbackProto)));
  
  Sizer->Add(WebView, wxSizerFlags(1).Expand());
  SetSizerAndFit(Sizer);
  
  // Find the dot executable.
  PathToDot = getPathForDotExecutable();
  
  if (!PathToDot.empty())
  {
    // Determine the path to Graphviz's libraries, based on the location of dot.
    llvm::SmallString<256> PluginPath (PathToDot);
    
    llvm::sys::path::remove_filename(PluginPath);    // */bin/dot -> */bin
    llvm::sys::path::remove_filename(PluginPath);    // */bin    -> *
    llvm::sys::path::append(PluginPath, "lib");      // *      -> */lib
    
    PathToGraphvizLibraries = "DYLD_LIBRARY_PATH=";
    PathToGraphvizLibraries += PluginPath.str();
    
    llvm::sys::path::append(PluginPath, "graphviz"); // */lib -> */lib/graphviz
    
    PathToGraphvizPlugins = "GVBINDIR=";
    PathToGraphvizPlugins += PluginPath.str();
    
    // Setup the layout handler.
    {
      std::lock_guard<std::mutex> LockLayoutHandler (LayoutHandlerMutex);
      LayoutHandler.reset(new seec::cm::graph::LayoutHandler());
      LayoutHandler->addBuiltinLayoutEngines();
    }

    // After the webpage is loaded, setup the initial ColourScheme.
    WebView->Bind(wxEVT_WEBVIEW_LOADED,
      std::function<void (wxWebViewEvent &)>{
        [this] (wxWebViewEvent &Event) -> void {
          setupColourScheme(
            *wxGetApp().getColourSchemeSettings().getColourScheme());
          Event.Skip();
        }});

    // Load the webpage.
    auto const WebViewURL =
      std::string{"icurb://TraceViewer/StateGraphViewer/WebViewHTML#"}
      + CallbackProto;
    
    WebView->LoadURL(WebViewURL);
    
    // Wire up our event handlers.
    Bind(SEEC_EV_GRAPH_RENDERED, &StateGraphViewerPanel::OnGraphRendered, this);
    
    // Register for context notifications.
    Notifier->callbackAdd([this] (ContextEvent const &Ev) -> void {
      this->handleContextEvent(Ev); });

    // Handle future changes to the ColourScheme.
    wxGetApp().getColourSchemeSettings().addListener(
      [this] (ColourSchemeSettings const &Settings) {
        setupColourScheme(*Settings.getColourScheme());
      });

    // Handle UAR replay.
    WithReplay.RegisterHandler("StateGraphViewer.MouseOverValue",
                               {{"address", "type"}},
      seec::make_function(this, &StateGraphViewerPanel::replayMouseOverValue));
  }
  else {
    // If the user navigates to a link, open it in the default browser.
    WebView->Bind(wxEVT_WEBVIEW_NAVIGATING,
      std::function<void (wxWebViewEvent &)>{
        [] (wxWebViewEvent &Event) -> void {
          if (Event.GetURL().StartsWith("http")) {
            wxLaunchDefaultBrowser(Event.GetURL());
            Event.Veto();
          }
          else
            Event.Skip();
        }});
    
    std::string const WebViewURL =
      "icurb://TraceViewer/StateGraphViewer/StateGraphViewerNoGraphviz.html";
    
    // Load the webpage explaining that dot is required.
    WebView->LoadURL(WebViewURL);
  }
  
  // Create the worker thread that will perform our graph generation.
  WorkerThread = std::thread{
    [this] () { this->workerTaskLoop(); }};

  return true;
}