void BinaryDataEditor::import_value()
{
mforms::FileChooser chooser(mforms::OpenFile);
chooser.set_title("Import Field Data");
if (chooser.run_modal())
{
std::string path = chooser.get_path();
GError *error = 0;
char *data;
gsize length;
if (!g_file_get_contents(path.c_str(), &data, &length, &error))
{
mforms::Utilities::show_error(base::strfmt("Could not import data from %s", path.c_str()),
error->message, "OK");
g_error_free(error);
}
else
{
assign_data(data, length, true);
tab_changed();
}
}
}
void playlistWindow::on_saveplaylist_clicked(void){
static Glib::ustring working_dir = Glib::get_home_dir();
Gtk::FileChooserDialog chooser(*this,
"Save your playlist", Gtk::FILE_CHOOSER_ACTION_SAVE);
chooser.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
chooser.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_OK);
chooser.set_current_folder(working_dir);
const int response = chooser.run();
if(response == Gtk::RESPONSE_OK)
{
std::string filename = (isM3U(chooser.get_filename()))
? chooser.get_filename()
: chooser.get_filename()+".m3u";
if (fileExists(filename)) {
Gtk::MessageDialog dialog(*this, "File already exists",
false /* use_markup */, Gtk::MESSAGE_QUESTION,
Gtk::BUTTONS_OK_CANCEL);
dialog.set_secondary_text("A file named \""+Glib::filename_display_basename(chooser.get_filename())+"\"alreay exists." );
dialog.run();
int result = dialog.run();
//Handle the response:
if (result == Gtk::RESPONSE_OK) {
writeM3U(filename);
}
} else {
writeM3U(filename);
}
}
}
//
// Called from AppleKeyPairGenContext
//
void BSafe::BSafeKeyPairGenContext::generate(
const Context &context,
BinaryKey &pubBinKey, // valid on successful return
BinaryKey &privBinKey, // ditto
uint32 &keySize) // ditto
{
/* these casts throw exceptions if the keys are of the
* wrong classes, which is a major bogon, since we created
* the keys in the above generate() function */
BSafeBinaryKey &bsPubBinKey =
dynamic_cast<BSafeBinaryKey &>(pubBinKey);
BSafeBinaryKey &bsPrivBinKey =
dynamic_cast<BSafeBinaryKey &>(privBinKey);
if (!initialized) {
setupAlgorithm(context, keySize);
check(B_GenerateInit(bsAlgorithm, chooser(), bsSurrender), true);
initialized = true;
}
setRandom();
check(B_GenerateKeypair(bsAlgorithm,
bsPubBinKey.bsKey(),
bsPrivBinKey.bsKey(),
bsRandom,
bsSurrender), true);
}
void PixelMapCreator::saveAsPng( String name, OwnedArray<Slice>& slices, Point<int> resolution )
{
Image pixelMap = Image( Image::PixelFormat::ARGB, resolution.x, resolution.y, true );
Graphics g( pixelMap );
//create a sub array to get a better distribution of colors when lots of slices are disabled
Array<Slice*> visibleSlices;
for ( auto slice : slices )
if ( !slice->screenIsCollapsed && slice->enabled )
visibleSlices.add( slice );
for ( auto visibleSlice : visibleSlices )
{
PixelMapButton b( *visibleSlice );
b.updatePath( resolution );
b.paint( g, visibleSlices.indexOf( visibleSlice ) / (float) visibleSlices.size() );
}
File tempFile = File( File::getSpecialLocation( File::SpecialLocationType::userDesktopDirectory ).getFullPathName() + "/" + name + ".png" );
File pngFile;
FileChooser chooser("Export Pixelmap as...", tempFile, "*.png");
if ( chooser.browseForFileToSave( true ) )
{
pngFile = chooser.getResult();
if ( pngFile.exists() )
pngFile.deleteFile();
if ( !pngFile.hasFileExtension( "png" ) )
pngFile = File( pngFile.getParentDirectory().getFullPathName() + "/" + pngFile.getFileNameWithoutExtension() + ".png" );
FileOutputStream stream( pngFile );
PNGImageFormat pngWriter;
pngWriter.writeImageToStream( pixelMap, stream );
}
}
std::string EntityChooser::ChooseEntity(const std::string& preSelectedEntity)
{
gtkutil::Dialog dlg(_("Select Entity"), GlobalMainFrame().getTopLevelWindow());
Gdk::Rectangle rect = gtkutil::MultiMonitor::getMonitorForWindow(GlobalMainFrame().getTopLevelWindow());
dlg.set_default_size(static_cast<int>(rect.get_width()/2), static_cast<int>(2*rect.get_height()/3));
// Instantiate a new chooser class
EntityChooserPtr chooser(new EntityChooser);
chooser->setSelectedEntity(preSelectedEntity);
// add this to the dialog window
IDialog::Handle handle = dlg.addElement(chooser);
if (dlg.run() == IDialog::RESULT_OK)
{
return dlg.getElementValue(handle);
}
else
{
// Cancelled
return "";
}
}
void EditSearchEngine::chooseIcon()
{
IconChooser chooser(this);
QIcon icon = chooser.getIcon();
if (!icon.isNull()) {
setIcon(icon);
}
}
void PointViewerMainWindow::chooseBackground()
{
QColor originalColor = m_pointView->background();
QColorDialog chooser(originalColor, this);
connect(&chooser, SIGNAL(currentColorChanged(QColor)),
m_pointView, SLOT(setBackground(QColor)));
if (chooser.exec() == QDialog::Rejected)
m_pointView->setBackground(originalColor);
}
EGLConfig q_configFromGLFormat(EGLDisplay display, const QSurfaceFormat &format, bool highestPixelFormat, int surfaceType)
{
QEglConfigChooser chooser(display);
chooser.setSurfaceFormat(format);
chooser.setSurfaceType(surfaceType);
chooser.setIgnoreColorChannels(highestPixelFormat);
return chooser.chooseConfig();
}
bool CodeEditor::SaveAs(void)
{
FileChooser chooser(TRANS("Specify a file to save to..."), File::getSpecialLocation(File::userDocumentsDirectory));
if(chooser.browseForFileToSave(true)){
file = chooser.getResult(); //set the doucument's file to the new one
return Save();
}
return false;
}
void BSafe::BSafeContext::setRandom()
{
if (bsRandom == NULL) {
check(B_CreateAlgorithmObject(&bsRandom));
check(B_SetAlgorithmInfo(bsRandom, AI_X962Random_V0, NULL_PTR));
check(B_RandomInit(bsRandom, chooser(), bsSurrender));
uint8 seed[BSAFE_RANDSIZE];
session().getRandomBytes(BSAFE_RANDSIZE, seed);
check(B_RandomUpdate(bsRandom, seed, sizeof(seed), bsSurrender));
}
}
void VectorLayerWidget::chooseVectorResource() {
AssetChooser chooser(this, AssetChooser::Open, AssetDefs::Vector,
kProductSubtype);
if (chooser.exec() != QDialog::Accepted)
return;
QString newpath;
if (!chooser.getFullPath(newpath))
return;
vector_resource_label->setText(shortAssetName(newpath));
}
//---------------------------------------
//checks if current king is in check
int validation :: AmIInCheck()
{
//turn=1 white
// Find the king
Tile *temp1 = new Tile();
int kingrow;
int kingcol;
int KtileNum;
if(!turn) //turn==1 means white
{
kingrow=B/8;
kingcol=B%8;
temp1=tile[kingrow][kingcol];
KtileNum=temp1->tileNum;
}
else //turn==0 means black
{
kingrow=W/8;
kingcol=W%8;
temp1=tile[kingrow][kingcol];
KtileNum=temp1->tileNum;
}
//run through opps players pieces and check if I'm(turn) is in check
for (int Row = 0; Row < 8; ++Row) {
for (int Col = 0; Col < 8; ++Col) {
if (tile[Row][Col]->piece != 0)
{
if (tile[Row][Col]->pieceColor !=turn)
{
zero=0;
max=0;
while(zero<30)
exp[zero++]=0;
if(chooser(tile[Row][Col]))
{
for(i=0; i<max; i++)
{
if(KtileNum==exp[i])
return 1;
}
}
}
}
}
}
return 0;
}
void MainContentComponent::buttonClicked(Button* button)
{
if (&readFileButton == button) {
FileChooser chooser("Choose an image file to display...");
if (chooser.browseForFileToOpen()) {
origImage = ImageFileFormat::loadFrom(chooser.getResult());
if (origImage.isValid()) {
procImage = origImage.createCopy();
imageComponent.setImage(procImage);
}
}
} else if (&writeFileButton == button) {
if (procImage.isValid()) {
FileChooser chooser("Write processed image to file...");
if (chooser.browseForFileToSave(true)) {
FileOutputStream stream(chooser.getResult());
PNGImageFormat pngImageFormat;
pngImageFormat.writeImageToStream(procImage, stream);
}
}
}
}
//--------------------------------------
//checks if opposite king is in check
int validation :: IsInCheck()
{
// Find the king
Tile *temp1 = new Tile();
int kingrow;
int kingcol;
int KtileNum;
if(turn) //turn==1 means white
{
kingrow=B/8;
kingcol=B%8;
temp1=tile[kingrow][kingcol];
KtileNum=temp1->tileNum;
}
else //turn==0 means black
{
kingrow=W/8;
kingcol=W%8;
temp1=tile[kingrow][kingcol];
KtileNum=temp1->tileNum;
}
// Run through the current turn player pieces and see if any can take the king
for (int Row = 0; Row < 8; ++Row) {
for (int Col = 0; Col < 8; ++Col) {
if (tile[Row][Col]->piece != 0)
{
if (tile[Row][Col]->pieceColor ==turn)
{
zero=0;
max=0;
while(zero<30)
exp[zero++]=0;
if(chooser(tile[Row][Col]))
{
for(i=0; i<max; i++)
{
if(KtileNum==exp[i])
return 1;
}
}
}
}
}
}
return 0;
}
void MagicView::OnViewBackColor()
{
ModelView* view = GetModelViewByIndex(view_focus);
if (view) {
ActiveWindow* win = (ActiveWindow*) view->GetWindow();
Color c = win->GetBackColor();
COLORREF crgb = RGB(c.Red(), c.Green(), c.Blue());
CColorDialog chooser(crgb);
if (chooser.DoModal() == IDOK) {
crgb = chooser.GetColor();
win->SetBackColor( Color(GetRValue(crgb), GetGValue(crgb), GetBValue(crgb)) );
}
}
}
//
// DSA Parameter Generation
//
void BSafe::BSafeKeyPairGenContext::generate(
const Context &context,
uint32 bitSize,
CssmData ¶ms,
uint32 &attrCount,
Context::Attr * &attrs)
{
assert(context.algorithm() == CSSM_ALGID_DSA);
B_ALGORITHM_OBJ genAlg = NULL;
B_ALGORITHM_OBJ result = NULL;
try {
check(B_CreateAlgorithmObject(&genAlg));
B_DSA_PARAM_GEN_PARAMS genParams;
genParams.primeBits = bitSize;
check(B_SetAlgorithmInfo(genAlg, AI_DSAParamGen, POINTER(&genParams)));
setRandom();
check(B_GenerateInit(genAlg, chooser(), bsSurrender), true);
check(B_CreateAlgorithmObject(&result));
check(B_GenerateParameters(genAlg, result, bsRandom, bsSurrender));
// get parameters out of algorithm object
A_DSA_PARAMS *kParams = NULL;
check(B_GetAlgorithmInfo((POINTER *)&kParams, result, AI_DSAKeyGen), true);
// shred them into context attribute form
attrs = normAllocator->alloc<Context::Attr>(3);
attrs[0] = Context::Attr(CSSM_ATTRIBUTE_PRIME,
*BSafeItem(kParams->prime).copyp<CssmData>(*normAllocator));
attrs[1] = Context::Attr(CSSM_ATTRIBUTE_SUBPRIME,
*BSafeItem(kParams->subPrime).copyp<CssmData>(*normAllocator));
attrs[2] = Context::Attr(CSSM_ATTRIBUTE_BASE,
*BSafeItem(kParams->base).copyp<CssmData>(*normAllocator));
attrCount = 3;
// clean up
B_DestroyAlgorithmObject(&result);
B_DestroyAlgorithmObject(&genAlg);
} catch (...) {
// clean up
B_DestroyAlgorithmObject(&result);
B_DestroyAlgorithmObject(&genAlg);
throw;
}
}
void playlistWindow::on_addtoplaylist_clicked(void) {
static Glib::ustring working_dir = Glib::get_home_dir();
Gtk::FileChooserDialog chooser(*this,
"Select a media to add in the playlist", Gtk::FILE_CHOOSER_ACTION_OPEN);
chooser.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
chooser.add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
chooser.set_select_multiple(true);
chooser.set_current_folder(working_dir);
const int response = chooser.run();
if(response == Gtk::RESPONSE_OK)
{
working_dir = chooser.get_current_folder();
int countSelected = chooser.get_filenames().size();
for (int i=0;i<countSelected;i++) {
// create path to the file to play
std::string filename = "file://"+chooser.get_filenames().at(i);
// store the path
pathfilestoplay.push_back(filename);
//Fill the TreeView's model from the end
Gtk::TreeModel::Row row = *(playlistStore->append());
// track position
row[playlistColumns.playlistidcol] = getSize();
// find last dot in filename "name"
int lastindex = Glib::filename_display_basename(chooser.get_filenames().at(i)).find_last_of(".");
// copy what comes before last dot --> file name
std::string name = Glib::filename_display_basename(chooser.get_filenames().at(i)).substr (0,lastindex);
row[playlistColumns.playlistnamecol] = name;
row[playlistColumns.playlistlengthcol] = "unknown";
// find last dot in filename
lastindex = filename.find_last_of(".");
// copy what comes after last dot --> file extension
std::string fileextension = filename.substr (lastindex+1,filename.size()-(lastindex+1));
//lowerize the character
for(int j = 0; fileextension[j] != '\0'; j++){
fileextension[j] = tolower(fileextension[j]);
}
row[playlistColumns.playlistformatcol] = fileextension;
row[playlistColumns.playlistdateofcreationcol] = "unknown";
}
}
colorizePlaylist();
}
ETHEntity* ETHPhysicsSimulator::GetClosestContact(const Vector2& a, const Vector2& b, Vector2& point, Vector2& normal, const str_type::string& semicolonSeparatedIgnoreList)
{
if (a == b)
return 0;
ETHEntityNameArrayChooser chooser(semicolonSeparatedIgnoreList, true);
ETHRayCastCallback rayCastCallback(a, b, &chooser);
const b2Vec2& p1 = rayCastCallback.GetScaledA();
const b2Vec2& p2 = rayCastCallback.GetScaledB();
// verify it again since values have been scaled and this
// is an assert test in the box2D code
if (b2Vec2(p2 - p1).LengthSquared() <= 0.0f)
return 0;
m_world->RayCast(&rayCastCallback, p1, p2);
return rayCastCallback.GetClosestContact(point, normal);
}
void
GUI::importCB2(){
string filename;
Fl_File_Chooser chooser(".","Valid Files (*.{surfrev,extrude,obj})",Fl_File_Chooser::SINGLE, "Open file?");
chooser.show();
while(chooser.shown()){ Fl::wait(); }
if ( chooser.value() != NULL ){
filename = chooser.value();
bool load = control->addMesh(filename);
if(!load){
char msg[] = "Sorry. Invalid file.";
fl_alert(msg);
}
}
view->redraw();
}
void BinaryDataEditor::export_value()
{
mforms::FileChooser chooser(mforms::SaveFile);
chooser.set_title("Export Field Data");
if (chooser.run_modal())
{
std::string path = chooser.get_path();
GError *error = 0;
if (!g_file_set_contents(path.c_str(), _data, (gssize)_length, &error))
{
mforms::Utilities::show_error(base::strfmt("Could not export data to %s", path.c_str()),
error->message, "OK");
g_error_free(error);
}
}
}
bool OwlNestSettings::updateFirmware(){
DBG("Update firmware!");
AlertWindow alert("Update Firmware",
"Changing the firmware can make your OWL unresponsive! Are you sure you want to proceed?",
juce::AlertWindow::InfoIcon);
alert.addButton("Cancel", 0, juce::KeyPress(), juce::KeyPress());
alert.addButton("Continue", 1, juce::KeyPress(), juce::KeyPress());
if(alert.runModalLoop() == 1){
alert.setVisible(false);
FileChooser chooser("Select Firmware", ApplicationConfiguration::getApplicationDirectory(), "*.bin");
if(chooser.browseForFileToOpen()){
PropertySet* props = ApplicationConfiguration::getApplicationProperties();
String options = props->getValue("firmware-dfu-options");
File file = chooser.getResult();
return deviceFirmwareUpdate(file, options);
}
}
return false;
}
void InterfaceComponent::buttonClicked (juce::Button* button)
{
if (button == &btnBrowse)
{
juce::FileChooser chooser ("Select the folder which contains the code files you want to modularise");
if (chooser.browseForDirectory())
{
const juce::File folder (chooser.getResult());
txtSourceFileFolder.setText (folder.getFullPathName().trim(), juce::sendNotification);
txtDestinationFolder.setText (folder.getParentDirectory().getFullPathName().trim(), juce::sendNotification);
files = Modulariser (folder, true).getFiles();
fileListBox.setSelectedRows (juce::SparseSet<int>());
fileListBox.updateContent();
}
}
else if (button == &btnRefresh)
{
refresh();
}
else if (button == &btnGenerate)
{
const juce::String srcFolder (txtSourceFileFolder.getText().trim());
const juce::String destFolder (txtDestinationFolder.getText().trim());
if (srcFolder.isNotEmpty()
&& destFolder.isNotEmpty()
&& juce::File::isAbsolutePath (srcFolder)
&& juce::File::isAbsolutePath (destFolder))
{
Modulariser modulariser (files);
modulariser.saveTo (juce::File (destFolder),
srcFolder,
txtModuleFilename.getText().trim(),
txtHeaderGuard.getText().trim(),
txtNamespace.getText().trim());
}
}
}
EGLConfig QEglFSIntegration::chooseConfig(EGLDisplay display, const QSurfaceFormat &format)
{
class Chooser : public QEglConfigChooser {
public:
Chooser(EGLDisplay display, QEglFSHooks *hooks)
: QEglConfigChooser(display)
, m_hooks(hooks)
{
}
protected:
bool filterConfig(EGLConfig config) const
{
return m_hooks->filterConfig(display(), config) && QEglConfigChooser::filterConfig(config);
}
private:
QEglFSHooks *m_hooks;
};
Chooser chooser(display, QEglFSHooks::hooks());
chooser.setSurfaceFormat(format);
return chooser.chooseConfig();
}
QString KisImportExportManager::importDocument(const QString& url,
const QString& documentMimeType,
KisImportExportFilter::ConversionStatus& status)
{
// Find the mime type for the file to be imported.
QString typeName(documentMimeType);
QUrl u(url);
QMimeType t;
if (documentMimeType.isEmpty()) {
QMimeDatabase db;
db.mimeTypeForFile(u.path(), QMimeDatabase::MatchExtension);
if (t.isValid())
typeName = t.name();
}
m_graph.setSourceMimeType(typeName.toLatin1()); // .latin1() is okay here (Werner)
if (!m_graph.isValid()) {
bool userCancelled = false;
warnFile << "Can't open " << typeName << ", trying filter chooser";
if (m_document) {
if (!m_document->isAutoErrorHandlingEnabled()) {
status = KisImportExportFilter::BadConversionGraph;
return QString();
}
QByteArray nativeFormat = m_document->nativeFormatMimeType();
QApplication::setOverrideCursor(Qt::ArrowCursor);
KisFilterChooser chooser(0,
KisImportExportManager::mimeFilter(nativeFormat, KisImportExportManager::Import,
m_document->extraNativeMimeTypes()), nativeFormat, u);
if (chooser.exec()) {
QByteArray f = chooser.filterSelected().toLatin1();
if (f == nativeFormat) {
status = KisImportExportFilter::OK;
QApplication::restoreOverrideCursor();
return url;
}
m_graph.setSourceMimeType(f);
} else
userCancelled = true;
QApplication::restoreOverrideCursor();
}
if (!m_graph.isValid()) {
errFile << "Couldn't create a valid graph for this source mimetype: "
<< typeName;
importErrorHelper(typeName, userCancelled);
status = KisImportExportFilter::BadConversionGraph;
return QString();
}
}
KisFilterChain::Ptr chain(0);
// Are we owned by a KisDocument?
if (m_document) {
QByteArray mimeType = m_document->nativeFormatMimeType();
QStringList extraMimes = m_document->extraNativeMimeTypes();
int i = 0;
int n = extraMimes.count();
chain = m_graph.chain(this, mimeType);
while (i < n) {
QByteArray extraMime = extraMimes[i].toUtf8();
// TODO check if its the same target mime then continue
KisFilterChain::Ptr newChain(0);
newChain = m_graph.chain(this, extraMime);
if (!chain || (newChain && newChain->weight() < chain->weight()))
chain = newChain;
++i;
}
} else if (!d->importMimeType.isEmpty()) {
chain = m_graph.chain(this, d->importMimeType);
} else {
errFile << "You aren't supposed to use import() from a filter!" << endl;
status = KisImportExportFilter::UsageError;
return QString();
}
if (!chain) {
errFile << "Couldn't create a valid filter chain!" << endl;
importErrorHelper(typeName);
status = KisImportExportFilter::BadConversionGraph;
return QString();
}
// Okay, let's invoke the filters one after the other
m_direction = Import; // vital information!
m_importUrl = url; // We want to load that file
m_exportUrl.clear(); // This is null for sure, as embedded stuff isn't
// allowed to use that method
status = chain->invokeChain();
m_importUrl.clear(); // Reset the import URL
if (status == KisImportExportFilter::OK)
return chain->chainOutput();
return QString();
}
KisImportExportFilter::ConversionStatus KisImportExportManager::exportDocument(const QString& url, QByteArray& mimeType)
{
bool userCancelled = false;
// The import url should already be set correctly (null if we have a KisDocument
// file manager and to the correct URL if we have an embedded manager)
m_direction = Export; // vital information!
m_exportUrl = url;
KisFilterChain::Ptr chain;
if (m_document) {
// We have to pick the right native mimetype as source.
QStringList nativeMimeTypes;
nativeMimeTypes.append(m_document->nativeFormatMimeType());
nativeMimeTypes += m_document->extraNativeMimeTypes();
QStringList::ConstIterator it = nativeMimeTypes.constBegin();
const QStringList::ConstIterator end = nativeMimeTypes.constEnd();
for (; !chain && it != end; ++it) {
m_graph.setSourceMimeType((*it).toLatin1());
if (m_graph.isValid())
chain = m_graph.chain(this, mimeType);
}
} else if (!m_importUrlMimetypeHint.isEmpty()) {
dbgFile << "Using the mimetype hint:" << m_importUrlMimetypeHint;
m_graph.setSourceMimeType(m_importUrlMimetypeHint);
} else {
QUrl u;
u.setPath(m_importUrl);
QMimeDatabase db;
QMimeType t = db.mimeTypeForFile(u.path(), QMimeDatabase::MatchExtension);
if (!t.isValid() || t.isDefault()) {
errFile << "No mimetype found for" << m_importUrl;
return KisImportExportFilter::BadMimeType;
}
m_graph.setSourceMimeType(t.name().toLatin1());
if (!m_graph.isValid()) {
warnFile << "Can't open" << t.name() << ", trying filter chooser";
QApplication::setOverrideCursor(Qt::ArrowCursor);
KisFilterChooser chooser(0, KisImportExportManager::mimeFilter(), QString(), u);
if (chooser.exec())
m_graph.setSourceMimeType(chooser.filterSelected().toLatin1());
else
userCancelled = true;
QApplication::restoreOverrideCursor();
}
}
if (!m_graph.isValid()) {
errFile << "Couldn't create a valid graph for this source mimetype.";
if (!d->batch && !userCancelled) {
QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not export file: the export filter is missing."));
}
return KisImportExportFilter::BadConversionGraph;
}
if (!chain) // already set when coming from the m_document case
chain = m_graph.chain(this, mimeType);
if (!chain) {
errFile << "Couldn't create a valid filter chain to " << mimeType << " !" << endl;
if (!d->batch) {
QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not export file: the export filter is missing."));
}
return KisImportExportFilter::BadConversionGraph;
}
return chain->invokeChain();
}
bool OwlNestSettings::downloadFromServer(CommandID commandID) {
String nodeString, optionString, warningString;
PropertySet* props = ApplicationConfiguration::getApplicationProperties();
switch (commandID){
case ApplicationCommands::checkForFirmwareUpdates:
warningString = "Beware that this procedure can make your OWL unresponsive!";
nodeString = "firmwares";
optionString = props->getValue("firmware-dfu-options");
break;
case ApplicationCommands::checkForBootloaderUpdates:
warningString = "Beware that this procedure can brick your OWL!";
nodeString = "bootloaders";
optionString = props->getValue("bootloader-dfu-options");
break;
default:
return false;
}
String xmlFilename ("updates.xml");
URL url(props->getValue("owl-updates-dir-url")+xmlFilename);
ScopedPointer<XmlElement> xmlUpdates;
if(url.isWellFormed())
xmlUpdates = url.readEntireXmlStream(0);
if(xmlUpdates == NULL) {
AlertWindow::showMessageBoxAsync(AlertWindow::WarningIcon, "Connection Error", "Server connection failed");
return false;
}
XmlElement* filesNode = xmlUpdates->getChildByName(nodeString);
StringArray names;
XmlElement* child = filesNode->getFirstChildElement();
while(child != nullptr){
names.add(child->getStringAttribute("name"));
child = child->getNextElement();
}
AlertWindow popup("Download File From Server", "Choose file:", juce::AlertWindow::InfoIcon);
popup.addButton("Cancel", 0, juce::KeyPress(), juce::KeyPress());
popup.addButton("Download", 1, juce::KeyPress(), juce::KeyPress());
popup.addComboBox("box", names);
if(popup.runModalLoop()==0)
return false;
popup.setVisible(false);
String selectedFilename(popup.getComboBoxComponent("box")->getText());
URL fwUrl(props->getValue("owl-updates-dir-url")+selectedFilename);
ScopedPointer<InputStream> strm;
strm = fwUrl.createInputStream(0);
if(strm == NULL){
AlertWindow::showMessageBoxAsync(AlertWindow::WarningIcon, "Connection Error", "File unavailable", "Continue");
return false;
}
File theTargetFile(ApplicationConfiguration::getApplicationDirectory().getChildFile(selectedFilename));
FileChooser chooser("Save As", theTargetFile, "*.bin");
bool succeeded = false;
if(!chooser.browseForFileToSave(true))
return false;
theTargetFile = chooser.getResult();
TemporaryFile temp (theTargetFile);
ScopedPointer<FileOutputStream> out(temp.getFile().createOutputStream());
if(out != nullptr) {
out->writeFromInputStream(*strm, strm->getTotalLength());
out = nullptr; // deletes the stream
succeeded = temp.overwriteTargetFileWithTemporary();
}
if(!succeeded){
AlertWindow::showMessageBoxAsync(AlertWindow::WarningIcon, "File Error", "Failed to save file", "Continue");
return false;
}
if(AlertWindow::showOkCancelBox(AlertWindow::QuestionIcon, "Update Device",
"Would you like to update your OWL with this binary now? "+warningString, "Yes", "No"))
{
DBG("pathName"<< theTargetFile.getFullPathName());
DBG("optionString " << optionString);
return deviceFirmwareUpdate(theTargetFile, optionString);
}
return true;
}
void FindAndReplaceShader::onChooseReplace(GtkWidget* widget, FindAndReplaceShader* self) {
// Construct the modal dialog, enters a main loop
ShaderChooser chooser(NULL, GTK_WINDOW(self->getWindow()), self->_replaceEntry);
}
void TrackComponent::mouseDown(const MouseEvent &e) {
ModifierKeys modifiers = ModifierKeys::getCurrentModifiersRealtime();
int posX;
// check the mod keys ..
if (modifiers.isPopupMenu() || modifiers.isCtrlDown())
{
ScopedPointer<PopupMenu> trackMenu_ = new PopupMenu();
trackMenu_->clear();
trackMenu_->addCommandItem(&_commands, MainWindow::showMixer);
trackMenu_->addItem(1, "Add Region", true);
MouseEvent ev = e.getEventRelativeTo(this);
for(auto region : _regionComponents)
{
posX = ev.x;
region->setBroughtToFrontOnMouseClick(true);
if(region->getPositionX() < posX && posX < (region->getPositionX() + region->getRegionWidth()))
{
trackMenu_->addItem(2, "Remove Region", true);
}
}
switch (trackMenu_->show())
{
case 1:
{
FileChooser chooser("Select an audio file to add...",
File::nonexistent,
"*.wav; *aif; *.flac");
if (chooser.browseForFileToOpen()) {
File audioFile(chooser.getResult());
const String fileString = audioFile.getFullPathName();
String format;
if (fileString.contains(".wav"))
format = "WAV";
else if (fileString.contains(".aif") || fileString.contains(".aiff"))
format = "AIFF";
else if (fileString.contains(".flac"))
format = "FLAC";
AudioFormatManager formatManager;
formatManager.registerBasicFormats();
AudioFormatReader* reader = formatManager.createReaderFor(audioFile);
Audio::Region* region = new Audio::SampleRegion(reader, 1, &audioFile);
Point<int> position = e.getPosition();
int x = position.getX();
if (x > _mixerOffset)
{
int64 samplesRange = secondsToSamples(100, _sampleRate);
int64 positionSamples = pixelsToSamples(x - _mixerOffset, 100 * _pixelsPerClip, samplesRange);
_track->add(positionSamples, region);
createRegionGUI(x, region, formatManager, audioFile);
getParentComponent()->resized();
}
else if (x < _mixerOffset)
{
_track->add(0, region);
createRegionGUI(_mixerOffset, region, formatManager, audioFile);
getParentComponent()->resized();
}
}
}
break;
case 2:
{
CriticalSection critical;
critical.enter();
for(size_t i = 0; i < _regionComponents.size(); ++i)
{
Rectangle<int> bounds_ = _regionComponents.at(i)->getBounds();
posX = ev.x;
if((int)_regionComponents.at(i)->getPositionX() < posX && posX < ((int)_regionComponents.at(i)->getPositionX() + (int)_regionComponents.at(i)->getRegionWidth()))
{
_track->remove(_regionComponents.at(i)->getRegion(), _posX.at(i));
std::vector<RegionComponent*>::iterator regit = _regionComponents.begin() + i;
RegionComponent* component = _regionComponents.at(i);
removeChildComponent(_regionComponents.at(i));
_regionComponents.erase(regit);
delete component;
_regions.erase(_posX.at(i));
std::vector<int64>::iterator posit = _posX.begin() + i;;
_posX.erase(posit);
std::vector<int64>::iterator sampsit = _sizeSamps.begin() + i;;
_sizeSamps.erase(sampsit);
}
}
critical.exit();
}
default:
break;
}
}
}
EGLConfig QEglFSIntegration::chooseConfig(EGLDisplay display, const QSurfaceFormat &format)
{
QEglConfigChooser chooser(display);
chooser.setSurfaceFormat(format);
return chooser.chooseConfig();
}
void SoundboardAudioProcessorEditor::buttonClicked(Button *buttonThatWasClicked)
{
if (loadDirectoryButton == buttonThatWasClicked)
{
FileChooser chooser("Open...");
if (chooser.browseForDirectory())
{
auto directory = chooser.getResult();
if (directory.isDirectory())
{
processor.openDirectory(directory);
table->updateContent();
grid->updateContent();
}
}
}
else if (settingsButton == buttonThatWasClicked)
{
DialogWindow::LaunchOptions launchOptions;
launchOptions.componentToCentreAround = this;
launchOptions.content.setOwned(new SoundboardSettingsComponent(processor));
launchOptions.content->setSize(640, 480);
launchOptions.dialogBackgroundColour = Colours::black;
launchOptions.dialogTitle = TRANS("Soundboard Settings");
launchOptions.escapeKeyTriggersCloseButton = true;
launchOptions.resizable = true;
launchOptions.useNativeTitleBar = true;
launchOptions.runModal();
}
else if (gridButton == buttonThatWasClicked)
{
gridButton->setEnabled(false);
listButton->setEnabled(true);
table->setVisible(false);
grid->setVisible(true);
grid->toFront(true);
if (resizableCornerComponent)
{
resizableCornerComponent->toFront(false);
}
}
else if (listButton == buttonThatWasClicked)
{
listButton->setEnabled(false);
gridButton->setEnabled(true);
grid->setVisible(false);
table->setVisible(true);
table->toFront(true);
if (resizableCornerComponent)
{
resizableCornerComponent->toFront(false);
}
}
else if (duckButton == buttonThatWasClicked) {
bool ducking = processor.getOscManager()->getOscParameterValue("/ultraschall/soundboard/duck/enabled");
processor.getOscManager()->setOscParameterValue("/ultraschall/soundboard/duck/enabled", !ducking);
if (!ducking) {
duckButton->setButtonText(FontAwesome_Comment);
} else {
duckButton->setButtonText(FontAwesome_Comment_O);
}
}
else if (lockButton == buttonThatWasClicked) {
processor.toggleLocked();
if (processor.getLocked()) {
lockButton->setButtonText(FontAwesome_Lock);
} else {
lockButton->setButtonText(FontAwesome_Unlock);
}
}
}
