//#define DEBUG
int main() {
pthread_t schedulerThread;
epfd = epollCreate(100);
struct threadpool *pool;
if ((pool = threadpool_init(100)) == NULL ) {
printf("Error! Failed to create a thread pool struct.\n");
exit(EXIT_FAILURE);
}
int sockfd;
int newsockfd, newschedule;
sockfd = Create();
int schedulerfd = Create();
if (Bind(35000, sockfd) < 0) {
printf("error in bind");
exit(0);
}
if (Bind(35001, schedulerfd) < 0) {
printf("error in bind");
exit(0);
}
Listen(sockfd, 10);
Listen(schedulerfd, 10);
pthread_create(&schedulerThread, 0, (void*) &schedule, NULL);
int i = 0;
while (i < 100) {
incClient();
newsockfd = Accept(sockfd);
if (numClient() <= 100) {
Send(newsockfd, "ACCEPT", strlen("ACCEPT") + 1);
newschedule = Accept(schedulerfd);
fprintf(stderr, "Connection established with scheduler");
sockets newsock;
newsock.active = 1;
newsock.priority = 1;
newsock.schedulerSocket = newschedule;
newsock.workerSocket = newsockfd;
socketList = addToList(socketList, newsock);
#ifdef DEBUG
if(socketList==NULL) {
fprintf(stderr,"socketlist is null");
exit(0);
}
#endif
epollAdd(epfd, newschedule);
int ret = threadpool_add_task(pool, negotiator, (void*) &newsockfd,
1);
} else {
Send(newsockfd, "REJECT", strlen("REJECT") + 1);
close(newsockfd);
}
i++;
}
sleep(10);
Close(sockfd);
printf("shutting down");
return 0;
}
// -----------------------------------------------------------------------------
// TextureXEditor class constructor
// -----------------------------------------------------------------------------
TextureXEditor::TextureXEditor(wxWindow* parent) : wxPanel(parent, -1)
{
// Init variables
undo_manager_ = std::make_unique<UndoManager>();
wxWindowBase::SetName("texturex");
// Create texture menu
menu_texture_ = new wxMenu();
SAction::fromId("txed_new")->addToMenu(menu_texture_);
SAction::fromId("txed_new_patch")->addToMenu(menu_texture_);
SAction::fromId("txed_new_file")->addToMenu(menu_texture_);
SAction::fromId("txed_delete")->addToMenu(menu_texture_);
menu_texture_->AppendSeparator();
SAction::fromId("txed_rename")->addToMenu(menu_texture_);
SAction::fromId("txed_rename_each")->addToMenu(menu_texture_);
auto menu_export = new wxMenu();
SAction::fromId("txed_export")->addToMenu(menu_export, "Archive (as image)");
SAction::fromId("txed_extract")->addToMenu(menu_export, "File");
menu_texture_->AppendSubMenu(menu_export, "&Export To");
menu_texture_->AppendSeparator();
SAction::fromId("txed_copy")->addToMenu(menu_texture_);
SAction::fromId("txed_cut")->addToMenu(menu_texture_);
SAction::fromId("txed_paste")->addToMenu(menu_texture_);
menu_texture_->AppendSeparator();
SAction::fromId("txed_up")->addToMenu(menu_texture_);
SAction::fromId("txed_down")->addToMenu(menu_texture_);
SAction::fromId("txed_sort")->addToMenu(menu_texture_);
auto menu_patch = new wxMenu();
SAction::fromId("txed_patch_add")->addToMenu(menu_patch);
SAction::fromId("txed_patch_remove")->addToMenu(menu_patch);
SAction::fromId("txed_patch_replace")->addToMenu(menu_patch);
SAction::fromId("txed_patch_back")->addToMenu(menu_patch);
SAction::fromId("txed_patch_forward")->addToMenu(menu_patch);
SAction::fromId("txed_patch_duplicate")->addToMenu(menu_patch);
menu_texture_->AppendSubMenu(menu_patch, "&Patch");
// Create patch browser
patch_browser_ = new PatchBrowser(theMainWindow);
patch_browser_->CenterOnParent();
patch_browser_->Show(false);
// Setup sizer
auto sizer = new wxBoxSizer(wxVERTICAL);
SetSizer(sizer);
// Add tabs
tabs_ = STabCtrl::createControl(this);
sizer->Add(tabs_, 1, wxEXPAND | wxALL, UI::pad());
// Bind events
Bind(wxEVT_SHOW, &TextureXEditor::onShow, this);
// Palette chooser
listenTo(theMainWindow->paletteChooser());
updateTexturePalette();
// Listen to patch table
listenTo(&patch_table_);
// Listen to resource manager
listenTo(&App::resources());
// Update + layout
wxWindowBase::Layout();
wxWindow::Show();
}
UninstallForm::UninstallForm(wxWindow* parent, UserCore::UserI* user) : wxFrame(parent, wxID_ANY, PRODUCT_NAME_CATW(L" UnInstaller"), wxDefaultPosition, wxSize( 500,330 ), wxCAPTION|wxMINIMIZE_BOX|wxSYSTEM_MENU|wxTAB_TRAVERSAL )
{
m_pUser = user;
wxPanel* pTitlePanel = new wxPanel( this, wxID_ANY, wxDefaultPosition, wxSize( -1,57 ), wxTAB_TRAVERSAL );
pTitlePanel->SetBackgroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_BTNHIGHLIGHT ) );
m_labTitle = new wxStaticText(pTitlePanel, wxID_ANY, Managers::GetString(L"#DUN_UNINSTALL_HEADER"), wxDefaultPosition, wxDefaultSize, 0 );
m_labTitleInfo = new wxStaticText(pTitlePanel, wxID_ANY, Managers::GetString(L"#DUN_UNINSTALL_SUBHEADER"), wxDefaultPosition, wxDefaultSize, 0 );
m_imgLogo = new wxStaticBitmap(this, wxID_ANY, wxBitmap(wxT("IDI_HEADER"), wxBITMAP_TYPE_RESOURCE ), wxDefaultPosition, wxSize( 150,57 ), 0 );
m_staticline1 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
m_butRepair = new wxButton( this, wxID_ANY, Managers::GetString(L"#DUN_REPAIR"), wxDefaultPosition, wxDefaultSize, 0 );
m_butUninstall = new wxButton( this, wxID_ANY, Managers::GetString(L"#DUN_UNINSTALL"), wxDefaultPosition, wxDefaultSize, 0 );
m_butCancel = new wxButton( this, wxID_ANY, Managers::GetString(L"#CANCEL"), wxDefaultPosition, wxDefaultSize, 0 );
wxFont font = m_labTitle->GetFont();
font.SetWeight(wxFONTWEIGHT_BOLD);
m_labTitle->SetFont(font);
m_pContent = new UDFSettingsPanel(this);
m_bContentSizer = new wxBoxSizer( wxHORIZONTAL );
m_bContentSizer->Add(m_pContent, 1, wxEXPAND, 5);
wxBoxSizer* bSizer1 = new wxBoxSizer( wxHORIZONTAL );
bSizer1->Add( 0, 0, 1, wxEXPAND, 5 );
bSizer1->Add( m_butRepair, 0, wxTOP|wxBOTTOM|wxLEFT, 5 );
bSizer1->Add( m_butUninstall, 0, wxTOP|wxBOTTOM|wxLEFT, 5 );
bSizer1->Add( m_butCancel, 0, wxALL, 5 );
wxFlexGridSizer* fgSizer2 = new wxFlexGridSizer( 2, 2, 0, 0 );
fgSizer2->SetFlexibleDirection( wxBOTH );
fgSizer2->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );
fgSizer2->Add( 10, 0, 1, wxEXPAND, 5 );
fgSizer2->Add( m_labTitle, 0, wxALL, 5 );
fgSizer2->Add( 0, 0, 1, wxEXPAND, 5 );
fgSizer2->Add( m_labTitleInfo, 0, wxLEFT, 15 );
pTitlePanel->SetSizer( fgSizer2 );
pTitlePanel->Layout();
wxFlexGridSizer* fgSizer3 = new wxFlexGridSizer( 1, 2, 0, 0 );
fgSizer3->AddGrowableCol( 0 );
fgSizer3->SetFlexibleDirection( wxBOTH );
fgSizer3->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );
fgSizer3->Add( pTitlePanel, 1, wxEXPAND, 5 );
fgSizer3->Add( m_imgLogo, 0, 0, 5 );
wxFlexGridSizer* fgSizer1;
fgSizer1 = new wxFlexGridSizer( 5, 1, 0, 0 );
fgSizer1->AddGrowableCol( 0 );
fgSizer1->AddGrowableRow( 2 );
fgSizer1->SetFlexibleDirection( wxBOTH );
fgSizer1->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );
fgSizer1->Add( fgSizer3, 1, wxEXPAND, 5 );
fgSizer1->Add( 0, 0, 1, wxEXPAND, 5 );
fgSizer1->Add( m_bContentSizer, 1, wxEXPAND|wxLEFT|wxRIGHT, 10 );
fgSizer1->Add( m_staticline1, 1, wxEXPAND, 5 );
fgSizer1->Add( bSizer1, 1, wxEXPAND, 5 );
SetBackgroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_3DLIGHT ) );
this->SetSizer( fgSizer1 );
this->Layout();
this->Centre( wxBOTH );
SetIcon(wxIcon(wxICON(IDI_ICONNORMAL)));
Bind(wxEVT_COMMAND_BUTTON_CLICKED, &UninstallForm::onButtonClicked, this);
m_bComplete = false;
}
DialogStyling::DialogStyling(agi::Context *context)
: wxDialog(context->parent, -1, _("Styling Assistant"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER | wxMINIMIZE_BOX)
, c(context)
, active_line_connection(context->selectionController->AddActiveLineListener(&DialogStyling::OnActiveLineChanged, this))
, active_line(nullptr)
{
SetIcon(GETICON(styling_toolbutton_16));
wxSizer *main_sizer = new wxBoxSizer(wxVERTICAL);
wxSizer *bottom_sizer = new wxBoxSizer(wxHORIZONTAL);
{
wxSizer *cur_line_box = new wxStaticBoxSizer(wxHORIZONTAL, this, _("Current line"));
current_line_text = new wxTextCtrl(this, -1, _("Current line"), wxDefaultPosition, wxSize(300, 60), wxTE_MULTILINE | wxTE_READONLY);
cur_line_box->Add(current_line_text, 1, wxEXPAND, 0);
main_sizer->Add(cur_line_box, 0, wxEXPAND | wxALL, 5);
}
{
wxSizer *styles_box = new wxStaticBoxSizer(wxVERTICAL, this, _("Styles available"));
style_list = new wxListBox(this, -1, wxDefaultPosition, wxSize(150, 180), to_wx(context->ass->GetStyles()));
styles_box->Add(style_list, 1, wxEXPAND, 0);
bottom_sizer->Add(styles_box, 1, wxEXPAND | wxRIGHT, 5);
}
wxSizer *right_sizer = new wxBoxSizer(wxVERTICAL);
{
wxSizer *style_text_box = new wxStaticBoxSizer(wxHORIZONTAL, this, _("Set style"));
style_name = new wxTextCtrl(this, -1, "", wxDefaultPosition, wxSize(180, -1), wxTE_PROCESS_ENTER);
style_text_box->Add(style_name, 1, wxEXPAND);
right_sizer->Add(style_text_box, 0, wxEXPAND | wxBOTTOM, 5);
}
{
wxSizer *hotkey_box = new wxStaticBoxSizer(wxVERTICAL, this, _("Keys"));
wxSizer *hotkey_grid = new wxGridSizer(2, 0, 5);
add_hotkey(hotkey_grid, this, "tool/styling_assistant/commit", _("Accept changes"));
add_hotkey(hotkey_grid, this, "tool/styling_assistant/preview", _("Preview changes"));
add_hotkey(hotkey_grid, this, "grid/line/prev", _("Previous line"));
add_hotkey(hotkey_grid, this, "grid/line/next", _("Next line"));
add_hotkey(hotkey_grid, this, "video/play/line", _("Play video"));
add_hotkey(hotkey_grid, this, "audio/play/selection", _("Play audio"));
hotkey_grid->Add(new wxStaticText(this, -1, _("Click on list")));
hotkey_grid->Add(new wxStaticText(this, -1, _("Select style")));
hotkey_box->Add(hotkey_grid, 0, wxEXPAND | wxBOTTOM, 5);
auto_seek = new wxCheckBox(this, -1, _("&Seek video to line start time"));
auto_seek->SetValue(true);
hotkey_box->Add(auto_seek, 0, 0, 0);
hotkey_box->AddStretchSpacer(1);
right_sizer->Add(hotkey_box, 0, wxEXPAND | wxBOTTOM, 5);
}
{
wxSizer *actions_box = new wxStaticBoxSizer(wxHORIZONTAL, this, _("Actions"));
actions_box->AddStretchSpacer(1);
play_audio = new wxButton(this, -1, _("Play &Audio"));
play_audio->Enable(c->audioController->IsAudioOpen());
actions_box->Add(play_audio, 0, wxLEFT | wxRIGHT | wxBOTTOM, 5);
play_video = new wxButton(this, -1, _("Play &Video"));
play_video->Enable(c->videoController->IsLoaded());
actions_box->Add(play_video, 0, wxBOTTOM | wxRIGHT, 5);
actions_box->AddStretchSpacer(1);
right_sizer->Add(actions_box, 0, wxEXPAND, 5);
}
bottom_sizer->Add(right_sizer);
main_sizer->Add(bottom_sizer, 1, wxEXPAND | wxLEFT | wxBOTTOM | wxRIGHT, 5);
{
auto button_sizer = new wxStdDialogButtonSizer;
button_sizer->AddButton(new wxButton(this, wxID_CANCEL));
button_sizer->AddButton(new HelpButton(this, "Styling Assistant"));
button_sizer->Realize();
main_sizer->Add(button_sizer, 0, wxEXPAND | wxBOTTOM | wxLEFT | wxRIGHT, 5);
}
SetSizerAndFit(main_sizer);
persist = agi::util::make_unique<PersistLocation>(this, "Tool/Styling Assistant");
Bind(wxEVT_ACTIVATE, &DialogStyling::OnActivate, this);
Bind(wxEVT_CHAR_HOOK, &DialogStyling::OnCharHook, this);
style_name->Bind(wxEVT_CHAR_HOOK, &DialogStyling::OnCharHook, this);
style_name->Bind(wxEVT_KEY_DOWN, &DialogStyling::OnKeyDown, this);
play_video->Bind(wxEVT_COMMAND_BUTTON_CLICKED, &DialogStyling::OnPlayVideoButton, this);
play_audio->Bind(wxEVT_COMMAND_BUTTON_CLICKED, &DialogStyling::OnPlayAudioButton, this);
style_list->Bind(wxEVT_COMMAND_LISTBOX_SELECTED, &DialogStyling::OnListClicked, this);
style_list->Bind(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, &DialogStyling::OnListDoubleClicked, this);
style_name->Bind(wxEVT_COMMAND_TEXT_UPDATED, &DialogStyling::OnStyleBoxModified, this);
OnActiveLineChanged(c->selectionController->GetActiveLine());
}
bool DolphinApp::OnInit()
{
if (!wxApp::OnInit())
return false;
Bind(wxEVT_QUERY_END_SESSION, &DolphinApp::OnEndSession, this);
Bind(wxEVT_END_SESSION, &DolphinApp::OnEndSession, this);
Bind(wxEVT_IDLE, &DolphinApp::OnIdle, this);
// Register message box and translation handlers
RegisterMsgAlertHandler(&wxMsgAlert);
RegisterStringTranslator(&wxStringTranslator);
#if wxUSE_ON_FATAL_EXCEPTION
wxHandleFatalExceptions(true);
#endif
UICommon::SetUserDirectory(m_user_path.ToStdString());
UICommon::CreateDirectories();
InitLanguageSupport(); // The language setting is loaded from the user directory
UICommon::Init();
if (m_select_video_backend && !m_video_backend_name.empty())
SConfig::GetInstance().m_strVideoBackend = WxStrToStr(m_video_backend_name);
if (m_select_audio_emulation)
SConfig::GetInstance().bDSPHLE = (m_audio_emulation_name.Upper() == "HLE");
VideoBackendBase::ActivateBackend(SConfig::GetInstance().m_strVideoBackend);
DolphinAnalytics::Instance()->ReportDolphinStart("wx");
// Enable the PNG image handler for screenshots
wxImage::AddHandler(new wxPNGHandler);
int x = SConfig::GetInstance().iPosX;
int y = SConfig::GetInstance().iPosY;
int w = SConfig::GetInstance().iWidth;
int h = SConfig::GetInstance().iHeight;
// The following is not needed with X11, where window managers
// do not allow windows to be created off the desktop.
#ifdef _WIN32
// Out of desktop check
int leftPos = GetSystemMetrics(SM_XVIRTUALSCREEN);
int topPos = GetSystemMetrics(SM_YVIRTUALSCREEN);
int width = GetSystemMetrics(SM_CXVIRTUALSCREEN);
int height = GetSystemMetrics(SM_CYVIRTUALSCREEN);
if ((leftPos + width) < (x + w) || leftPos > x || (topPos + height) < (y + h) || topPos > y)
x = y = wxDefaultCoord;
#elif defined __APPLE__
if (y < 1)
y = wxDefaultCoord;
#endif
main_frame = new CFrame(nullptr, wxID_ANY, StrToWxStr(scm_rev_str), wxPoint(x, y), wxSize(w, h),
m_use_debugger, m_batch_mode, m_use_logger);
SetTopWindow(main_frame);
main_frame->SetMinSize(wxSize(400, 300));
AfterInit();
return true;
}
PostProcessingConfigDiag::PostProcessingConfigDiag(wxWindow* parent, const std::string& shader)
: wxDialog(parent, wxID_ANY, _("Post Processing Shader Configuration")),
m_shader(shader)
{
// Depending on if we are running already, either use the one from the videobackend
// or generate our own.
if (g_renderer && g_renderer->GetPostProcessor())
{
m_post_processor = g_renderer->GetPostProcessor()->GetConfig();
}
else
{
m_post_processor = new PostProcessingShaderConfiguration();
m_post_processor->LoadShader(m_shader);
}
// Create our UI classes
const PostProcessingShaderConfiguration::ConfigMap& config_map = m_post_processor->GetOptions();
for (const auto& it : config_map)
{
if (it.second.m_type == PostProcessingShaderConfiguration::ConfigurationOption::OptionType::OPTION_BOOL)
{
ConfigGrouping* group = new ConfigGrouping(ConfigGrouping::WidgetType::TYPE_TOGGLE,
it.second.m_gui_name, it.first, it.second.m_dependent_option,
&it.second);
m_config_map[it.first] = group;
}
else
{
ConfigGrouping* group = new ConfigGrouping(ConfigGrouping::WidgetType::TYPE_SLIDER,
it.second.m_gui_name, it.first, it.second.m_dependent_option,
&it.second);
m_config_map[it.first] = group;
}
}
// Arrange our vectors based on dependency
for (const auto& it : m_config_map)
{
const std::string parent_name = it.second->GetParent();
if (parent_name.size())
{
// Since it depends on a different object, push it to a parent's object
m_config_map[parent_name]->AddChild(m_config_map[it.first]);
}
else
{
// It doesn't have a child, just push it to the vector
m_config_groups.push_back(m_config_map[it.first]);
}
}
// Generate our UI
wxNotebook* const notebook = new wxNotebook(this, wxID_ANY);
wxPanel* const page_general = new wxPanel(notebook);
wxFlexGridSizer* const szr_general = new wxFlexGridSizer(2, 5, 5);
// Now let's actually populate our window with our information
bool add_general_page = false;
for (const auto& it : m_config_groups)
{
if (it->HasChildren())
{
// Options with children get their own tab
wxPanel* const page_option = new wxPanel(notebook);
wxFlexGridSizer* const szr_option = new wxFlexGridSizer(2, 10, 5);
it->GenerateUI(this, page_option, szr_option);
// Add all the children
for (const auto& child : it->GetChildren())
{
child->GenerateUI(this, page_option, szr_option);
}
page_option->SetSizerAndFit(szr_option);
notebook->AddPage(page_option, _(it->GetGUIName()));
}
else
{
// Options with no children go in to the general tab
if (!add_general_page)
{
// Make it so it doesn't show up if there aren't any options without children.
add_general_page = true;
}
it->GenerateUI(this, page_general, szr_general);
}
}
if (add_general_page)
{
page_general->SetSizerAndFit(szr_general);
notebook->InsertPage(0, page_general, _("General"));
}
// Close Button
wxButton* const btn_close = new wxButton(this, wxID_OK, _("Close"));
btn_close->Bind(wxEVT_BUTTON, &PostProcessingConfigDiag::Event_ClickClose, this);
Bind(wxEVT_CLOSE_WINDOW, &PostProcessingConfigDiag::Event_Close, this);
wxBoxSizer* const szr_main = new wxBoxSizer(wxVERTICAL);
szr_main->Add(notebook, 1, wxEXPAND | wxALL, 5);
szr_main->Add(btn_close, 0, wxALIGN_RIGHT | wxRIGHT | wxBOTTOM, 5);
SetSizerAndFit(szr_main);
Center();
SetFocus();
UpdateWindowUI();
}
void
traceloop(void)
{
int seq, code, done;
double rtt;
struct rec *rec;
struct timeval tvrecv;
recvfd = Socket(pr->sasend->sa_family, SOCK_RAW, pr->icmpproto);
setuid(getuid()); /* don't need special permissions anymore */
#ifdef IPV6
if (pr->sasend->sa_family == AF_INET6 && verbose == 0) {
struct icmp6_filter myfilt;
ICMP6_FILTER_SETBLOCKALL(&myfilt);
ICMP6_FILTER_SETPASS(ICMP6_TIME_EXCEEDED, &myfilt);
ICMP6_FILTER_SETPASS(ICMP6_DST_UNREACH, &myfilt);
setsockopt(recvfd, IPPROTO_IPV6, ICMP6_FILTER,
&myfilt, sizeof(myfilt));
}
#endif
sendfd = Socket(pr->sasend->sa_family, SOCK_DGRAM, 0);
pr->sabind->sa_family = pr->sasend->sa_family;
sport = (getpid() & 0xffff) | 0x8000; /* our source UDP port # */
sock_set_port(pr->sabind, pr->salen, htons(sport));
Bind(sendfd, pr->sabind, pr->salen);
sig_alrm(SIGALRM);
seq = 0;
done = 0;
for (ttl = 1; ttl <= max_ttl && done == 0; ttl++) {
Setsockopt(sendfd, pr->ttllevel, pr->ttloptname, &ttl, sizeof(int));
bzero(pr->salast, pr->salen);
printf("%2d ", ttl);
fflush(stdout);
for (probe = 0; probe < nprobes; probe++) {
rec = (struct rec *) sendbuf;
rec->rec_seq = ++seq;
rec->rec_ttl = ttl;
Gettimeofday(&rec->rec_tv, NULL);
sock_set_port(pr->sasend, pr->salen, htons(dport + seq));
Sendto(sendfd, sendbuf, datalen, 0, pr->sasend, pr->salen);
if ( (code = (*pr->recv)(seq, &tvrecv)) == -3)
printf(" *"); /* timeout, no reply */
else {
char str[NI_MAXHOST];
if (sock_cmp_addr(pr->sarecv, pr->salast, pr->salen) != 0) {
if (getnameinfo(pr->sarecv, pr->salen, str, sizeof(str),
NULL, 0, 0) == 0)
printf(" %s (%s)", str,
Sock_ntop_host(pr->sarecv, pr->salen));
else
printf(" %s",
Sock_ntop_host(pr->sarecv, pr->salen));
memcpy(pr->salast, pr->sarecv, pr->salen);
}
tv_sub(&tvrecv, &rec->rec_tv);
rtt = tvrecv.tv_sec * 1000.0 + tvrecv.tv_usec / 1000.0;
printf(" %.3f ms", rtt);
if (code == -1) /* port unreachable; at destination */
done++;
else if (code >= 0)
printf(" (ICMP %s)", (*pr->icmpcode)(code));
}
fflush(stdout);
}
printf("\n");
}
}
ServerPlayModeMap::ServerPlayModeMap() {
Bind("before_kick_off", SPM_BeforeKickOff);
Bind("time_over", SPM_TimeOver);
Bind("play_on", SPM_PlayOn);
Bind("kick_off_l", SPM_KickOff_Left);
Bind("kick_off_r", SPM_KickOff_Right);
Bind("kick_in_l", SPM_KickIn_Left);
Bind("kick_in_r", SPM_KickIn_Right);
Bind("free_kick_l", SPM_FreeKick_Left);
Bind("free_kick_r", SPM_FreeKick_Right);
Bind("corner_kick_l", SPM_CornerKick_Left);
Bind("corner_kick_r", SPM_CornerKick_Right);
Bind("goal_kick_l", SPM_GoalKick_Left);
Bind("goal_kick_r", SPM_GoalKick_Right);
Bind("goal_l", SPM_AfterGoal_Left);
Bind("goal_r", SPM_AfterGoal_Right);
Bind("drop_ball", SPM_Drop_Ball);
Bind("offside_l", SPM_OffSide_Left);
Bind("offside_r", SPM_OffSide_Right);
Bind("penalty_kick_l", SPM_PK_Left);
Bind("penalty_kick_r", SPM_PK_Right);
Bind("first_half_over", SPM_FirstHalfOver);
Bind("pause", SPM_Pause);
Bind("human_judge", SPM_Human);
Bind("foul_charge_l", SPM_Foul_Charge_Left);
Bind("foul_charge_r", SPM_Foul_Charge_Right);
Bind("foul_push_l", SPM_Foul_Push_Left);
Bind("foul_push_r", SPM_Foul_Push_Right);
Bind("foul_multiple_attack_l", SPM_Foul_MultipleAttacker_Left);
Bind("foul_multiple_attack_r", SPM_Foul_MultipleAttacker_Right);
Bind("foul_ballout_l", SPM_Foul_BallOut_Left);
Bind("foul_ballout_r", SPM_Foul_BallOut_Right);
Bind("back_pass_l", SPM_Back_Pass_Left);
Bind("back_pass_r", SPM_Back_Pass_Right);
Bind("free_kick_fault_l", SPM_Free_Kick_Fault_Left);
Bind("free_kick_fault_r", SPM_Free_Kick_Fault_Right);
Bind("catch_fault_l", SPM_CatchFault_Left);
Bind("catch_fault_r", SPM_CatchFault_Right);
Bind("indirect_free_kick_l", SPM_IndFreeKick_Left);
Bind("indirect_free_kick_r", SPM_IndFreeKick_Right);
Bind("penalty_setup_l", SPM_PenaltySetup_Left);
Bind("penalty_setup_r", SPM_PenaltySetup_Right);
Bind("penalty_ready_l", SPM_PenaltyReady_Left);
Bind("penalty_ready_r", SPM_PenaltyReady_Right);
Bind("penalty_taken_l", SPM_PenaltyTaken_Left);
Bind("penalty_taken_r", SPM_PenaltyTaken_Right);
Bind("penalty_miss_l", SPM_PenaltyMiss_Left);
Bind("penalty_miss_r", SPM_PenaltyMiss_Right);
Bind("penalty_score_l", SPM_PenaltyScore_Left);
Bind("penalty_score_r", SPM_PenaltyScore_Right);
Bind("goalie_catch_ball_l", SPM_GoalieCatchBall_Left);
Bind("goalie_catch_ball_r", SPM_GoalieCatchBall_Right);
Bind("foul_l", SPM_Foul_Left);
Bind("foul_r", SPM_Foul_Right);
Bind("penalty_onfield_l", SPM_PenaltyOnfield_Left);
Bind("penalty_onfield_r", SPM_PenaltyOnfield_Right);
Bind("penalty_foul_l", SPM_PenaltyFoul_Left);
Bind("penalty_foul_r", SPM_PenaltyFoul_Right);
Bind("penalty_winner_l", SPM_PenaltyWinner_Left);
Bind("penalty_winner_r", SPM_PenaltyWinner_Right);
Bind("half_time", SPM_HalfTime);
Bind("time_up", SPM_TimeUp);
Bind("time_extended", SPM_TimeExtended);
Assert(mString2Enum.size() == SPM_MAX - 1);
}
int main(int argc, char **argv)
{
struct msghdr *msg;
struct hwa_info *hwa, *hwahead;
struct sockaddr_un su;
struct sockaddr *sa;
socklen_t addrlen;
int i, j;
int protocol, maxfdp1;
fd_set rset;
char address[16], name[16];
char rcvline[MAXLINE];
struct hostent *host;
if(argc < 2)
{
printf("Usage: odr staleness\n");
return -1;
}
staleness = atoi(argv[1]);
gethostname(name, 16);
host = malloc(sizeof(struct hostent));
host = gethostbyname(name);
if(host == NULL)
printf("host is NULL\n");
strncpy(canonical, inet_ntoa( *( struct in_addr*)( host -> h_addr_list[0])), 16);
printf("Local ODR on host %s\n", name);
printf( "Canonical IP: %s\n", canonical);
printf("Finding interfaces\n");
for (i = 0, hwahead = hwa = Get_hw_addrs(); hwa != NULL && i < MAX_INTERFACES; hwa = hwa->hwa_next, i++)
{
if(strncmp(hwa->if_name, "eth0", 4) != 0 && strncmp(hwa->if_name, "lo", 2) != 0)
{
for(j = 0; j < 6; j++)
{
interfaces[i].if_haddr[j] = hwa->if_haddr[j];
}
interfaces[i].if_index = hwa->if_index;
sa = hwa->ip_addr;
strncpy(interfaces[i].ip_addr, sock_ntop_host(sa, sizeof(*sa)), 16);
printf("IP Address: %s\n", interfaces[i].ip_addr);
printf("Hardware Address: ");
printHW(interfaces[i].if_haddr);
printf("\nIndex: %d\n\n", interfaces[i].if_index);
}
else
i--;
}
if_nums = i;
err_msg("%s",ODR_SUNPATH);
printf("Found %d interfaces\n", if_nums);
//Creating packet socket
pfsock = socket(PF_PACKET, SOCK_RAW, htons(ODR_PROTOCOL));
if(pfsock < 0)
{
printf("pfsock: %d %s\n", errno, strerror(errno));
return -1;
}
//Creating application socket
su.sun_family = AF_LOCAL;
strcpy(su.sun_path, ODR_SUNPATH);
//strcat(su.sun_path, "\0");
appsock = socket(AF_LOCAL, SOCK_DGRAM, 0);
if(appsock < 0)
{
printf("appsock: %d %s\n", errno, strerror(errno));
return -1;
}
unlink(ODR_SUNPATH);
if(Bind(appsock, (struct sockaddr*) &su, SUN_LEN(&su)) < 0)
{
printf("bind failed: %d %s\n", errno, strerror(errno));
return -1;
}
printf("Bound appsock\n");
for ( ; ; )
{
printf("in for\n");
FD_ZERO(&rset);
printf("zero\n");
FD_SET(pfsock, &rset);
printf("set1\n");
FD_SET(appsock, &rset);
printf("set2\n");
maxfdp1 = max(pfsock, appsock) + 1;
printf("max\n");
select(maxfdp1, &rset, NULL, NULL, NULL);
printf("Selecting...\n");
if(FD_ISSET(appsock, &rset))
{
printf("appsock is ready\n");
//msg_recv(appsock, message, address, port);
addrlen = sizeof(sa);
if(recvfrom(appsock, rcvline, MAXLINE, 0, sa, &addrlen) < 0)
{
printf("appsock recvfrom error: %d %s\n", errno, strerror(errno));
return -1;
}
//su = (struct sockaddr_un*) sa;
processAPPmsg(rcvline);
}
if(FD_ISSET(pfsock, &rset))
{
printf("pfsock is ready\n");
//msg_recv(pfsock, message, address, port);
if(recvmsg(pfsock, msg, 0) < 0)
{
printf("pfsock recvmsg error: %d %s\n", errno, strerror(errno));
return -1;
}
processODRmsg(msg);
}
}
}
void BedShapePanel::build_panel(ConfigOptionPoints* default_pt)
{
// on_change(nullptr);
auto box = new wxStaticBox(this, wxID_ANY, _(L("Shape")));
auto sbsizer = new wxStaticBoxSizer(box, wxVERTICAL);
// shape options
m_shape_options_book = new wxChoicebook(this, wxID_ANY, wxDefaultPosition,
wxSize(25*wxGetApp().em_unit(), -1), wxCHB_TOP);
sbsizer->Add(m_shape_options_book);
auto optgroup = init_shape_options_page(_(L("Rectangular")));
ConfigOptionDef def;
def.type = coPoints;
def.default_value = new ConfigOptionPoints{ Vec2d(200, 200) };
def.label = L("Size");
def.tooltip = L("Size in X and Y of the rectangular plate.");
Option option(def, "rect_size");
optgroup->append_single_option_line(option);
def.type = coPoints;
def.default_value = new ConfigOptionPoints{ Vec2d(0, 0) };
def.label = L("Origin");
def.tooltip = L("Distance of the 0,0 G-code coordinate from the front left corner of the rectangle.");
option = Option(def, "rect_origin");
optgroup->append_single_option_line(option);
optgroup = init_shape_options_page(_(L("Circular")));
def.type = coFloat;
def.default_value = new ConfigOptionFloat(200);
def.sidetext = L("mm");
def.label = L("Diameter");
def.tooltip = L("Diameter of the print bed. It is assumed that origin (0,0) is located in the center.");
option = Option(def, "diameter");
optgroup->append_single_option_line(option);
optgroup = init_shape_options_page(_(L("Custom")));
Line line{ "", "" };
line.full_width = 1;
line.widget = [this](wxWindow* parent) {
auto btn = new wxButton(parent, wxID_ANY, _(L("Load shape from STL...")), wxDefaultPosition, wxDefaultSize);
auto sizer = new wxBoxSizer(wxHORIZONTAL);
sizer->Add(btn);
btn->Bind(wxEVT_BUTTON, ([this](wxCommandEvent e)
{
load_stl();
}));
return sizer;
};
optgroup->append_line(line);
Bind(wxEVT_CHOICEBOOK_PAGE_CHANGED, ([this](wxCommandEvent e)
{
update_shape();
}));
// right pane with preview canvas
m_canvas = new Bed_2D(this);
m_canvas->m_bed_shape = default_pt->values;
// main sizer
auto top_sizer = new wxBoxSizer(wxHORIZONTAL);
top_sizer->Add(sbsizer, 0, wxEXPAND | wxLeft | wxTOP | wxBOTTOM, 10);
if (m_canvas)
top_sizer->Add(m_canvas, 1, wxEXPAND | wxALL, 10) ;
SetSizerAndFit(top_sizer);
set_shape(default_pt);
update_preview();
}
/**
* Unlocks the buffer. Pointers to buffer data will no longer be valid after this call
*/
void FSlateOpenGLIndexBuffer::Unlock()
{
Bind();
glUnmapBuffer( GL_ELEMENT_ARRAY_BUFFER );
}
ZLauncherFrame::ZLauncherFrame( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxFrame( parent, id, title, pos, size, style )
{
wxImage::SetDefaultLoadFlags(wxImage::GetDefaultLoadFlags() & ~wxImage::Load_Verbose);
this->SetSizeHints( wxSize( 500,300 ), wxDefaultSize );
this->SetBackgroundColour( APPLICATION_BACKGROUND );
// GridBagSizer for the whole frame
wxGridBagSizer* gridBagSizerFrame;
gridBagSizerFrame = new wxGridBagSizer( 0, 0 );
gridBagSizerFrame->SetFlexibleDirection( wxBOTH );
gridBagSizerFrame->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );
gridBagSizerFrame->SetMinSize( wxSize( 800,600 ) );
// GridBagSizer For the "Body" (HTML Window, etc.)
wxGridBagSizer* gridBagSizerBody;
gridBagSizerBody = new wxGridBagSizer( 0, 0 );
gridBagSizerBody->SetFlexibleDirection( wxBOTH );
gridBagSizerBody->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );
// HTML Viewer
m_htmlWin = wxWebView::New(this, wxID_ANY, wxWebViewDefaultURLStr, wxDefaultPosition, wxDefaultSize, wxWebViewBackendDefault, wxSIMPLE_BORDER);
m_htmlWin->SetMinSize( wxSize( 400,300 ) );
gridBagSizerBody->Add( m_htmlWin, wxGBPosition( 0, 0 ), wxGBSpan( 1, 1 ), wxALL|wxEXPAND, 5 );
// GridBagSizer for the right side of the window
wxGridBagSizer* gridBagSizerRight;
gridBagSizerRight = new wxGridBagSizer( 0, 0 );
gridBagSizerRight->SetFlexibleDirection( wxBOTH );
gridBagSizerRight->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );
// Add a spacer, for empty space, at the left side of the close button
gridBagSizerRight->Add( 0, 0, wxGBPosition( 0, 0 ), wxGBSpan( 1, 1 ), wxEXPAND, 5 );
// Close Button (Top Right)
m_CloseButtonImg_Normal.LoadFile(GetResourcesDirectory() + CLOSE_BUTTON_NORMAL, wxBITMAP_TYPE_PNG);
m_CloseButtonImg_Disabled.LoadFile(GetResourcesDirectory() + CLOSE_BUTTON_DISABLED, wxBITMAP_TYPE_PNG);
m_CloseButtonImg_Pressed.LoadFile(GetResourcesDirectory() + CLOSE_BUTTON_PRESSED, wxBITMAP_TYPE_PNG);
m_CloseButtonImg_Focus.LoadFile(GetResourcesDirectory() + CLOSE_BUTTON_FOCUS, wxBITMAP_TYPE_PNG);
m_CloseButtonImg_Hover.LoadFile(GetResourcesDirectory() + CLOSE_BUTTON_HOVER, wxBITMAP_TYPE_PNG);
m_btnClose = new wxButton(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE | wxBU_EXACTFIT | wxBU_NOTEXT);
m_btnClose->SetBitmap(m_CloseButtonImg_Normal);
m_btnClose->SetBitmapDisabled(m_CloseButtonImg_Disabled);
m_btnClose->SetBitmapPressed(m_CloseButtonImg_Pressed);
m_btnClose->SetBitmapFocus(m_CloseButtonImg_Focus);
m_btnClose->SetBitmapCurrent(m_CloseButtonImg_Hover);
m_btnClose->SetBackgroundColour(APPLICATION_BACKGROUND);
m_btnClose->Enable(true);
gridBagSizerRight->Add( m_btnClose, wxGBPosition( 0, 1 ), wxGBSpan( 1, 1 ), wxALL, 5 );
gridBagSizerRight->AddGrowableCol( 0 );
gridBagSizerRight->AddGrowableRow( 0 );
gridBagSizerBody->Add( gridBagSizerRight, wxGBPosition( 0, 1 ), wxGBSpan( 1, 1 ), wxALIGN_RIGHT|wxEXPAND, 5 );
gridBagSizerBody->AddGrowableCol( 1 );
gridBagSizerBody->AddGrowableRow( 0 );
gridBagSizerFrame->Add( gridBagSizerBody, wxGBPosition( 0, 0 ), wxGBSpan( 1, 2 ), wxEXPAND, 5 );
// Footer Area (Progress Bar and Launch button)
wxGridBagSizer* gridBagSizerFooter;
gridBagSizerFooter = new wxGridBagSizer( 0, 0 );
gridBagSizerFooter->SetFlexibleDirection( wxBOTH );
gridBagSizerFooter->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );
// Text for the Progress Bar
m_txtProgress = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY|wxNO_BORDER );
m_txtProgress->SetForegroundColour( COMPONENT_TEXT_COLOR );
m_txtProgress->SetBackgroundColour( APPLICATION_BACKGROUND );
gridBagSizerFooter->Add( m_txtProgress, wxGBPosition( 0, 0 ), wxGBSpan( 1, 1 ), wxALIGN_BOTTOM|wxEXPAND, 5 );
// Progress Bar
m_progress = new wxGauge( this, wxID_ANY, 100, wxDefaultPosition, wxDefaultSize, wxGA_HORIZONTAL );
m_progress->SetValue( 0 );
m_progress->SetMinSize( wxSize( 500,25 ) );
gridBagSizerFooter->Add( m_progress, wxGBPosition( 1, 0 ), wxGBSpan( 1, 1 ), wxALIGN_TOP|wxALL|wxEXPAND, 5 );
gridBagSizerFooter->AddGrowableCol( 0 );
gridBagSizerFooter->AddGrowableRow( 0 );
gridBagSizerFrame->Add( gridBagSizerFooter, wxGBPosition( 1, 0 ), wxGBSpan( 1, 1 ), wxEXPAND, 5 );
// Launch Button
m_LaunchButtonImg_Normal.LoadFile(GetResourcesDirectory() + LAUNCH_BUTTON_NORMAL, wxBITMAP_TYPE_PNG);
m_LaunchButtonImg_Disabled.LoadFile(GetResourcesDirectory() + LAUNCH_BUTTON_DISABLED, wxBITMAP_TYPE_PNG);
m_LaunchButtonImg_Pressed.LoadFile(GetResourcesDirectory() + LAUNCH_BUTTON_PRESSED, wxBITMAP_TYPE_PNG);
m_LaunchButtonImg_Focus.LoadFile(GetResourcesDirectory() + LAUNCH_BUTTON_FOCUS, wxBITMAP_TYPE_PNG);
m_LaunchButtonImg_Hover.LoadFile(GetResourcesDirectory() + LAUNCH_BUTTON_HOVER, wxBITMAP_TYPE_PNG);
m_btnLaunch = new wxButton( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE | wxBU_EXACTFIT | wxBU_NOTEXT);
m_btnLaunch->SetBitmap(m_LaunchButtonImg_Normal);
m_btnLaunch->SetBitmapDisabled(m_LaunchButtonImg_Disabled);
m_btnLaunch->SetBitmapPressed(m_LaunchButtonImg_Pressed);
m_btnLaunch->SetBitmapFocus(m_LaunchButtonImg_Focus);
m_btnLaunch->SetBitmapCurrent(m_LaunchButtonImg_Hover);
m_btnLaunch->SetBackgroundColour(APPLICATION_BACKGROUND);
m_btnLaunch->Enable( false );
gridBagSizerFrame->Add( m_btnLaunch, wxGBPosition( 1, 1 ), wxGBSpan( 1, 1 ), wxALIGN_BOTTOM|wxALL, 5 );
gridBagSizerFrame->AddGrowableCol( 0 );
gridBagSizerFrame->AddGrowableRow( 0 );
this->SetSizer( gridBagSizerFrame );
this->Layout();
this->Centre( wxBOTH );
// Set background image, if any.
SetBackgroundStyle(wxBG_STYLE_PAINT);
if (g_BackgroundImage != wxEmptyString)
m_backgroundImg.LoadFile(g_BackgroundImage, wxBITMAP_TYPE_PNG);
// Bind Message Events
Bind(wxEVT_PAINT, &ZLauncherFrame::PaintEvent, this);
Bind(wxEVT_COMMAND_UPDATE_PROGRESS_BAR, &ZLauncherFrame::OnProgressBarUpdate, this);
Bind(wxEVT_COMMAND_UPDATE_PROGRESS_TEXT, &ZLauncherFrame::OnProgressTextUpdate, this);
Bind(wxEVT_COMMAND_HTML_SET_CONTENT, &ZLauncherFrame::OnHTMLSetContent, this);
Bind(wxEVT_COMMAND_HTML_LOAD_PAGE, &ZLauncherFrame::OnHTMLLoadPage, this);
Bind(wxEVT_COMMAND_ENABLE_LAUNCH_BUTTON, &ZLauncherFrame::OnEnableLaunchButton, this);
Bind(wxEVT_CLOSE_WINDOW, &ZLauncherFrame::OnClose, this);
Bind(wxEVT_WEBVIEW_NAVIGATING, &ZLauncherFrame::OnClickLink, this);
// Bind Button Events
m_btnClose->Bind(wxEVT_BUTTON, &ZLauncherFrame::OnCloseButtonClicked, this);
m_btnLaunch->Bind(wxEVT_BUTTON, &ZLauncherFrame::OnLaunchButtonClicked, this);
// Read Header html data from external file
if (wxFile::Exists(GetResourcesDirectory() + g_PatchHTMLHeaderFileName))
{
wxFile headerFile(GetResourcesDirectory() + g_PatchHTMLHeaderFileName, wxFile::OpenMode::read);
headerFile.ReadAll(&PatchHTMLHeader);
}
else
{
wxMessageBox(wxString::Format("HTML Header file missing. Make sure it can be found in the following directory:\n %s", GetResourcesDirectory() + g_PatchHTMLHeaderFileName), "Missing file", wxOK| wxICON_EXCLAMATION);
}
}
AudioBox::AudioBox(wxWindow *parent, agi::Context *context)
: wxSashWindow(parent, -1, wxDefaultPosition, wxDefaultSize, wxSW_3D | wxCLIP_CHILDREN)
, controller(context->audioController.get())
, context(context)
, audio_open_connection(context->audioController->AddAudioPlayerOpenListener(&AudioBox::OnAudioOpen, this))
, panel(new wxPanel(this, -1, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL | wxBORDER_RAISED))
, audioDisplay(new AudioDisplay(panel, context->audioController.get(), context))
, HorizontalZoom(new wxSlider(panel, Audio_Horizontal_Zoom, -OPT_GET("Audio/Zoom/Horizontal")->GetInt(), -50, 30, wxDefaultPosition, wxSize(-1, 20), wxSL_VERTICAL|wxSL_BOTH))
, VerticalZoom(new wxSlider(panel, Audio_Vertical_Zoom, OPT_GET("Audio/Zoom/Vertical")->GetInt(), 0, 100, wxDefaultPosition, wxSize(-1, 20), wxSL_VERTICAL|wxSL_BOTH|wxSL_INVERSE))
, VolumeBar(new wxSlider(panel, Audio_Volume, OPT_GET("Audio/Volume")->GetInt(), 0, 100, wxDefaultPosition, wxSize(-1, 20), wxSL_VERTICAL|wxSL_BOTH|wxSL_INVERSE))
{
SetSashVisible(wxSASH_BOTTOM, true);
Bind(wxEVT_SASH_DRAGGED, &AudioBox::OnSashDrag, this);
HorizontalZoom->SetToolTip(_("Horizontal zoom"));
VerticalZoom->SetToolTip(_("Vertical zoom"));
VolumeBar->SetToolTip(_("Audio Volume"));
bool link = OPT_GET("Audio/Link")->GetBool();
if (link) {
VolumeBar->SetValue(VerticalZoom->GetValue());
VolumeBar->Enable(false);
}
// VertVol sider
wxSizer *VertVol = new wxBoxSizer(wxHORIZONTAL);
VertVol->Add(VerticalZoom,1,wxEXPAND,0);
VertVol->Add(VolumeBar,1,wxEXPAND,0);
wxSizer *VertVolArea = new wxBoxSizer(wxVERTICAL);
VertVolArea->Add(VertVol,1,wxEXPAND,0);
auto link_btn = new ToggleBitmap(panel, context, "audio/opt/vertical_link", 16, "Audio", wxSize(20, -1));
link_btn->SetMaxSize(wxDefaultSize);
VertVolArea->Add(link_btn, 0, wxRIGHT | wxEXPAND, 0);
OPT_SUB("Audio/Link", &AudioBox::OnVerticalLink, this);
// Top sizer
wxSizer *TopSizer = new wxBoxSizer(wxHORIZONTAL);
TopSizer->Add(audioDisplay,1,wxEXPAND,0);
TopSizer->Add(HorizontalZoom,0,wxEXPAND,0);
TopSizer->Add(VertVolArea,0,wxEXPAND,0);
context->karaoke = new AudioKaraoke(panel, context);
// Main sizer
auto MainSizer = new wxBoxSizer(wxVERTICAL);
MainSizer->Add(TopSizer,1,wxEXPAND|wxALL,3);
MainSizer->Add(toolbar::GetToolbar(panel, "audio", context, "Audio"),0,wxEXPAND|wxLEFT|wxRIGHT,3);
MainSizer->Add(context->karaoke,0,wxEXPAND|wxALL,3);
MainSizer->Show(context->karaoke, false);
panel->SetSizer(MainSizer);
wxSizer *audioSashSizer = new wxBoxSizer(wxHORIZONTAL);
audioSashSizer->Add(panel, 1, wxEXPAND);
SetSizerAndFit(audioSashSizer);
SetMinSize(wxSize(-1, OPT_GET("Audio/Display Height")->GetInt()));
SetMinimumSizeY(panel->GetSize().GetHeight());
audioDisplay->Bind(wxEVT_MOUSEWHEEL, &AudioBox::OnMouseWheel, this);
audioDisplay->SetZoomLevel(-HorizontalZoom->GetValue());
audioDisplay->SetAmplitudeScale(pow(mid(1, VerticalZoom->GetValue(), 100) / 50.0, 3));
}
bool Link()
{
TIMER_ACCRUE(tc_ShaderGLSLLink);
ENSURE(!m_Program);
m_Program = pglCreateProgramObjectARB();
pglAttachObjectARB(m_Program, m_VertexShader);
ogl_WarnIfError();
pglAttachObjectARB(m_Program, m_FragmentShader);
ogl_WarnIfError();
// Set up the attribute bindings explicitly, since apparently drivers
// don't always pick the most efficient bindings automatically,
// and also this lets us hardcode indexes into VertexPointer etc
for (std::map<CStrIntern, int>::iterator it = m_VertexAttribs.begin(); it != m_VertexAttribs.end(); ++it)
pglBindAttribLocationARB(m_Program, it->second, it->first.c_str());
pglLinkProgramARB(m_Program);
GLint ok = 0;
pglGetProgramiv(m_Program, GL_LINK_STATUS, &ok);
GLint length = 0;
pglGetProgramiv(m_Program, GL_INFO_LOG_LENGTH, &length);
if (!ok && length == 0)
length = 4096;
if (length > 1)
{
char* infolog = new char[length];
pglGetProgramInfoLog(m_Program, length, NULL, infolog);
if (ok)
LOGMESSAGE(L"Info when linking program '%ls'+'%ls':\n%hs", m_VertexFile.string().c_str(), m_FragmentFile.string().c_str(), infolog);
else
LOGERROR(L"Failed to link program '%ls'+'%ls':\n%hs", m_VertexFile.string().c_str(), m_FragmentFile.string().c_str(), infolog);
delete[] infolog;
}
ogl_WarnIfError();
if (!ok)
return false;
m_Uniforms.clear();
m_Samplers.clear();
Bind();
ogl_WarnIfError();
GLint numUniforms = 0;
pglGetProgramiv(m_Program, GL_ACTIVE_UNIFORMS, &numUniforms);
ogl_WarnIfError();
for (GLint i = 0; i < numUniforms; ++i)
{
char name[256] = {0};
GLsizei nameLength = 0;
GLint size = 0;
GLenum type = 0;
pglGetActiveUniformARB(m_Program, i, ARRAY_SIZE(name), &nameLength, &size, &type, name);
ogl_WarnIfError();
GLint loc = pglGetUniformLocationARB(m_Program, name);
CStrIntern nameIntern(name);
m_Uniforms[nameIntern] = std::make_pair(loc, type);
// Assign sampler uniforms to sequential texture units
if (type == GL_SAMPLER_2D
|| type == GL_SAMPLER_CUBE
#if !CONFIG2_GLES
|| type == GL_SAMPLER_2D_SHADOW
#endif
)
{
int unit = (int)m_Samplers.size();
m_Samplers[nameIntern].first = (type == GL_SAMPLER_CUBE ? GL_TEXTURE_CUBE_MAP : GL_TEXTURE_2D);
m_Samplers[nameIntern].second = unit;
pglUniform1iARB(loc, unit); // link uniform to unit
ogl_WarnIfError();
}
}
// TODO: verify that we're not using more samplers than is supported
Unbind();
ogl_WarnIfError();
return true;
}
// -------------------------------------------------------------------------------- //
guChannelEditor::guChannelEditor( wxWindow * parent, guPodcastChannel * channel ) :
wxDialog( parent, wxID_ANY, _( "Podcast Channel Editor" ), wxDefaultPosition, wxSize( 564,329 ), wxDEFAULT_DIALOG_STYLE )
{
wxStaticText* DescLabel;
wxStaticText* AuthorLabel;
wxStaticText* OwnerLabel;
wxStaticText* DownloadLabel;
wxStaticText* DeleteLabel;
wxStdDialogButtonSizer* ButtonsSizer;
wxButton* ButtonsSizerOK;
wxButton* ButtonsSizerCancel;
m_PodcastChannel = channel;
guConfig * Config = ( guConfig * ) guConfig::Get();
this->SetSizeHints( wxDefaultSize, wxDefaultSize );
wxBoxSizer* MainSizer;
MainSizer = new wxBoxSizer( wxVERTICAL );
wxStaticBoxSizer* ChannelSizer;
ChannelSizer = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _( " Podcast Channel " ) ), wxVERTICAL );
wxFlexGridSizer* FlexGridSizer;
FlexGridSizer = new wxFlexGridSizer( 2, 0, 0 );
FlexGridSizer->AddGrowableCol( 1 );
FlexGridSizer->SetFlexibleDirection( wxBOTH );
FlexGridSizer->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );
m_Image = new wxStaticBitmap( this, wxID_ANY, wxNullBitmap, wxDefaultPosition, wxSize( guPODCASTS_IMAGE_SIZE,guPODCASTS_IMAGE_SIZE ), 0 );
FlexGridSizer->Add( m_Image, 0, wxALL, 5 );
// Check that the directory to store podcasts are created
wxString PodcastsPath = Config->ReadStr( CONFIG_KEY_PODCASTS_PATH, guPATH_PODCASTS, CONFIG_PATH_PODCASTS );
wxFileName ImageFile = wxFileName( PodcastsPath + wxT( "/" ) +
channel->m_Title + wxT( "/" ) +
channel->m_Title + wxT( ".jpg" ) );
if( ImageFile.Normalize( wxPATH_NORM_ALL | wxPATH_NORM_CASE ) )
{
wxImage PodcastImage;
if( wxFileExists( ImageFile.GetFullPath() ) &&
PodcastImage.LoadFile( ImageFile.GetFullPath() ) &&
PodcastImage.IsOk() )
{
m_Image->SetBitmap( PodcastImage );
}
else
{
m_Image->SetBitmap( guBitmap( guIMAGE_INDEX_mid_podcast ) );
if( !channel->m_Image.IsEmpty() )
{
guChannelUpdateImageThread * UpdateImageThread = new guChannelUpdateImageThread( this, channel->m_Image.c_str() );
if( !UpdateImageThread )
{
guLogError( wxT( "Could not create the Channel Image Thread" ) );
}
}
}
}
m_Title = new wxStaticText( this, wxID_ANY, channel->m_Title, wxDefaultPosition, wxDefaultSize, 0 );
FlexGridSizer->Add( m_Title, 1, wxEXPAND|wxALIGN_CENTER_VERTICAL, 5 );
DescLabel = new wxStaticText( this, wxID_ANY, _( "Description:" ), wxDefaultPosition, wxDefaultSize, 0 );
DescLabel->Wrap( -1 );
DescLabel->SetFont( wxFont( wxNORMAL_FONT->GetPointSize(), 70, 90, 90, false, wxEmptyString ) );
FlexGridSizer->Add( DescLabel, 0, wxALIGN_RIGHT|wxBOTTOM|wxRIGHT|wxLEFT, 5 );
m_DescText = new wxStaticText( this, wxID_ANY, ( channel->m_Description.Length() > 200 ?
channel->m_Description.Mid( 0, 200 ) + wxT( " ..." ) :
channel->m_Description ), wxDefaultPosition, wxDefaultSize, 0 );
m_DescText->Wrap( 450 );
FlexGridSizer->Add( m_DescText, 0, wxEXPAND|wxALIGN_CENTER_VERTICAL|wxBOTTOM|wxRIGHT, 5 );
AuthorLabel = new wxStaticText( this, wxID_ANY, _("Author:"), wxDefaultPosition, wxDefaultSize, 0 );
AuthorLabel->Wrap( -1 );
AuthorLabel->SetFont( wxFont( wxNORMAL_FONT->GetPointSize(), 70, 90, 90, false, wxEmptyString ) );
FlexGridSizer->Add( AuthorLabel, 0, wxALIGN_RIGHT|wxBOTTOM|wxRIGHT|wxLEFT, 5 );
m_AuthorText = new wxStaticText( this, wxID_ANY, channel->m_Author, wxDefaultPosition, wxDefaultSize, 0 );
m_AuthorText->Wrap( -1 );
FlexGridSizer->Add( m_AuthorText, 0, wxEXPAND|wxALIGN_CENTER_VERTICAL|wxBOTTOM|wxRIGHT, 5 );
OwnerLabel = new wxStaticText( this, wxID_ANY, _("Owner:"), wxDefaultPosition, wxDefaultSize, 0 );
OwnerLabel->Wrap( -1 );
OwnerLabel->SetFont( wxFont( wxNORMAL_FONT->GetPointSize(), 70, 90, 90, false, wxEmptyString ) );
FlexGridSizer->Add( OwnerLabel, 0, wxALIGN_RIGHT|wxBOTTOM|wxRIGHT|wxLEFT, 5 );
m_OwnerText = new wxStaticText( this, wxID_ANY, channel->m_OwnerName +
wxT( " ( " ) + channel->m_OwnerEmail + wxT( " )" ) , wxDefaultPosition, wxDefaultSize, 0 );
m_OwnerText->Wrap( -1 );
FlexGridSizer->Add( m_OwnerText, 0, wxBOTTOM|wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
DownloadLabel = new wxStaticText( this, wxID_ANY, _("Download:"), wxDefaultPosition, wxDefaultSize, 0 );
DownloadLabel->Wrap( -1 );
FlexGridSizer->Add( DownloadLabel, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxALL, 5 );
wxBoxSizer* DownloadSizer;
DownloadSizer = new wxBoxSizer( wxHORIZONTAL );
wxString m_DownloadChoiceChoices[] = { _( "Manually" ), _( "Only if contains" ), _( "Everything" ) };
int m_DownloadChoiceNChoices = sizeof( m_DownloadChoiceChoices ) / sizeof( wxString );
m_DownloadChoice = new wxChoice( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, m_DownloadChoiceNChoices, m_DownloadChoiceChoices, 0 );
m_DownloadChoice->SetSelection( channel->m_DownloadType );
DownloadSizer->Add( m_DownloadChoice, 0, wxTOP|wxBOTTOM|wxRIGHT, 5 );
m_DownloadText = new wxTextCtrl( this, wxID_ANY, channel->m_DownloadText, wxDefaultPosition, wxDefaultSize, 0 );
m_DownloadText->Enable( ( channel->m_DownloadType == guPODCAST_DOWNLOAD_FILTER ) );
DownloadSizer->Add( m_DownloadText, 1, wxEXPAND|wxALIGN_CENTER_VERTICAL|wxALL, 5 );
FlexGridSizer->Add( DownloadSizer, 1, wxEXPAND, 5 );
DeleteLabel = new wxStaticText( this, wxID_ANY, _("Delete:"), wxDefaultPosition, wxDefaultSize, 0 );
DeleteLabel->Wrap( -1 );
FlexGridSizer->Add( DeleteLabel, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxBOTTOM|wxRIGHT|wxLEFT, 5 );
m_DeleteCheckBox = new wxCheckBox( this, wxID_ANY, _( "Allow delete old items" ), wxDefaultPosition, wxDefaultSize, 0 );
m_DeleteCheckBox->SetValue( channel->m_AllowDelete );
FlexGridSizer->Add( m_DeleteCheckBox, 0, wxBOTTOM|wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
ChannelSizer->Add( FlexGridSizer, 1, wxEXPAND, 5 );
MainSizer->Add( ChannelSizer, 1, wxEXPAND|wxALL, 5 );
ButtonsSizer = new wxStdDialogButtonSizer();
ButtonsSizerOK = new wxButton( this, wxID_OK );
ButtonsSizer->AddButton( ButtonsSizerOK );
ButtonsSizerCancel = new wxButton( this, wxID_CANCEL );
ButtonsSizer->AddButton( ButtonsSizerCancel );
ButtonsSizer->SetAffirmativeButton( ButtonsSizerOK );
ButtonsSizer->SetCancelButton( ButtonsSizerCancel );
ButtonsSizer->Realize();
MainSizer->Add( ButtonsSizer, 0, wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT, 5 );
this->SetSizer( MainSizer );
this->Layout();
ButtonsSizerOK->SetDefault();
// Bind Events
m_DownloadChoice->Bind( wxEVT_CHOICE, &guChannelEditor::OnDownloadChoice, this );
Bind( guChannelEditorEvent, &guChannelEditor::OnChannelImageUpdated, this, guCHANNELEDITOR_EVENT_UPDATE_IMAGE );
m_DescText->SetFocus();
}
//===========================================================================
//
//
//
//===========================================================================
void FMaterial::Precache()
{
Bind(0, 0);
}
VideoDisplay::VideoDisplay(
wxToolBar *visualSubToolBar,
bool freeSize,
wxComboBox *zoomBox,
wxWindow* parent,
agi::Context *c)
: wxGLCanvas(parent, -1, attribList)
, autohideTools(OPT_GET("Tool/Visual/Autohide"))
, con(c)
, zoomValue(OPT_GET("Video/Default Zoom")->GetInt() * .125 + .125)
, toolBar(visualSubToolBar)
, zoomBox(zoomBox)
, freeSize(freeSize)
, retina_helper(agi::util::make_unique<RetinaHelper>(this))
, scale_factor(retina_helper->GetScaleFactor())
, scale_factor_connection(retina_helper->AddScaleFactorListener([=](int new_scale_factor) {
double new_zoom = zoomValue * new_scale_factor / scale_factor;
scale_factor = new_scale_factor;
SetZoom(new_zoom);
}))
{
zoomBox->SetValue(wxString::Format("%g%%", zoomValue * 100.));
zoomBox->Bind(wxEVT_COMBOBOX, &VideoDisplay::SetZoomFromBox, this);
zoomBox->Bind(wxEVT_TEXT_ENTER, &VideoDisplay::SetZoomFromBoxText, this);
con->videoController->Bind(EVT_FRAME_READY, &VideoDisplay::UploadFrameData, this);
slots.push_back(con->videoController->AddVideoOpenListener(&VideoDisplay::UpdateSize, this));
slots.push_back(con->videoController->AddARChangeListener(&VideoDisplay::UpdateSize, this));
slots.push_back(con->subsController->AddFileSaveListener(&VideoDisplay::OnSubtitlesSave, this));
Bind(wxEVT_PAINT, std::bind(&VideoDisplay::Render, this));
Bind(wxEVT_SIZE, &VideoDisplay::OnSizeEvent, this);
Bind(wxEVT_CONTEXT_MENU, &VideoDisplay::OnContextMenu, this);
Bind(wxEVT_ENTER_WINDOW, &VideoDisplay::OnMouseEvent, this);
Bind(wxEVT_CHAR_HOOK, &VideoDisplay::OnKeyDown, this);
Bind(wxEVT_LEAVE_WINDOW, &VideoDisplay::OnMouseLeave, this);
Bind(wxEVT_LEFT_DCLICK, &VideoDisplay::OnMouseEvent, this);
Bind(wxEVT_LEFT_DOWN, &VideoDisplay::OnMouseEvent, this);
Bind(wxEVT_LEFT_UP, &VideoDisplay::OnMouseEvent, this);
Bind(wxEVT_MOTION, &VideoDisplay::OnMouseEvent, this);
Bind(wxEVT_MOUSEWHEEL, &VideoDisplay::OnMouseWheel, this);
SetCursor(wxNullCursor);
c->videoDisplay = this;
if (con->videoController->IsLoaded())
con->videoController->JumpToFrame(con->videoController->GetFrameN());
}
void VertexBufferObject::Draw(int offset) const
{
Bind();
glDrawArrays(GL_TRIANGLES, offset, vertexCount);
Unbind();
}
RegisterEditorDialog::RegisterEditorDialog(wxPanel *parent, u32 _pc, cpu_thread* _cpu, CPUDisAsm* _disasm)
: wxDialog(parent, wxID_ANY, "Edit registers")
, pc(_pc)
, cpu(_cpu)
, disasm(_disasm)
{
wxBoxSizer* s_panel_margin_x = new wxBoxSizer(wxHORIZONTAL);
wxBoxSizer* s_panel_margin_y = new wxBoxSizer(wxVERTICAL);
wxBoxSizer* s_panel = new wxBoxSizer(wxVERTICAL);
wxBoxSizer* s_t1_panel = new wxBoxSizer(wxHORIZONTAL);
wxBoxSizer* s_t2_panel = new wxBoxSizer(wxHORIZONTAL);
wxBoxSizer* s_t3_panel = new wxBoxSizer(wxHORIZONTAL);
wxBoxSizer* s_b_panel = new wxBoxSizer(wxHORIZONTAL);
wxStaticText* t1_text = new wxStaticText(this, wxID_ANY, "Register: ");
t1_register = new wxComboBox(this, wxID_ANY);
wxStaticText* t2_text = new wxStaticText(this, wxID_ANY, "Value (Hex):");
t2_value = new wxTextCtrl(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(200, -1));
s_t1_panel->Add(t1_text);
s_t1_panel->AddSpacer(8);
s_t1_panel->Add(t1_register);
s_t2_panel->Add(t2_text);
s_t2_panel->AddSpacer(8);
s_t2_panel->Add(t2_value);
s_b_panel->Add(new wxButton(this, wxID_OK), wxLEFT, 0, 5);
s_b_panel->AddSpacer(5);
s_b_panel->Add(new wxButton(this, wxID_CANCEL), wxLEFT, 0, 5);
s_panel->Add(s_t1_panel);
s_panel->AddSpacer(8);
s_panel->Add(s_t2_panel);
s_panel->AddSpacer(16);
s_panel->Add(s_b_panel);
s_panel_margin_y->AddSpacer(12);
s_panel_margin_y->Add(s_panel);
s_panel_margin_y->AddSpacer(12);
s_panel_margin_x->AddSpacer(12);
s_panel_margin_x->Add(s_panel_margin_y);
s_panel_margin_x->AddSpacer(12);
Bind(wxEVT_COMBOBOX, &RegisterEditorDialog::updateRegister, this);
switch (cpu->type)
{
case cpu_type::ppu:
for (int i = 0; i<32; i++) t1_register->Append(wxString::Format("GPR[%d]", i));
for (int i = 0; i<32; i++) t1_register->Append(wxString::Format("FPR[%d]", i));
for (int i = 0; i<32; i++) t1_register->Append(wxString::Format("VR[%d]", i));
t1_register->Append("CR");
t1_register->Append("LR");
t1_register->Append("CTR");
//t1_register->Append("XER");
//t1_register->Append("FPSCR");
break;
case cpu_type::spu:
for (int i = 0; i<128; i++) t1_register->Append(wxString::Format("GPR[%d]", i));
break;
default:
wxMessageBox("Not supported thread.", "Error");
return;
}
SetSizerAndFit(s_panel_margin_x);
if (ShowModal() == wxID_OK)
{
std::string reg = fmt::ToUTF8(t1_register->GetStringSelection());
std::string value = fmt::ToUTF8(t2_value->GetValue());
switch (cpu->type)
{
case cpu_type::ppu:
{
auto& ppu = *static_cast<ppu_thread*>(cpu);
while (value.length() < 32) value = "0" + value;
std::string::size_type first_brk = reg.find('[');
try
{
if (first_brk != std::string::npos)
{
long reg_index = atol(reg.substr(first_brk + 1, reg.length() - first_brk - 2).c_str());
if (reg.find("GPR") == 0 || reg.find("FPR") == 0)
{
unsigned long long reg_value;
reg_value = std::stoull(value.substr(16, 31), 0, 16);
if (reg.find("GPR") == 0) ppu.gpr[reg_index] = (u64)reg_value;
if (reg.find("FPR") == 0) (u64&)ppu.fpr[reg_index] = (u64)reg_value;
return;
}
if (reg.find("VR") == 0)
{
unsigned long long reg_value0;
unsigned long long reg_value1;
reg_value0 = std::stoull(value.substr(16, 31), 0, 16);
reg_value1 = std::stoull(value.substr(0, 15), 0, 16);
ppu.vr[reg_index]._u64[0] = (u64)reg_value0;
ppu.vr[reg_index]._u64[1] = (u64)reg_value1;
return;
}
}
if (reg == "LR" || reg == "CTR")
{
unsigned long long reg_value;
reg_value = std::stoull(value.substr(16, 31), 0, 16);
if (reg == "LR") ppu.lr = (u64)reg_value;
if (reg == "CTR") ppu.ctr = (u64)reg_value;
return;
}
if (reg == "CR")
{
unsigned long long reg_value;
reg_value = std::stoull(value.substr(24, 31), 0, 16);
if (reg == "CR") ppu.cr_unpack((u32)reg_value);
return;
}
}
catch (std::invalid_argument&)//if any of the stoull conversion fail
{
break;
}
break;
}
case cpu_type::spu:
{
auto& spu = *static_cast<SPUThread*>(cpu);
while (value.length() < 32) value = "0" + value;
std::string::size_type first_brk = reg.find('[');
if (first_brk != std::string::npos)
{
long reg_index;
reg_index = atol(reg.substr(first_brk + 1, reg.length() - 2).c_str());
if (reg.find("GPR") == 0)
{
ullong reg_value0;
ullong reg_value1;
try
{
reg_value0 = std::stoull(value.substr(16, 31), 0, 16);
reg_value1 = std::stoull(value.substr(0, 15), 0, 16);
}
catch (std::invalid_argument& /*e*/)
{
break;
}
spu.gpr[reg_index]._u64[0] = (u64)reg_value0;
spu.gpr[reg_index]._u64[1] = (u64)reg_value1;
return;
}
}
break;
}
}
wxMessageBox("This value could not be converted.\nNo changes were made.", "Error");
}
}
GitConsole::GitConsole(wxWindow* parent, GitPlugin* git)
: GitConsoleBase(parent)
, m_git(git)
{
// set the font to fit the C++ lexer default font
LexerConf::Ptr_t lexCpp = EditorConfigST::Get()->GetLexer("text");
if(lexCpp) {
lexCpp->Apply(m_stcLog);
}
m_bitmapLoader = new BitmapLoader();
GitImages m_images;
m_bitmaps = m_bitmapLoader->MakeStandardMimeMap();
m_modifiedBmp = m_bitmapLoader->LoadBitmap("subversion/16/modified");
m_untrackedBmp = m_bitmapLoader->LoadBitmap("subversion/16/unversioned");
m_folderBmp = m_bitmapLoader->LoadBitmap("mime/16/folder");
m_newBmp = m_images.Bitmap("gitFileAdd");
m_deleteBmp = m_bitmapLoader->LoadBitmap("subversion/16/deleted");
EventNotifier::Get()->Connect(
wxEVT_GIT_CONFIG_CHANGED, wxCommandEventHandler(GitConsole::OnConfigurationChanged), NULL, this);
EventNotifier::Get()->Connect(
wxEVT_WORKSPACE_CLOSED, wxCommandEventHandler(GitConsole::OnWorkspaceClosed), NULL, this);
EventNotifier::Get()->Connect(
wxEVT_CL_THEME_CHANGED, wxCommandEventHandler(GitConsole::OnEditorThemeChanged), NULL, this);
clConfig conf("git.conf");
GitEntry data;
conf.ReadItem(&data);
m_isVerbose = (data.GetFlags() & GitEntry::Git_Verbose_Log);
m_splitter->SetSashPosition(data.GetGitConsoleSashPos());
m_auibar->AddTool(
XRCID("git_reset_repository"), _("Reset"), m_images.Bitmap("gitResetRepo"), _("Reset repository"));
m_auibar->AddSeparator();
m_auibar->AddTool(XRCID("git_pull"), _("Pull"), m_images.Bitmap("gitPull"), _("Pull remote changes"));
m_auibar->SetToolDropDown(XRCID("git_pull"), true);
m_auibar->AddTool(XRCID("git_commit"), _("Commit"), m_images.Bitmap("gitCommitLocal"), _("Commit local changes"));
m_auibar->AddTool(XRCID("git_push"), _("Push"), m_images.Bitmap("gitPush"), _("Push local changes"));
m_auibar->AddTool(XRCID("git_rebase"), _("Rebase"), m_images.Bitmap("gitRebase"), _("Rebase"));
m_auibar->SetToolDropDown(XRCID("git_rebase"), true);
m_auibar->AddSeparator();
m_auibar->AddTool(XRCID("git_commit_diff"), _("Diffs"), m_images.Bitmap("gitDiffs"), _("Show current diffs"));
m_auibar->AddTool(
XRCID("git_browse_commit_list"), _("Log"), m_images.Bitmap("gitCommitedFiles"), _("Browse commit history"));
#ifdef __WXMSW__
m_auibar->AddSeparator();
m_auibar->AddTool(XRCID("git_msysgit"),
_("Open MSYS Git"),
m_images.Bitmap("msysgit"),
_("Open MSYS Git at the current file location"));
#endif
wxAuiToolBarItemArray append_items;
PopulateAuiToolbarOverflow(append_items, m_images);
m_auibar->AddSeparator();
for(size_t i = 0; i < append_items.GetCount(); ++i) {
const wxAuiToolBarItem& item = append_items.Item(i);
m_auibar->AddTool(item.GetId(), item.GetLabel(), item.GetBitmap(), item.GetLabel(), (wxItemKind)item.GetKind());
}
m_auibar->Realize();
Bind(wxEVT_AUITOOLBAR_TOOL_DROPDOWN,
wxAuiToolBarEventHandler(GitConsole::OnGitPullDropdown),
this,
XRCID("git_pull"));
Bind(wxEVT_AUITOOLBAR_TOOL_DROPDOWN,
wxAuiToolBarEventHandler(GitConsole::OnGitRebaseDropdown),
this,
XRCID("git_rebase"));
// Adjust the h-scrollbar of git log
::clRecalculateSTCHScrollBar(m_stcLog);
}
// Construtor of JoystickConfiguration
JoystickConfiguration::JoystickConfiguration(int pad, bool left, wxWindow *parent)
: wxDialog(
parent, // Parent
wxID_ANY, // ID
_T("Gamepad configuration"), // Title
wxDefaultPosition, // Position
wxSize(400, 200), // Width + Lenght
// Style
wxSYSTEM_MENU |
wxCAPTION |
wxCLOSE_BOX |
wxCLIP_CHILDREN)
{
m_init_reverse_Lx = false;
m_init_reverse_Ly = false;
m_init_reverse_Rx = false;
m_init_reverse_Ry = false;
m_init_mouse_Ljoy = false;
m_init_mouse_Rjoy = false;
m_pad_id = pad;
m_isForLeftJoystick = left;
m_pan_joystick_config = new wxPanel(
this, // Parent
wxID_ANY, // ID
wxDefaultPosition, // Prosition
wxSize(300, 200) // Size
);
if (m_isForLeftJoystick) {
m_cb_reverse_Lx = new wxCheckBox(
m_pan_joystick_config, // Parent
wxID_ANY, // ID
_T("Reverse Lx"), // Label
wxPoint(20, 20) // Position
);
m_cb_reverse_Ly = new wxCheckBox(
m_pan_joystick_config, // Parent
wxID_ANY, // ID
_T("Reverse Ly"), // Label
wxPoint(20, 40) // Position
);
m_cb_mouse_Ljoy = new wxCheckBox(
m_pan_joystick_config, // Parent
wxID_ANY, // ID
_T("Use mouse for left analog joystick"), // Label
wxPoint(20, 60) // Position
);
m_cb_reverse_Rx = nullptr;
m_cb_reverse_Ry = nullptr;
m_cb_mouse_Rjoy = nullptr;
} else {
m_cb_reverse_Rx = new wxCheckBox(
m_pan_joystick_config, // Parent
wxID_ANY, // ID
_T("Reverse Rx"), // Label
wxPoint(20, 20) // Position
);
m_cb_reverse_Ry = new wxCheckBox(
m_pan_joystick_config, // Parent
wxID_ANY, // ID
_T("Reverse Ry"), // Label
wxPoint(20, 40) // Position
);
m_cb_mouse_Rjoy = new wxCheckBox(
m_pan_joystick_config, // Parent
wxID_ANY, // ID
_T("Use mouse for right analog joystick"), // Label
wxPoint(20, 60) // Position
);
m_cb_reverse_Lx = nullptr;
m_cb_reverse_Ly = nullptr;
m_cb_mouse_Ljoy = nullptr;
}
m_bt_ok = new wxButton(
m_pan_joystick_config, // Parent
wxID_ANY, // ID
_T("&OK"), // Label
wxPoint(250, 130), // Position
wxSize(60, 25) // Size
);
m_bt_cancel = new wxButton(
m_pan_joystick_config, // Parent
wxID_ANY, // ID
_T("&Cancel"), // Label
wxPoint(320, 130), // Position
wxSize(60, 25) // Size
);
Bind(wxEVT_BUTTON, &JoystickConfiguration::OnButtonClicked, this);
Bind(wxEVT_CHECKBOX, &JoystickConfiguration::OnCheckboxChange, this);
}
bool DolphinApp::OnInit()
{
Bind(wxEVT_QUERY_END_SESSION, &DolphinApp::OnEndSession, this);
Bind(wxEVT_END_SESSION, &DolphinApp::OnEndSession, this);
// Declarations and definitions
bool UseDebugger = false;
bool UseLogger = false;
bool selectVideoBackend = false;
bool selectAudioEmulation = false;
bool selectPerfDir = false;
wxString videoBackendName;
wxString audioEmulationName;
wxString userPath;
wxString perfDir;
#if wxUSE_CMDLINE_PARSER // Parse command lines
wxCmdLineEntryDesc cmdLineDesc[] =
{
{
wxCMD_LINE_SWITCH, "h", "help",
"Show this help message",
wxCMD_LINE_VAL_NONE, wxCMD_LINE_OPTION_HELP
},
{
wxCMD_LINE_SWITCH, "d", "debugger",
"Opens the debugger",
wxCMD_LINE_VAL_NONE, wxCMD_LINE_PARAM_OPTIONAL
},
{
wxCMD_LINE_SWITCH, "l", "logger",
"Opens the logger",
wxCMD_LINE_VAL_NONE, wxCMD_LINE_PARAM_OPTIONAL
},
{
wxCMD_LINE_OPTION, "e", "exec",
"Loads the specified file (ELF, DOL, GCM, ISO, WBFS, CISO, GCZ, WAD)",
wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL
},
{
wxCMD_LINE_SWITCH, "b", "batch",
"Exit Dolphin with emulator",
wxCMD_LINE_VAL_NONE, wxCMD_LINE_PARAM_OPTIONAL
},
{
wxCMD_LINE_OPTION, "V", "video_backend",
"Specify a video backend",
wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL
},
{
wxCMD_LINE_OPTION, "A", "audio_emulation",
"Low level (LLE) or high level (HLE) audio",
wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL
},
{
wxCMD_LINE_OPTION, "m", "movie",
"Play a movie file",
wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL
},
{
wxCMD_LINE_OPTION, "U", "user",
"User folder path",
wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL
},
{
wxCMD_LINE_OPTION, "P", "perf_dir",
"Directory for Linux perf perf-$pid.map file",
wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL
},
{
wxCMD_LINE_NONE, nullptr, nullptr, nullptr, wxCMD_LINE_VAL_NONE, 0
}
};
// Gets the command line parameters
wxCmdLineParser parser(cmdLineDesc, argc, argv);
LoadFile = false;
if (argc == 2 && File::Exists(argv[1].ToUTF8().data()))
{
LoadFile = true;
FileToLoad = argv[1];
}
else if (parser.Parse() != 0)
{
return false;
}
UseDebugger = parser.Found("debugger");
UseLogger = parser.Found("logger");
if (!LoadFile)
LoadFile = parser.Found("exec", &FileToLoad);
BatchMode = parser.Found("batch");
selectVideoBackend = parser.Found("video_backend", &videoBackendName);
selectAudioEmulation = parser.Found("audio_emulation", &audioEmulationName);
selectPerfDir = parser.Found("perf_dir", &perfDir);
playMovie = parser.Found("movie", &movieFile);
parser.Found("user", &userPath);
#endif // wxUSE_CMDLINE_PARSER
// Register message box and translation handlers
RegisterMsgAlertHandler(&wxMsgAlert);
RegisterStringTranslator(&wxStringTranslator);
#if wxUSE_ON_FATAL_EXCEPTION
wxHandleFatalExceptions(true);
#endif
UICommon::SetUserDirectory(userPath.ToStdString());
UICommon::CreateDirectories();
InitLanguageSupport(); // The language setting is loaded from the user directory
UICommon::Init();
if (selectPerfDir)
{
SConfig::GetInstance().m_perfDir =
WxStrToStr(perfDir);
}
if (selectVideoBackend && videoBackendName != wxEmptyString)
SConfig::GetInstance().m_strVideoBackend =
WxStrToStr(videoBackendName);
if (selectAudioEmulation)
{
if (audioEmulationName == "HLE")
SConfig::GetInstance().bDSPHLE = true;
else if (audioEmulationName == "LLE")
SConfig::GetInstance().bDSPHLE = false;
}
VideoBackend::ActivateBackend(SConfig::GetInstance().m_strVideoBackend);
// Enable the PNG image handler for screenshots
wxImage::AddHandler(new wxPNGHandler);
int x = SConfig::GetInstance().iPosX;
int y = SConfig::GetInstance().iPosY;
int w = SConfig::GetInstance().iWidth;
int h = SConfig::GetInstance().iHeight;
if (File::Exists("www.dolphin-emulator.com.txt"))
{
File::Delete("www.dolphin-emulator.com.txt");
wxMessageDialog dlg(nullptr, _(
"This version of Dolphin was downloaded from a website stealing money from developers of the emulator. Please "
"download Dolphin from the official website instead: https://dolphin-emu.org/"),
_("Unofficial version detected"), wxOK | wxICON_WARNING);
dlg.ShowModal();
wxLaunchDefaultBrowser("https://dolphin-emu.org/?ref=badver");
exit(0);
}
// The following is not needed with X11, where window managers
// do not allow windows to be created off the desktop.
#ifdef _WIN32
// Out of desktop check
int leftPos = GetSystemMetrics(SM_XVIRTUALSCREEN);
int topPos = GetSystemMetrics(SM_YVIRTUALSCREEN);
int width = GetSystemMetrics(SM_CXVIRTUALSCREEN);
int height = GetSystemMetrics(SM_CYVIRTUALSCREEN);
if ((leftPos + width) < (x + w) || leftPos > x || (topPos + height) < (y + h) || topPos > y)
x = y = wxDefaultCoord;
#elif defined __APPLE__
if (y < 1)
y = wxDefaultCoord;
#endif
main_frame = new CFrame(nullptr, wxID_ANY,
StrToWxStr(scm_rev_str),
wxPoint(x, y), wxSize(w, h),
UseDebugger, BatchMode, UseLogger);
SetTopWindow(main_frame);
main_frame->SetMinSize(wxSize(400, 300));
AfterInit();
return true;
}
void
if_init()
{
struct hwa_info *hwa, *hwahead;
struct sockaddr *sa;
struct hostent *hptr;
char *ptr;
char **pptr;
int i, j, prflag, n;
struct arp_cache_entry cache_entry;
memset(if_hwaddr, 0, sizeof(if_hwaddr));
memset(if_sock, 0, sizeof(if_sock));
if_size = 0;
puts("<-- HW INFO -->");
for (i = 0; i < NUM_VM; i++){
sprintf(node_ip[i], "vm%d", i+1);
hptr = gethostbyname(node_ip[i]);
for (pptr = hptr->h_addr_list; *pptr != NULL; pptr++){
Inet_ntop(hptr->h_addrtype, *pptr, node_ip[i], INET_ADDRSTRLEN);
}
}
for (hwahead = hwa = Get_hw_addrs(); hwa != NULL; hwa = hwa->hwa_next) {
printf("interface index = %d\n", (n = hwa->if_index));
printf("%s :%s", hwa->if_name,
((hwa->ip_alias) == IP_ALIAS) ? " (alias)\n" : "\n");
if ((hwa->ip_alias) != IP_ALIAS) {
if_size++;
}
if ((sa = hwa->ip_addr) != NULL) {
printf("\tIP addr = %s\n", Sock_ntop_host(sa, sizeof(*sa)));
if (hwa->if_haddr != NULL) {
if (strcmp(hwa->if_haddr, if_hwaddr[my_index])
== 0 && (hwa->ip_alias) == IP_ALIAS) {
insert_local_hw_cache(Sock_ntop_host(sa, sizeof(*sa)));
}
}
}
// get canonical ip
if (strcmp(hwa->if_name, "eth0") == 0) {
sprintf(my_ip, "%s", Sock_ntop_host(sa, sizeof(*sa)));
my_index = hwa->if_index;
for (my_vm = 0; my_vm < NUM_VM; my_vm++) {
if (strcmp(my_ip, node_ip[my_vm]) == 0) {
my_vm++;
break;
}
}
}
prflag = i = 0;
do {
if (hwa->if_haddr[i] != '\0') {
prflag = 1;
break;
}
} while (++i < IF_HADDR);
if (prflag) {
printf("\tHW addr = ");
for (i = 0; i < IF_HADDR; i++) {
if_hwaddr[n][i] = hwa->if_haddr[i];
printf("%02x ", (int) if_hwaddr[n][i] & 0xff);
}
puts("");
}
}
// printf("***info: number of interfaces -- %d\n***", if_size);
// Create PF_PACKET socket for etho0
if_sockfd = Socket(AF_PACKET, SOCK_RAW, htons(ARP_PROTOCOL));
addr.sll_family = PF_PACKET;
addr.sll_protocol = htons(ARP_PROTOCOL);
addr.sll_ifindex = my_index;
addr.sll_hatype = ARPHRD_ETHER;
addr.sll_pkttype = PACKET_HOST;
addr.sll_halen = ETH_ALEN;
for (j = 0; j < ETH_ALEN; j++){
addr.sll_addr[j] = if_hwaddr[my_index][j];
}
Bind(if_sockfd, (SA *)&addr, sizeof(struct sockaddr_ll));
maxfd= (maxfd, if_sockfd);
insert_local_hw_cache(my_ip);
// puts("if_init done\n");
puts("");
}
int main(int argc, char* argv[]) {
struct sockaddr_in sad; // structure to hold an IP address
struct sockaddr_in cad; // structure to hold an IP address
struct addrinfo hint;
struct addrinfo *serverptr;
int sd, sd2; // socket descriptor
int port; // protocol port number
char *host; // pointer to host name
char buf[BUFSIZE]; // buffer for data from the server
char buf2[BUFSIZE];
int bytes_expected;
int alen;
memset((char *)&sad,0,sizeof(sad)); // clear sockaddr structure
sad.sin_family = AF_INET; // set family to Internet
int i;
for(i = 65; i < BUFSIZE + 65; i++)
buf2[i-65] = i % 256;
if (argc < 3) {
printf("usage: %s [ host ] [ port ]\n",argv[0]);
exit(-1);
}
host = argv[1];
port = atoi(argv[2]);
if (port <= 0) {
fprintf(stderr,"SOURCE: bad port number %s\n",argv[2]);
exit(1);
}
// prepare the hint information
bzero(&hint, sizeof(hint));
hint.ai_flags = AI_CANONNAME;
hint.ai_family = AF_INET;
Getaddrinfo(host, NULL, &hint, &serverptr);
bcopy(serverptr->ai_addr, (char *)&sad, serverptr->ai_addrlen);
sad.sin_port = htons((u_short)port);
// Create a socket.
sd = Socket(AF_INET, SOCK_STREAM, 0);
//Bind the socket to the specififed port
Bind(sd, (struct sockaddr *) &sad, sizeof(sad));
printf("SINK: Socket created\n");
listen(sd, 5);
alen = sizeof(cad);
printf("SINK: Waiting for a connection\n");
sd2 = accept(sd, (struct sockaddr *) &cad, &alen);
printf("SINK: Waiting to receive a message\n");
Readn(sd2, &bytes_expected, sizeof(int));
Readn(sd2, buf2, bytes_expected+1);
printf("SINK: Received a message\n");
printf("SINK: (%d) '%s'\n", bytes_expected, buf2);
Readn(sd2, &bytes_expected, sizeof(int));
Readn(sd2, buf2, bytes_expected+1);
printf("SINK: Received a message\n");
printf("SINK: (%d) '%s'\n", bytes_expected, buf2);
printf("SINK: Responding to Source\n");
strcpy(buf, "message recieved");
bytes_expected = strlen(buf);
Writen(sd, &bytes_expected, sizeof(int));
Writen(sd, buf, bytes_expected);
close(sd2);
close(sd);
return 1;
}
void
JabberProtocol::OnTag(XMLEntity *entity)
{
char buffer[4096]; // general buffer space
static int seen_streams = 0;
if (entity->IsCompleted() && !strcasecmp(entity->Name(), "iq"))
{
// handle roster retrival
if (entity->Child("query") && entity->Child("query")->Attribute("xmlns") &&
!strcasecmp(entity->Child("query")->Attribute("xmlns"),"jabber:iq:roster"))
{
ParseRosterList(entity);
return;
}
// handle session retrival
if (entity->Attribute("id") && entity->Attribute("type") &&
!strcasecmp(entity->Attribute("type"), "result") &&
!strcasecmp(entity->Attribute("id"), "sess_1"))
{
release_sem(logged);
mainWindow->Lock();
mainWindow->PostMessage(JAB_LOGGED_IN);
mainWindow->Unlock();
return;
}
// handle binding retrival
if (entity->Attribute("id") && entity->Attribute("type") &&
!strcasecmp(entity->Attribute("type"), "result") &&
!strcasecmp(entity->Attribute("id"), "bind_0"))
{
jid = BString(entity->Child("bind")->Child("jid")->Data());
fprintf(stderr, "JID: %s.\n", jid.String());
Session();
return;
}
if (entity->Attribute("type") && entity->Child("query") &&
!strcasecmp(entity->Attribute("type"), "result") &&
entity->Child("query", "xmlns", "jabber:iq:register"))
{
Authorize();
return;
}
if (entity->Attribute("type") && entity->Attribute("id") &&
!strcasecmp(entity->Attribute("type"), "result") &&
!strcasecmp(entity->Attribute("id"), "request_room_info"))
{
BMessage msg(JAB_PREFERENCES_DATAFORM);
msg.AddPointer("XMLEntity", entity);
MessageRepeater::Instance()->PostMessage(&msg);
return;
}
if (entity->Attribute("type") && entity->Attribute("id") &&
!strcasecmp(entity->Attribute("type"), "error"))
{
if (!strcasecmp(entity->Attribute("id"), "storage_request"))
{
_storage_supported = false;
return;
}
else if (!strcasecmp(entity->Attribute("id"), "save_conferences"))
{
_storage_supported = false;
sprintf(buffer, "Storage XEP-0049 is not supported on server. Cannot save conferences.\n\nNext time will try save to roster.");
ModalAlertFactory::Alert(buffer, "Pity", NULL, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT);
return;
}
else if (!strcasecmp(entity->Attribute("id"), "request_room_info"))
{
if (entity->Child("error") &&
entity->Child("error")->Child("text") &&
entity->Child("error")->Attribute("code"))
sprintf(buffer, "Error %s:\n\n%s", entity->Child("error")->Attribute("code"),
entity->Child("error")->Child("text")->Data());
else
sprintf(buffer, "Error %s", entity->Child("error")->Attribute("code"));
ModalAlertFactory::Alert(buffer, "OK", NULL, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT);
return;
}
if (entity->Child("error") &&
entity->Child("error")->Child("text") &&
entity->Child("error")->Attribute("code"))
sprintf(buffer, "Error %s:\n\n%s", entity->Child("error")->Attribute("code"),
entity->Child("error")->Child("text")->Data());
else
sprintf(buffer, "Error %s", entity->Child("error")->Attribute("code"));
ModalAlertFactory::Alert(buffer, "OK", NULL, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT);
Disconnect();
return;
}
if (entity->Attribute("id") && entity->Child("query") && entity->Child("query")->Attribute("xmlns") &&
entity->Attribute("type") &&
!strcasecmp(entity->Attribute("id"), "storage_request") &&
!strcasecmp(entity->Attribute("type"), "result") &&
!strcasecmp(entity->Child("query")->Attribute("xmlns"), "jabber:iq:private"))
{
if (entity->Child("query")->Child("storage"))
ParseStorage(entity->Child("query")->Child("storage"));
return;
}
if (entity->Attribute("type") && !strcasecmp(entity->Attribute("type"), "get"))
{
BString iq_from;
BString iq_id;
if (entity->Attribute("from")) {
iq_from = BString(entity->Attribute("from"));
}
if (entity->Attribute("id")) {
iq_id = BString(entity->Attribute("id"));
}
// handle version request
XMLEntity *query = entity->Child("query");
if (query && query->Attribute("xmlns")) {
if (!strcasecmp(query->Attribute("xmlns"), "jabber:iq:version")) {
ProcessVersionRequest(iq_id, iq_from);
}
}
// handle version request
query = entity->Child("ping");
if (query && query->Attribute("xmlns")) {
if (!strcasecmp(query->Attribute("xmlns"), "urn:xmpp:ping"))
{
Pong(iq_id, iq_from);
}
}
return;
}
fprintf(stderr, "Unknown IQ message.\n");
return;
}
// handle authorization success
if (entity->IsCompleted() && !strcasecmp(entity->Name(), "success"))
{
InitSession();
return;
}
// handle presence messages
if (entity->IsCompleted() && !strcasecmp(entity->Name(), "presence"))
{
ProcessPresence(entity);
return;
}
// handle stream error
if (entity->IsCompleted() && !strcasecmp(entity->Name(), "stream:error")) {
sprintf(buffer, "An stream error has occurred.");
ModalAlertFactory::Alert(buffer, "Sorry", NULL, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT);
Disconnect();
return;
}
// handle stream error
if (entity->IsCompleted() && !strcasecmp(entity->Name(), "stream:features"))
{
mainWindow->Lock();
int wantRegister = mainWindow->_login_new_account->Value();
mainWindow->Unlock();
if (wantRegister == B_CONTROL_ON)
{
if (entity->Child("register"))
{
mainWindow->Lock();
mainWindow->_login_new_account->SetValue(B_CONTROL_OFF);
mainWindow->Unlock();
SendUserRegistration(user, pass, "haiku");
} else
{
sprintf(buffer, "Registration not supported on this server.");
ModalAlertFactory::Alert(buffer, "Sorry", NULL, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT);
Disconnect();
}
}
else if (entity->Child("mechanisms"))
Authorize();
else if (entity->Child("bind"))
Bind();
else if (entity->Child("session"))
Session();
return;
}
// handle failures
if (entity->IsCompleted() && !strcasecmp(entity->Name(), "failure")) {
if (entity->Child("not-authorized") != NULL)
sprintf(buffer, "Not authorized failure.");
else if (entity->Child("invalid-mechanism") != NULL)
sprintf(buffer, "Invalid mechanism failure.");
else if (entity->Child("invalid-authzid") != NULL)
sprintf(buffer, "Invalid authorization Id.");
else
sprintf(buffer, "An failure occured.");
ModalAlertFactory::Alert(buffer, "Sorry", NULL, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT);
Disconnect();
return;
}
// handle disconnection
if (entity->IsCompleted() && !strcasecmp(entity->Name(), "stream:stream"))
{
++seen_streams;
if (seen_streams % 2 == 1)
Disconnect();
return;
}
// handle incoming messages
if (entity->IsCompleted() && !strcasecmp(entity->Name(), "message"))
{
//TalkManager::Instance()->Lock();
TalkManager::Instance()->ProcessMessageData(entity);
//TalkManager::Instance()->Unlock();
return;
}
//delete entity;
}
WritingExample(void)
{
VertexShader vs;
// Set the vertex shader source
vs.Source(
"#version 330\n"
"in vec4 Position;"
"void main(void)"
"{"
" gl_Position = Position;"
"}"
);
// compile it
vs.Compile();
GeometryShader gs;
// Set the geometry shader source
gs.Source(
"#version 330\n"
"layout(lines) in;"
"layout(triangle_strip, max_vertices = 4) out;"
"void main(void)"
"{"
" vec4 offs = vec4(0.02, 0.01, 0.0, 0.0);"
" gl_Position = gl_in[0].gl_Position - offs;"
" EmitVertex();"
" gl_Position = gl_in[0].gl_Position + offs;"
" EmitVertex();"
" gl_Position = gl_in[1].gl_Position - offs;"
" EmitVertex();"
" gl_Position = gl_in[1].gl_Position + offs;"
" EmitVertex();"
" EndPrimitive();"
"}"
);
// compile it
gs.Compile();
FragmentShader fs;
// set the fragment shader source
fs.Source(
"#version 330\n"
"out vec4 fragColor;"
"void main(void)"
"{"
" fragColor = vec4(0.0, 0.0, 0.0, 1.0);"
"}"
);
// compile it
fs.Compile();
// attach the shaders to the program
prog.AttachShader(vs);
prog.AttachShader(gs);
prog.AttachShader(fs);
// link and use it
prog.Link();
prog.Use();
const Vec2f points[] = {
Vec2f(-0.33f, +0.50f),
Vec2f(-0.45f, +0.70f),
Vec2f(-0.66f, +0.70f),
Vec2f(-0.66f, +0.30f),
Vec2f(-0.66f, -0.20f),
Vec2f(-0.35f, -0.15f),
Vec2f(-0.30f, +0.05f),
Vec2f(-0.20f, +0.50f),
Vec2f(-0.30f, +0.50f),
Vec2f(-0.33f, +0.50f),
Vec2f(-0.50f, +0.45f),
Vec2f(-0.10f, +0.40f),
Vec2f(+0.10f, +0.55f),
Vec2f(-0.20f, +0.40f),
Vec2f(-0.30f, -0.10f),
Vec2f( 0.00f, -0.10f),
Vec2f(+0.10f, -0.10f),
Vec2f(+0.20f, -0.10f),
Vec2f(+0.10f, +0.55f),
Vec2f(+0.20f, +0.00f),
Vec2f(+0.30f, -0.70f),
Vec2f( 0.00f, -0.75f),
Vec2f(-0.40f, -0.75f),
Vec2f( 0.00f, 0.00f),
Vec2f(+0.40f, +0.10f),
Vec2f(+0.60f, +0.10f),
Vec2f(+0.70f, +0.90f),
Vec2f(+0.55f, +0.90f),
Vec2f(+0.35f, +0.90f),
Vec2f(+0.10f, -0.10f),
Vec2f(+0.55f, 0.00f),
Vec2f(+0.90f, 0.10f),
Vec2f(+0.70f, 0.10f),
Vec2f(+0.90f, 0.20f)
};
BezierCurves<Vec2f, double, 3> bezier(
std::vector<Vec2f>(
points,
points+sizeof(points)/sizeof(points[0])
)
);
writing.Bind();
{
auto data = bezier.Approximate(25);
curve_n = data.size();
Bind(curve_verts, Buffer::Target::Array).Data(data);
VertexAttribArray attr(prog, "Position");
attr.Setup(2, DataType::Float);
attr.Enable();
}
gl.ClearColor(0.9f, 0.9f, 0.9f, 0.0f);
}
WorkerThread(WorkerThreadPool *owner, WorkerThreadPool::Priority p)
: m_owner(owner),
m_priority(p),
m_thread(Bind(this).To<&WorkerThread::Run>())
{}
void Item::LoadFromDB(Field* fields, Player* plr, bool light )
{
int32 count;
uint32 itemid = fields[2].GetUInt32(), random_prop = fields[9].GetUInt32(), random_suffix = fields[10].GetUInt32();
m_itemProto = ItemPrototypeStorage.LookupEntry( itemid );
ASSERT( m_itemProto );
if(m_itemProto->LockId > 1)
locked = true;
else
locked = false;
SetUInt32Value( OBJECT_FIELD_ENTRY, itemid );
m_owner = plr;
wrapped_item_id=fields[3].GetUInt32();
m_uint32Values[ITEM_FIELD_GIFTCREATOR] = fields[4].GetUInt32();
m_uint32Values[ITEM_FIELD_CREATOR] = fields[5].GetUInt32();
count = fields[6].GetUInt32();
if(m_itemProto->MaxCount > 0 && count > m_itemProto->MaxCount)
count = m_itemProto->MaxCount;
SetUInt32Value( ITEM_FIELD_STACK_COUNT, count);
// Again another for that did not indent to make it do anything for more than
// one iteration x == 0 was the only one executed
for( uint32 x = 0; x < 5; x++ )
{
if( m_itemProto->Spells[x].Id )
{
SetUInt32Value( ITEM_FIELD_SPELL_CHARGES + x , fields[7].GetUInt32() );
break;
}
}
SetUInt32Value( ITEM_FIELD_FLAGS, fields[8].GetUInt32() );
Bind(ITEM_BIND_ON_PICKUP); // Check if we need to bind our shit.
if( random_prop )
SetRandomProperty( random_prop );
else if( random_suffix )
SetRandomSuffix( random_suffix );
SetTextID( fields[11].GetUInt32() );
SetUInt32Value( ITEM_FIELD_MAXDURABILITY, m_itemProto->MaxDurability );
SetUInt32Value( ITEM_FIELD_DURABILITY, fields[12].GetUInt32() );
if( light )
return;
string enchant_field = fields[15].GetString();
vector< string > enchants = StrSplit( enchant_field, ";" );
uint32 enchant_id;
EnchantEntry* entry;
uint32 time_left;
uint32 enchslot;
uint32 dummy = 0;
for( vector<string>::iterator itr = enchants.begin(); itr != enchants.end(); itr++ )
{
if( sscanf( (*itr).c_str(), "%u,%u,%u,%u", (unsigned int*)&enchant_id, (unsigned int*)&time_left, (unsigned int*)&enchslot, (unsigned int*)&dummy) > 3 )
{
entry = dbcEnchant.LookupEntry( enchant_id );
if( entry && entry->Id == enchant_id )
{
AddEnchantment( entry, time_left, ( time_left == 0 ), false, false, enchslot, 0, ((dummy > 0) ? true : false) );
//(enchslot != 2) ? false : true, false);
}
}
}
string gem_field = fields[16].GetString();
for( uint8 k = 0; k < 3; k++ )
sscanf( gem_field.c_str(), GemReadFormat[k], &Gems[k]);
ApplyRandomProperties( false );
Charter* charter = guildmgr.GetCharterByItemGuid(GetLowGUID());
if(charter != NULL)
{
SetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1, charter->GetID());
// Charter stuff
if(m_uint32Values[OBJECT_FIELD_ENTRY] == ITEM_ENTRY_GUILD_CHARTER)
{
SetUInt32Value( ITEM_FIELD_STACK_COUNT, 1 );
SetUInt32Value( ITEM_FIELD_PROPERTY_SEED, 57813883 );
if( plr->m_playerInfo->charterId[CHARTER_TYPE_GUILD] )
SetUInt32Value( ITEM_FIELD_ENCHANTMENT_1_1, plr->m_playerInfo->charterId[CHARTER_TYPE_GUILD] );
}
if( m_uint32Values[OBJECT_FIELD_ENTRY] == ARENA_TEAM_CHARTER_2v2 )
{
SetUInt32Value( ITEM_FIELD_STACK_COUNT, 1 );
SetUInt32Value( ITEM_FIELD_PROPERTY_SEED, 57813883 );
if( plr->m_playerInfo->charterId[CHARTER_TYPE_ARENA_2V2] )
SetUInt32Value( ITEM_FIELD_ENCHANTMENT_1_1, plr->m_playerInfo->charterId[CHARTER_TYPE_ARENA_2V2] );
}
if( m_uint32Values[OBJECT_FIELD_ENTRY] == ARENA_TEAM_CHARTER_3v3 )
{
SetUInt32Value( ITEM_FIELD_STACK_COUNT, 1 );
SetUInt32Value( ITEM_FIELD_PROPERTY_SEED, 57813883 );
if( plr->m_playerInfo->charterId[CHARTER_TYPE_ARENA_3V3] )
SetUInt32Value( ITEM_FIELD_ENCHANTMENT_1_1, plr->m_playerInfo->charterId[CHARTER_TYPE_ARENA_3V3] );
}
if( m_uint32Values[OBJECT_FIELD_ENTRY] == ARENA_TEAM_CHARTER_5v5 )
{
SetUInt32Value( ITEM_FIELD_STACK_COUNT, 1 );
SetUInt32Value( ITEM_FIELD_PROPERTY_SEED, 57813883 );
if( plr->m_playerInfo->charterId[CHARTER_TYPE_ARENA_5V5] )
SetUInt32Value( ITEM_FIELD_ENCHANTMENT_1_1, plr->m_playerInfo->charterId[CHARTER_TYPE_ARENA_5V5] );
}
}
}
// -----------------------------------------------------------------------------
// GfxEntryPanel class constructor
// -----------------------------------------------------------------------------
GfxEntryPanel::GfxEntryPanel(wxWindow* parent) : EntryPanel(parent, "gfx")
{
// Init variables
prev_translation_.addRange(TransRange::Type::Palette, 0);
edit_translation_.addRange(TransRange::Type::Palette, 0);
// Add gfx canvas
gfx_canvas_ = new GfxCanvas(this, -1);
sizer_main_->Add(gfx_canvas_->toPanel(this), 1, wxEXPAND, 0);
gfx_canvas_->setViewType(GfxCanvas::View::Default);
gfx_canvas_->allowDrag(true);
gfx_canvas_->allowScroll(true);
gfx_canvas_->setPalette(MainEditor::currentPalette());
gfx_canvas_->setTranslation(&edit_translation_);
// Offsets
wxSize spinsize = { UI::px(UI::Size::SpinCtrlWidth), -1 };
spin_xoffset_ = new wxSpinCtrl(
this,
-1,
wxEmptyString,
wxDefaultPosition,
wxDefaultSize,
wxSP_ARROW_KEYS | wxTE_PROCESS_ENTER,
SHRT_MIN,
SHRT_MAX,
0);
spin_yoffset_ = new wxSpinCtrl(
this,
-1,
wxEmptyString,
wxDefaultPosition,
wxDefaultSize,
wxSP_ARROW_KEYS | wxTE_PROCESS_ENTER,
SHRT_MIN,
SHRT_MAX,
0);
spin_xoffset_->SetMinSize(spinsize);
spin_yoffset_->SetMinSize(spinsize);
sizer_bottom_->Add(new wxStaticText(this, -1, "Offsets:"), 0, wxALIGN_CENTER_VERTICAL, 0);
sizer_bottom_->Add(spin_xoffset_, 0, wxALIGN_CENTER_VERTICAL | wxLEFT | wxRIGHT, UI::pad());
sizer_bottom_->Add(spin_yoffset_, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, UI::pad());
// Gfx (offset) type
wxString offset_types[] = { "Auto", "Graphic", "Sprite", "HUD" };
choice_offset_type_ = new wxChoice(this, -1, wxDefaultPosition, wxDefaultSize, 4, offset_types);
choice_offset_type_->SetSelection(0);
sizer_bottom_->Add(choice_offset_type_, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, UI::pad());
// Auto offset
btn_auto_offset_ = new SIconButton(this, "offset", "Modify Offsets...");
sizer_bottom_->Add(btn_auto_offset_, 0, wxALIGN_CENTER_VERTICAL);
sizer_bottom_->AddStretchSpacer();
// Aspect ratio correction checkbox
cb_arc_ = new wxCheckBox(this, -1, "Aspect Ratio Correction");
cb_arc_->SetValue(gfx_arc);
sizer_bottom_->Add(cb_arc_, 0, wxEXPAND, 0);
sizer_bottom_->AddSpacer(UI::padLarge());
// Tile checkbox
cb_tile_ = new wxCheckBox(this, -1, "Tile");
sizer_bottom_->Add(cb_tile_, 0, wxEXPAND, 0);
sizer_bottom_->AddSpacer(UI::padLarge());
// Image selection buttons
btn_nextimg_ = new SIconButton(this, "right");
btn_previmg_ = new SIconButton(this, "left");
text_curimg_ = new wxStaticText(this, -1, "Image XX/XX");
btn_nextimg_->Show(false);
btn_previmg_->Show(false);
text_curimg_->Show(false);
// Palette chooser
listenTo(theMainWindow->paletteChooser());
// Custom menu
menu_custom_ = new wxMenu();
GfxEntryPanel::fillCustomMenu(menu_custom_);
custom_menu_name_ = "Graphic";
// Brushes menu
menu_brushes_ = new wxMenu();
fillBrushMenu(menu_brushes_);
// Custom toolbar
setupToolbar();
// Bind Events
cb_colour_->Bind(wxEVT_COLOURBOX_CHANGED, &GfxEntryPanel::onPaintColourChanged, this);
spin_xoffset_->Bind(wxEVT_SPINCTRL, &GfxEntryPanel::onXOffsetChanged, this);
spin_yoffset_->Bind(wxEVT_SPINCTRL, &GfxEntryPanel::onYOffsetChanged, this);
spin_xoffset_->Bind(wxEVT_TEXT_ENTER, &GfxEntryPanel::onXOffsetChanged, this);
spin_yoffset_->Bind(wxEVT_TEXT_ENTER, &GfxEntryPanel::onYOffsetChanged, this);
choice_offset_type_->Bind(wxEVT_CHOICE, &GfxEntryPanel::onOffsetTypeChanged, this);
cb_tile_->Bind(wxEVT_CHECKBOX, &GfxEntryPanel::onTileChanged, this);
cb_arc_->Bind(wxEVT_CHECKBOX, &GfxEntryPanel::onARCChanged, this);
Bind(wxEVT_GFXCANVAS_OFFSET_CHANGED, &GfxEntryPanel::onGfxOffsetChanged, this, gfx_canvas_->GetId());
Bind(wxEVT_GFXCANVAS_PIXELS_CHANGED, &GfxEntryPanel::onGfxPixelsChanged, this, gfx_canvas_->GetId());
Bind(wxEVT_GFXCANVAS_COLOUR_PICKED, &GfxEntryPanel::onColourPicked, this, gfx_canvas_->GetId());
btn_nextimg_->Bind(wxEVT_BUTTON, &GfxEntryPanel::onBtnNextImg, this);
btn_previmg_->Bind(wxEVT_BUTTON, &GfxEntryPanel::onBtnPrevImg, this);
btn_auto_offset_->Bind(wxEVT_BUTTON, &GfxEntryPanel::onBtnAutoOffset, this);
// Apply layout
wxWindowBase::Layout();
}
int JackNetWinSocket::BindWith(int port)
{
fRecvAddr.sin_port = htons(port);
return Bind();
}