From 98a8057bdc661394e362ebd5c3f3f26d92dac12f Mon Sep 17 00:00:00 2001 From: Todd Stinson Date: Tue, 13 Dec 2011 17:39:39 -0800 Subject: Introducing the initial hooks for building a pathfinding console floater. --- indra/newview/llviewerfloaterreg.cpp | 2 ++ 1 file changed, 2 insertions(+) (limited to 'indra/newview/llviewerfloaterreg.cpp') diff --git a/indra/newview/llviewerfloaterreg.cpp b/indra/newview/llviewerfloaterreg.cpp index 8406f639df..76ad717aae 100644 --- a/indra/newview/llviewerfloaterreg.cpp +++ b/indra/newview/llviewerfloaterreg.cpp @@ -83,6 +83,7 @@ #include "llfloaternotificationsconsole.h" #include "llfloaterobjectweights.h" #include "llfloateropenobject.h" +#include "llfloaterpathfindingconsole.h" #include "llfloaterpay.h" #include "llfloaterperms.h" #include "llfloaterpostprocess.h" @@ -241,6 +242,7 @@ void LLViewerFloaterReg::registerFloaters() LLFloaterReg::add("outgoing_call", "floater_outgoing_call.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterPayUtil::registerFloater(); + LLFloaterReg::add("pathfinding_console", "floater_pathfinding_console.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("people", "floater_people.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("places", "floater_places.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("preferences", "floater_preferences.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); -- cgit v1.3 From e90cdf6682cacd261b2927cc4cecf06dfe5a5447 Mon Sep 17 00:00:00 2001 From: Todd Stinson Date: Thu, 15 Dec 2011 10:31:25 -0800 Subject: Introducing the initial hooks for building the pathfinding linkset floater. --- indra/newview/CMakeLists.txt | 2 + indra/newview/app_settings/commands.xml | 12 ++++- indra/newview/llfloaterpathfindinglinksets.cpp | 49 ++++++++++++++++++++ indra/newview/llfloaterpathfindinglinksets.h | 54 ++++++++++++++++++++++ indra/newview/llviewerfloaterreg.cpp | 2 + indra/newview/skins/default/textures/textures.xml | 1 + .../xui/en/floater_pathfinding_linksets.xml | 26 +++++++++++ indra/newview/skins/default/xui/en/strings.xml | 2 + 8 files changed, 147 insertions(+), 1 deletion(-) create mode 100644 indra/newview/llfloaterpathfindinglinksets.cpp create mode 100644 indra/newview/llfloaterpathfindinglinksets.h create mode 100644 indra/newview/skins/default/xui/en/floater_pathfinding_linksets.xml (limited to 'indra/newview/llviewerfloaterreg.cpp') diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt index 0bd9866b42..13ef8f1848 100644 --- a/indra/newview/CMakeLists.txt +++ b/indra/newview/CMakeLists.txt @@ -220,6 +220,7 @@ set(viewer_SOURCE_FILES llfloaterobjectweights.cpp llfloateropenobject.cpp llfloaterpathfindingconsole.cpp + llfloaterpathfindinglinksets.cpp llfloaterpay.cpp llfloaterperms.cpp llfloaterpostprocess.cpp @@ -776,6 +777,7 @@ set(viewer_HEADER_FILES llfloaterobjectweights.h llfloateropenobject.h llfloaterpathfindingconsole.h + llfloaterpathfindinglinksets.h llfloaterpay.h llfloaterperms.h llfloaterpostprocess.h diff --git a/indra/newview/app_settings/commands.xml b/indra/newview/app_settings/commands.xml index 808c92351a..5d970c06e2 100644 --- a/indra/newview/app_settings/commands.xml +++ b/indra/newview/app_settings/commands.xml @@ -145,7 +145,7 @@ is_running_function="Floater.IsOpen" is_running_parameters="people" /> - + ); + LLFloaterReg::add("pathfinding_linksets", "floater_pathfinding_linksets.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("people", "floater_people.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("places", "floater_places.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("preferences", "floater_preferences.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); diff --git a/indra/newview/skins/default/textures/textures.xml b/indra/newview/skins/default/textures/textures.xml index c082cf6ca4..ee854d96e5 100644 --- a/indra/newview/skins/default/textures/textures.xml +++ b/indra/newview/skins/default/textures/textures.xml @@ -139,6 +139,7 @@ with the same filename but different name + diff --git a/indra/newview/skins/default/xui/en/floater_pathfinding_linksets.xml b/indra/newview/skins/default/xui/en/floater_pathfinding_linksets.xml new file mode 100644 index 0000000000..074ffd5f5d --- /dev/null +++ b/indra/newview/skins/default/xui/en/floater_pathfinding_linksets.xml @@ -0,0 +1,26 @@ + + + + Filter list by: + + diff --git a/indra/newview/skins/default/xui/en/strings.xml b/indra/newview/skins/default/xui/en/strings.xml index 63a55a975a..664d60f8b5 100644 --- a/indra/newview/skins/default/xui/en/strings.xml +++ b/indra/newview/skins/default/xui/en/strings.xml @@ -3677,6 +3677,7 @@ Try enclosing path to the editor with double quotes. Walk / run / fly Pathfinding People + Pathfinding Linksets Picks Places Preferences @@ -3703,6 +3704,7 @@ Try enclosing path to the editor with double quotes. Moving your avatar Information about pathfinding Friends, groups, and nearby people + Manipulation of pathfinding linksets Places to show as favorites in your profile Places you've saved Preferences -- cgit v1.3 From 1cc154166fe504e17735669b7b9e366f93e34d64 Mon Sep 17 00:00:00 2001 From: Tank_Master Date: Tue, 20 Dec 2011 22:17:20 -0800 Subject: STORM-1738 - Add autocorrect functionality Ported with owner permission from Firestorm, inital work done by LordGregGreg Back --- indra/llui/lllineeditor.cpp | 57 + indra/llui/lllineeditor.h | 1 + indra/newview/CMakeLists.txt | 4 + indra/newview/app_settings/settings.xml | 33 + .../newview/app_settings/settings_autocorrect.xml | 8369 ++++++++++++++++++++ indra/newview/llautocorrect.cpp | 402 + indra/newview/llautocorrect.h | 60 + indra/newview/llautocorrectfloater.cpp | 384 + indra/newview/llautocorrectfloater.h | 67 + indra/newview/llfloaterpreference.cpp | 4 +- indra/newview/llviewerfloaterreg.cpp | 3 +- .../skins/default/xui/en/floater_autocorrect.xml | 83 + .../newview/skins/default/xui/en/notifications.xml | 7 + .../default/xui/en/panel_preferences_chat.xml | 15 +- 14 files changed, 9485 insertions(+), 4 deletions(-) create mode 100644 indra/newview/app_settings/settings_autocorrect.xml create mode 100644 indra/newview/llautocorrect.cpp create mode 100644 indra/newview/llautocorrect.h create mode 100644 indra/newview/llautocorrectfloater.cpp create mode 100644 indra/newview/llautocorrectfloater.h create mode 100644 indra/newview/skins/default/xui/en/floater_autocorrect.xml (limited to 'indra/newview/llviewerfloaterreg.cpp') diff --git a/indra/llui/lllineeditor.cpp b/indra/llui/lllineeditor.cpp index 06dfc90d83..cee84cc53f 100644 --- a/indra/llui/lllineeditor.cpp +++ b/indra/llui/lllineeditor.cpp @@ -51,6 +51,8 @@ #include "lluictrlfactory.h" #include "llclipboard.h" #include "llmenugl.h" +#include "../newview/llautocorrect.h" +#include "../newview/llviewercontrol.h" // // Imported globals @@ -194,7 +196,60 @@ LLLineEditor::~LLLineEditor() // calls onCommit() while LLLineEditor still valid gFocusMgr.releaseFocusIfNeeded( this ); } +void LLLineEditor::autoCorrectText() +{ + static LLCachedControl doAnything(gSavedSettings, "EnableAutoCorrect"); + if( (!mReadOnly) && (doAnything))// && (isDirty())) + { + S32 wordStart = 0; + S32 wordEnd = mCursorPos-1; + //llinfos <<"Checking Word, Cursor is at "< 0) && (' '!=text[wordEnd-1])) + { + wordEnd--; + } + + wordStart=wordEnd; + + while ((wordEnd < (S32)text.length()) && (' '!=text[wordEnd] ) ) + { + wordEnd++; + } + + std::string strLastWord = std::string(text.begin(), text.end()); + std::string lastTypedWord = strLastWord.substr( wordStart, wordEnd-wordStart); + std::string correctedWord( AutoCorrect::getInstance()->replaceWord(lastTypedWord)); + if(correctedWord!=lastTypedWord) + { + LLWString strNew = utf8str_to_wstring( correctedWord ); + LLWString strOld = utf8str_to_wstring( lastTypedWord ); + int nDiff = strNew.size() - strOld.size(); + + //int wordStart = regText.find(lastTypedWord); + text.replace(wordStart,lastTypedWord.length(),strNew); + mText = wstring_to_utf8str(text); + mCursorPos+=nDiff; + } + } + } +} void LLLineEditor::onFocusReceived() { @@ -866,6 +921,8 @@ void LLLineEditor::addChar(const llwchar uni_char) LLUI::reportBadKeystroke(); } + autoCorrectText(); + getWindow()->hideCursorUntilMouseMove(); } diff --git a/indra/llui/lllineeditor.h b/indra/llui/lllineeditor.h index 2518dbe3c7..8dcc801b62 100644 --- a/indra/llui/lllineeditor.h +++ b/indra/llui/lllineeditor.h @@ -169,6 +169,7 @@ public: virtual BOOL setTextArg( const std::string& key, const LLStringExplicit& text ); virtual BOOL setLabelArg( const std::string& key, const LLStringExplicit& text ); + void autoCorrectText(); void setLabel(const LLStringExplicit &new_label) { mLabel = new_label; } const std::string& getLabel() { return mLabel.getString(); } diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt index 6b2fe1e45a..b43426ad9f 100644 --- a/indra/newview/CMakeLists.txt +++ b/indra/newview/CMakeLists.txt @@ -97,6 +97,8 @@ set(viewer_SOURCE_FILES llassetuploadresponders.cpp llattachmentsmgr.cpp llaudiosourcevo.cpp + llautocorrect.cpp + llautocorrectfloater.cpp llavataractions.cpp llavatariconctrl.cpp llavatarlist.cpp @@ -651,6 +653,8 @@ set(viewer_HEADER_FILES llassetuploadresponders.h llattachmentsmgr.h llaudiosourcevo.h + llautocorrect.h + llautocorrectfloater.h llavataractions.h llavatariconctrl.h llavatarlist.h diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml index aa8ad53a3d..c132cc6ea2 100644 --- a/indra/newview/app_settings/settings.xml +++ b/indra/newview/app_settings/settings.xml @@ -346,6 +346,17 @@ Value 0 + AutoCorrectCount + + Comment + How many words have been auto replaced. + Persist + 1 + Type + S32 + Value + 0 + AutoAcceptNewInventory Comment @@ -1606,6 +1617,17 @@ Value 0 + CmdLineAutocorrect + + Comment + Command for adding new entries to autocorrect + Persist + 1 + Type + String + Value + /addac + CmdLineDisableVoice Comment @@ -2775,6 +2797,17 @@ Value 1 + EnableAutoCorrect + + Comment + Enables or disables the autocorrect function + Persist + 1 + Type + Boolean + Value + 0 + EnableGroupChatPopups Comment diff --git a/indra/newview/app_settings/settings_autocorrect.xml b/indra/newview/app_settings/settings_autocorrect.xml new file mode 100644 index 0000000000..4669ba5822 --- /dev/null +++ b/indra/newview/app_settings/settings_autocorrect.xml @@ -0,0 +1,8369 @@ + + + Custom + + announce + 0 + author + You + data + + enabled + 1 + priority + 10 + wordStyle + 1 + + Abbreviations + + announce + 0 + author + Wulf / TankMaster + data + + afaic + As far as I am concerned + afaik + As far as I know + afk + (Away from Keyboard) + atm + at the moment + bbiab + (Be back in a bit) + bbl + (Be back later) + brb + (Be Right Back) + btw + By the way + fyi + For your information + fwiw + For what its worth + gtg + (Got to go) + idk + I don't know + iirc + If I recall correctly + imho + in my humble opinion + imo + in my opinion + irl + in real life + lol + (Laughing out Loud) + nm + Not much + np + No problem + nsfw + not safe for work + nvm + Nevermind + rofl + (Rolling on Floor Laughing) + tc + Take care + thx + Thanks + ttfn + Ta Ta for now + ttyl + Talk to you later + ty + Thank you + tyvm + Thank you very much + wb + Welcome back + yw + You're Welcome + yvw + You're very welcome + + enabled + 1 + priority + 4 + wordStyle + 1 + + Spelling Corrections + + announce + 0 + author + LordGregGreg / Wikipedia + data + + Amercia + America + Bernouilli + Bernoulli + Blitzkreig + Blitzkrieg + Bonnano + Bonanno + Brasillian + Brazilian + Britian + Britain + Brittish + British + Buddah + Buddha + Buddist + Buddhist + Cambrige + Cambridge + Capetown + Cape Town + Carmalite + Carmelite + Carnagie + Carnegie + Carnagie-Mellon + Carnegie-Mellon + Carnigie + Carnegie + Carnigie-Mellon + Carnegie-Mellon + Carribbean + Caribbean + Carribean + Caribbean + Carthagian + Carthaginian + Cataline + Catiline + Ceasar + Caesar + Celcius + Celsius + Champange + Champagne + Cincinatti + Cincinnati + Cincinnatti + Cincinnati + Conneticut + Connecticut + Dardenelles + Dardanelles + Dravadian + Dravidian + Enlish + English + Europian + European + Europians + Europeans + Eurpean + European + Eurpoean + European + Farenheit + Fahrenheit + Febuary + February + Feburary + February + Flemmish + Flemish + Formalhaut + Fomalhaut + Foundland + Newfoundland + Fransiscan + Franciscan + Fransiscans + Franciscans + Galations + Galatians + Gameboy + Game Boy + Ghandi + Gandhi + Godounov + Godunov + Gothenberg + Gothenburg + Gottleib + Gottlieb + Guaduloupe + Guadalupe + Guadulupe + Guadalupe + Guatamala + Guatemala + Guatamalan + Guatemalan + Guilia + Giulia + Guilio + Giulio + Guiness + Guinness + Guiseppe + Giuseppe + Habsbourg + Habsburg + Hallowean + Halloween + Heidelburg + Heidelberg + Ihaca + Ithaca + Israelies + Israelis + Janurary + January + Januray + January + Japanes + Japanese + Johanine + Johannine + Jospeh + Joseph + Juadaism + Judaism + Juadism + Judaism + Lybia + Libya + Malcom + Malcolm + Massachussets + Massachusetts + Massachussetts + Massachusetts + Mediteranean + Mediterranean + Michagan + Michigan + Misouri + Missouri + Missisipi + Mississippi + Missisippi + Mississippi + Monserrat + Montserrat + Montnana + Montana + Morisette + Morissette + Morrisette + Morissette + Mythraic + Mithraic + Naploeon + Napoleon + Napolean + Napoleon + Napoleonian + Napoleonic + Nazereth + Nazareth + Newyorker + New Yorker + Novermber + November + Nullabour + Nullarbor + Nuremburg + Nuremberg + Palistian + Palestinian + Palistinian + Palestinian + Palistinians + Palestinians + Papanicalou + Papanicolaou + Peloponnes + Peloponnesus + Pennyslvania + Pennsylvania + Pharoah + Pharaoh + Philipines + Philippines + Phillipine + Philippine + Phillipines + Philippines + Phillippines + Philippines + Phonecian + Phoenecian + Portugese + Portuguese + Postdam + Potsdam + Premonasterians + Premonstratensians + Pucini + Puccini + Puertorrican + Puerto Rican + Puertorricans + Puerto Ricans + Queenland + Queensland + Rockerfeller + Rockefeller + Russion + Russian + Sanhedrim + Sanhedrin + Saterday + Saturday + Saterdays + Saturdays + Sionist + Zionist + Sionists + Zionists + Sixtin + Sistine + Skagerak + Skagerrak + Tolkein + Tolkien + Tuscon + Tucson + Ukranian + Ukrainian + UnitesStates + UnitedStates + Yementite + Yemenite + abandonned + abandoned + aberation + aberration + abilties + abilities + abilty + ability + abondon + abandon + abondoned + abandoned + abondoning + abandoning + abondons + abandons + aborigene + aborigine + abortificant + abortifacient + abreviate + abbreviate + abreviated + abbreviated + abreviation + abbreviation + abritrary + arbitrary + absail + abseil + absailing + abseiling + absense + absence + absolutly + absolutely + absorbsion + absorption + absorbtion + absorption + abundacies + abundances + abundancies + abundances + abundunt + abundant + abutts + abuts + acadamy + academy + acadmic + academic + accademic + academic + accademy + academy + acccused + accused + accelleration + acceleration + accension + ascension + acceptence + acceptance + acceptible + acceptable + accessable + accessible + accidentaly + accidentally + accidently + accidentally + acclimitization + acclimatization + accomadate + accommodate + accomadated + accommodated + accomadates + accommodates + accomadating + accommodating + accomadation + accommodation + accomadations + accommodations + accomdate + accommodate + accomodate + accommodate + accomodated + accommodated + accomodates + accommodates + accomodating + accommodating + accomodation + accommodation + accomodations + accommodations + accompanyed + accompanied + accordeon + accordion + accordian + accordion + accoring + according + accoustic + acoustic + accquainted + acquainted + accrediation + accreditation + accredidation + accreditation + accross + across + accussed + accused + acedemic + academic + acheive + achieve + acheived + achieved + acheivement + achievement + acheivements + achievements + acheives + achieves + acheiving + achieving + acheivment + achievement + acheivments + achievements + achievment + achievement + achievments + achievements + achivement + achievement + achivements + achievements + acknowldeged + acknowledged + acknowledgeing + acknowledging + ackward + awkward + acommodate + accommodate + acomplish + accomplish + acomplished + accomplished + acomplishment + accomplishment + acomplishments + accomplishments + acording + according + acordingly + accordingly + acquaintence + acquaintance + acquaintences + acquaintances + acquiantence + acquaintance + acquiantences + acquaintances + acquited + acquitted + activites + activities + activly + actively + actualy + actually + acuracy + accuracy + acused + accused + acustom + accustom + acustommed + accustomed + adavanced + advanced + adbandon + abandon + additinally + additionally + additionaly + additionally + additonal + additional + additonally + additionally + addmission + admission + addopt + adopt + addopted + adopted + addoptive + adoptive + addres + address + addresable + addressable + addresed + addressed + addresing + addressing + addressess + addresses + addtion + addition + addtional + additional + adecuate + adequate + adequit + adequate + adhearing + adhering + adherance + adherence + admendment + amendment + admininistrative + administrative + adminstered + administered + adminstrate + administrate + adminstration + administration + adminstrative + administrative + adminstrator + administrator + admissability + admissibility + admissable + admissible + admited + admitted + admitedly + admittedly + adn + and + adolecent + adolescent + adquire + acquire + adquired + acquired + adquires + acquires + adquiring + acquiring + adres + address + adresable + addressable + adresing + addressing + adress + address + adressable + addressable + adressed + addressed + adressing + addressing + adventrous + adventurous + advertisment + advertisement + advertisments + advertisements + advesary + adversary + adviced + advised + aeriel + aerial + aeriels + aerials + afair + affair + afficianados + aficionados + afficionado + aficionado + afficionados + aficionados + affilate + affiliate + affilliate + affiliate + affort + afford + aforememtioned + aforementioned + againnst + against + agains + against + agaisnt + against + aganist + against + aggaravates + aggravates + aggreed + agreed + aggreement + agreement + aggregious + egregious + aggresive + aggressive + agian + again + agianst + against + agin + again + agina + again + aginst + against + agravate + aggravate + agre + agree + agred + agreed + agreeement + agreement + agreemnt + agreement + agregate + aggregate + agregates + aggregates + agreing + agreeing + agression + aggression + agressive + aggressive + agressively + aggressively + agressor + aggressor + agricuture + agriculture + agrieved + aggrieved + ahev + have + ahppen + happen + ahve + have + aicraft + aircraft + aiport + airport + airbourne + airborne + aircaft + aircraft + aircrafts + aircraft + airporta + airports + airrcraft + aircraft + aisian + asian + albiet + albeit + alchohol + alcohol + alchoholic + alcoholic + alchol + alcohol + alcholic + alcoholic + alcohal + alcohol + alcoholical + alcoholic + aledge + allege + aledged + alleged + aledges + alleges + alege + allege + aleged + alleged + alegience + allegiance + algebraical + algebraic + algorhitms + algorithms + algoritm + algorithm + algoritms + algorithms + alientating + alienating + alledge + allege + alledged + alleged + alledgedly + allegedly + alledges + alleges + allegedely + allegedly + allegedy + allegedly + allegely + allegedly + allegence + allegiance + allegience + allegiance + allign + align + alligned + aligned + alliviate + alleviate + allopone + allophone + allopones + allophones + allready + already + allthough + although + alltime + all-time + alltogether + altogether + almsot + almost + alochol + alcohol + alomst + almost + alot + a lot + alotted + allotted + alowed + allowed + alowing + allowing + alreayd + already + alse + else + alsot + also + alternitives + alternatives + altho + although + althought + although + altough + although + alusion + allusion + alwasy + always + alwyas + always + amalgomated + amalgamated + amatuer + amateur + amature + armature + amendmant + amendment + amerliorate + ameliorate + amke + make + amking + making + ammend + amend + ammended + amended + ammendment + amendment + ammendments + amendments + ammount + amount + ammused + amused + amoung + among + amoungst + amongst + amung + among + amunition + ammunition + analagous + analogous + analitic + analytic + analogeous + analogous + anarchim + anarchism + anarchistm + anarchism + anbd + and + ancestory + ancestry + ancilliary + ancillary + androgenous + androgynous + androgeny + androgyny + anihilation + annihilation + aniversary + anniversary + annoint + anoint + annointed + anointed + annointing + anointing + annoints + anoints + annouced + announced + annualy + annually + annuled + annulled + anohter + another + anomolies + anomalies + anomolous + anomalous + anomoly + anomaly + anonimity + anonymity + anounced + announced + anouncement + announcement + ansalisation + nasalisation + ansalization + nasalization + ansestors + ancestors + antartic + antarctic + anthromorphization + anthropomorphization + anthropolgist + anthropologist + anthropolgy + anthropology + anual + annual + anulled + annulled + anwsered + answered + anyhwere + anywhere + anyother + any other + anytying + anything + aparent + apparent + aparment + apartment + apenines + apennines + aplication + application + aplied + applied + apolegetics + apologetics + apon + apron + apparant + apparent + apparantly + apparently + appart + apart + appartment + apartment + appartments + apartments + appealling + appealing + appeareance + appearance + appearence + appearance + appearences + appearances + apperance + appearance + apperances + appearances + appereance + appearance + appereances + appearances + applicaiton + application + applicaitons + applications + appologies + apologies + appology + apology + apprearance + appearance + apprieciate + appreciate + approachs + approaches + appropiate + appropriate + appropraite + appropriate + appropropiate + appropriate + approproximate + approximate + approxamately + approximately + approxiately + approximately + approximitely + approximately + aprehensive + apprehensive + apropriate + appropriate + aproximate + approximate + aproximately + approximately + aquaduct + aqueduct + aquaintance + acquaintance + aquainted + acquainted + aquiantance + acquaintance + aquire + acquire + aquired + acquired + aquiring + acquiring + aquisition + acquisition + aquitted + acquitted + aranged + arranged + arangement + arrangement + arbitarily + arbitrarily + arbitary + arbitrary + archaelogists + archaeologists + archaelogy + archaeology + archaoelogy + archaeology + archaology + archaeology + archeaologist + archaeologist + archeaologists + archaeologists + archetect + architect + archetects + architects + archetectural + architectural + archetecturally + architecturally + archetecture + architecture + archiac + archaic + archictect + architect + archimedian + archimedean + architecht + architect + architechturally + architecturally + architechture + architecture + architechtures + architectures + architectual + architectural + archtype + archetype + archtypes + archetypes + aready + already + areodynamics + aerodynamics + argubly + arguably + arguement + argument + arguements + arguments + arised + arose + arival + arrival + armamant + armament + armistace + armistice + arogant + arrogant + arogent + arrogant + aroud + around + arrangment + arrangement + arrangments + arrangements + arround + around + artical + article + artice + article + articel + article + artifical + artificial + artifically + artificially + artillary + artillery + arund + around + asetic + ascetic + asfar + as far + asign + assign + aslo + also + asociated + associated + asorbed + absorbed + asphyxation + asphyxiation + assasin + assassin + assasinate + assassinate + assasinated + assassinated + assasinates + assassinates + assasination + assassination + assasinations + assassinations + assasined + assassinated + assasins + assassins + assassintation + assassination + assemple + assemble + assertation + assertion + asside + aside + assisnate + assassinate + assit + assist + assitant + assistant + assocation + association + assoicate + associate + assoicated + associated + assoicates + associates + assosication + assassination + asssassans + assassins + assualt + assault + assualted + assaulted + assymetric + asymmetric + assymetrical + asymmetrical + asteriod + asteroid + asthetic + aesthetic + asthetical + aesthetical + asthetically + aesthetically + asume + assume + aswell + as well + atain + attain + atempting + attempting + atheistical + atheistic + athenean + athenian + atheneans + athenians + athiesm + atheism + athiest + atheist + atorney + attorney + atribute + attribute + atributed + attributed + atributes + attributes + attaindre + attainder + attemp + attempt + attemped + attempted + attemt + attempt + attemted + attempted + attemting + attempting + attemts + attempts + attendence + attendance + attendent + attendant + attendents + attendants + attened + attended + attension + attention + attitide + attitude + attributred + attributed + attrocities + atrocities + audeince + audience + auromated + automated + austrailia + Australia + austrailian + Australian + auther + author + authobiographic + autobiographic + authobiography + autobiography + authorative + authoritative + authorites + authorities + authorithy + authority + authoritiers + authorities + authoritive + authoritative + authrorities + authorities + autochtonous + autochthonous + autoctonous + autochthonous + automaticly + automatically + automibile + automobile + automonomous + autonomous + autor + author + autority + authority + auxilary + auxiliary + auxillaries + auxiliaries + auxillary + auxiliary + auxilliaries + auxiliaries + auxilliary + auxiliary + availabe + available + availablity + availability + availaible + available + availble + available + availiable + available + availible + available + avalable + available + avalance + avalanche + avaliable + available + avation + aviation + avengence + a vengeance + averageed + averaged + avilable + available + awared + awarded + awya + away + baceause + because + backgorund + background + backrounds + backgrounds + bakc + back + banannas + bananas + bandwith + bandwidth + bankrupcy + bankruptcy + banruptcy + bankruptcy + baout + about + basicaly + basically + basicly + basically + bcak + back + beachead + beachhead + beacuse + because + beastiality + bestiality + beatiful + beautiful + beaurocracy + bureaucracy + beaurocratic + bureaucratic + beautyfull + beautiful + becamae + became + becames + becomes + becasue + because + beccause + because + becomeing + becoming + becomming + becoming + becouse + because + becuase + because + bedore + before + befoer + before + beggin + begin + begginer + beginner + begginers + beginners + beggining + beginning + begginings + beginnings + beggins + begins + begining + beginning + beginnig + beginning + behavour + behavior + beleagured + beleaguered + beleif + belief + beleive + believe + beleived + believed + beleives + believes + beleiving + believing + beligum + belgium + belive + believe + belived + believed + belives + believes + belligerant + belligerent + bellweather + bellwether + bemusemnt + bemusement + beneficary + beneficiary + beng + being + benificial + beneficial + benifit + benefit + benifits + benefits + bergamont + bergamot + beseige + besiege + beseiged + besieged + beseiging + besieging + betwen + between + beween + between + bewteen + between + bilateraly + bilaterally + billingualism + bilingualism + binominal + binomial + bizzare + bizarre + blaim + blame + blaimed + blamed + blessure + blessing + bodydbuilder + bodybuilder + bombardement + bombardment + bombarment + bombardment + bondary + boundary + borke + broke + boundry + boundary + bouyancy + buoyancy + bouyant + buoyant + boyant + buoyant + breakthough + breakthrough + breakthroughts + breakthroughs + breif + brief + breifly + briefly + brethen + brethren + bretheren + brethren + briliant + brilliant + brillant + brilliant + brimestone + brimstone + broacasted + broadcast + broadacasting + broadcasting + broady + broadly + buisness + business + buisnessman + businessman + buoancy + buoyancy + burried + buried + busineses + businesses + busness + business + bussiness + business + caculater + calculator + cacuses + caucuses + cahracters + characters + calaber + caliber + calculater + calculator + calculs + calculus + calenders + calendars + caligraphy + calligraphy + caluclate + calculate + caluclated + calculated + caluculate + calculate + caluculated + calculated + calulate + calculate + calulated + calculated + calulater + calculator + camoflage + camouflage + campain + campaign + campains + campaigns + candadate + candidate + candiate + candidate + candidiate + candidate + cannister + canister + cannisters + canisters + cannnot + cannot + cannonical + canonical + cannotation + connotation + cannotations + connotations + cant + can't + caost + coast + caperbility + capability + capible + capable + captial + capital + captued + captured + capturd + captured + carachter + character + caracterized + characterized + carcas + carcass + carefull + careful + careing + caring + carismatic + charismatic + carnege + carnage + carnige + carnage + carniverous + carnivorous + carreer + career + carrers + careers + cartdridge + cartridge + carthographer + cartographer + cartilege + cartilage + cartilidge + cartilage + cartrige + cartridge + casette + cassette + casion + caisson + cassawory + cassowary + cassowarry + cassowary + casulaties + casualties + casulaty + casualty + catagories + categories + catagorized + categorized + catagory + category + catapillar + caterpillar + catapillars + caterpillars + catapiller + caterpillar + catapillers + caterpillars + catepillar + caterpillar + catepillars + caterpillars + catergorize + categorize + catergorized + categorized + caterpilar + caterpillar + caterpilars + caterpillars + caterpiller + caterpillar + caterpillers + caterpillars + cathlic + catholic + catholocism + catholicism + catterpilar + caterpillar + catterpilars + caterpillars + catterpillar + caterpillar + catterpillars + caterpillars + cattleship + battleship + causalities + casualties + cellpading + cellpadding + cementary + cemetery + cemetarey + cemetery + cemetaries + cemeteries + cemetary + cemetery + cencus + census + censur + censor + cententenial + centennial + centruies + centuries + centruy + century + ceratin + certain + cerimonial + ceremonial + cerimonies + ceremonies + cerimonious + ceremonious + cerimony + ceremony + ceromony + ceremony + certainity + certainty + certian + certain + chalenging + challenging + challange + challenge + challanged + challenged + challege + challenge + changable + changeable + charachter + character + charachters + characters + charactersistic + characteristic + charactor + character + charactors + characters + charasmatic + charismatic + charaterized + characterized + chariman + chairman + charistics + characteristics + cheif + chief + cheifs + chiefs + chemcial + chemical + chemcially + chemically + chemestry + chemistry + chemicaly + chemically + childbird + childbirth + childen + children + choosen + chosen + chracter + character + chuch + church + churchs + churches + circulaton + circulation + circumsicion + circumcision + circut + circuit + ciricuit + circuit + ciriculum + curriculum + civillian + civilian + claer + clear + claerer + clearer + claerly + clearly + claimes + claims + clas + class + clasic + classic + clasical + classical + clasically + classically + cleareance + clearance + clera + clear + clincial + clinical + clinicaly + clinically + cmo + com + cmoputer + computer + co-incided + coincided + coctail + cocktail + coform + conform + cognizent + cognizant + coincedentally + coincidentally + colaborations + collaborations + colateral + collateral + colelctive + collective + collaberative + collaborative + collecton + collection + collegue + colleague + collegues + colleagues + collonade + colonnade + collonies + colonies + collony + colony + collosal + colossal + colonizators + colonizers + comander + commander + comando + commando + comandos + commandos + comany + company + comapany + company + comback + comeback + combanations + combinations + combinatins + combinations + combusion + combustion + comdemnation + condemnation + comemmorates + commemorates + comemoretion + commemoration + comision + commission + comisioned + commissioned + comisioner + commissioner + comisioning + commissioning + comisions + commissions + comission + commission + comissioned + commissioned + comissioner + commissioner + comissioning + commissioning + comissions + commissions + comited + committed + comiting + committing + comitted + committed + comittee + committee + comitting + committing + commandoes + commandos + commedic + comedic + commemerative + commemorative + commemmorate + commemorate + commemmorating + commemorating + commerical + commercial + commerically + commercially + commericial + commercial + commericially + commercially + commerorative + commemorative + comming + coming + comminication + communication + commision + commission + commisioned + commissioned + commisioner + commissioner + commisioning + commissioning + commisions + commissions + commited + committed + commitee + committee + commiting + committing + committe + committee + committment + commitment + committments + commitments + commmemorated + commemorated + commongly + commonly + commonweath + commonwealth + commuications + communications + commuinications + communications + communciation + communication + communiation + communication + communites + communities + compability + compatibility + comparision + comparison + comparisions + comparisons + comparitive + comparative + comparitively + comparatively + compatabilities + compatibilities + compatability + compatibility + compatable + compatible + compatablities + compatibilities + compatablity + compatibility + compatiable + compatible + compatiblities + compatibilities + compatiblity + compatibility + compeitions + competitions + compensantion + compensation + competance + competence + competant + competent + competative + competitive + competion + competition + competitiion + competition + competive + competitive + competiveness + competitiveness + comphrehensive + comprehensive + compitent + competent + completedthe + completed the + completelyl + completely + completetion + completion + complier + compiler + componant + component + comprable + comparable + comprimise + compromise + compulsary + compulsory + compulsery + compulsory + computarized + computerized + concensus + consensus + concider + consider + concidered + considered + concidering + considering + conciders + considers + concieted + conceited + concieved + conceived + concious + conscious + conciously + consciously + conciousness + consciousness + condamned + condemned + condemmed + condemned + condidtion + condition + condidtions + conditions + conditionsof + conditions of + conected + connected + conection + connection + conesencus + consensus + confidental + confidential + confidentally + confidentially + confids + confides + configureable + configurable + confortable + comfortable + congradulations + congratulations + congresional + congressional + conived + connived + conjecutre + conjecture + conjuction + conjunction + conotations + connotations + conquerd + conquered + conquerer + conqueror + conquerers + conquerors + conqured + conquered + conscent + consent + consciouness + consciousness + consdider + consider + consdidered + considered + consdiered + considered + consectutive + consecutive + consenquently + consequently + consentrate + concentrate + consentrated + concentrated + consentrates + concentrates + consept + concept + consequentually + consequently + consequeseces + consequences + consern + concern + conserned + concerned + conserning + concerning + conservitive + conservative + consiciousness + consciousness + consicousness + consciousness + considerd + considered + consideres + considered + consious + conscious + consistant + consistent + consistantly + consistently + consituencies + constituencies + consituency + constituency + consituted + constituted + consitution + constitution + consitutional + constitutional + consolodate + consolidate + consolodated + consolidated + consonent + consonant + consonents + consonants + consorcium + consortium + conspiracys + conspiracies + conspiriator + conspirator + constaints + constraints + constanly + constantly + constarnation + consternation + constatn + constant + constinually + continually + constituant + constituent + constituants + constituents + constituion + constitution + constituional + constitutional + consttruction + construction + constuction + construction + consulant + consultant + consumate + consummate + consumated + consummated + contaiminate + contaminate + containes + contains + contamporaries + contemporaries + contamporary + contemporary + contempoary + contemporary + contemporaneus + contemporaneous + contempory + contemporary + contendor + contender + contibute + contribute + contibuted + contributed + contibutes + contributes + contigent + contingent + contined + continued + continous + continuous + continously + continuously + continueing + continuing + contravercial + controversial + contraversy + controversy + contributer + contributor + contributers + contributors + contritutions + contributions + controled + controlled + controling + controlling + controll + control + controlls + controls + controvercial + controversial + controvercy + controversy + controveries + controversies + controversal + controversial + controversey + controversy + controvertial + controversial + controvery + controversy + contruction + construction + conveinent + convenient + convenant + covenant + convential + conventional + convertables + convertibles + convertion + conversion + conveyer + conveyor + conviced + convinced + convienient + convenient + coordiantion + coordination + coorperations + corporations + copmetitors + competitors + coputer + computer + copywrite + copyright + coridal + cordial + cornmitted + committed + corosion + corrosion + corparate + corporate + corperations + corporations + correcters + correctors + correponding + corresponding + correposding + corresponding + correspondant + correspondent + correspondants + correspondents + corridoors + corridors + corrispond + correspond + corrispondant + correspondent + corrispondants + correspondents + corrisponded + corresponded + corrisponding + corresponding + corrisponds + corresponds + costitution + constitution + coucil + council + counries + countries + countains + contains + countires + countries + coururier + courier + coverted + converted + cpoy + copy + creaeted + created + creedence + credence + critereon + criterion + criterias + criteria + criticists + critics + critising + criticising + critisising + criticising + critisism + criticism + critisisms + criticisms + critisize + criticise + critisized + criticised + critisizes + criticises + critisizing + criticising + critized + criticized + critizing + criticizing + crockodiles + crocodiles + crowm + crown + crtical + critical + crticised + criticised + crucifiction + crucifixion + crusies + cruises + crystalisation + crystallisation + culiminating + culminating + cumulatative + cumulative + curch + church + curcuit + circuit + currenly + currently + curriculem + curriculum + cxan + cyan + cyclinder + cylinder + dacquiri + daiquiri + dael + deal + dalmation + dalmatian + damenor + demeanor + dammage + damage + daugher + daughter + debateable + debatable + decendant + descendant + decendants + descendants + decendent + descendant + decendents + descendants + decideable + decidable + decidely + decidedly + decieved + deceived + decison + decision + decomissioned + decommissioned + decomposit + decompose + decomposited + decomposed + decompositing + decomposing + decomposits + decomposes + decress + decrees + decribe + describe + decribed + described + decribes + describes + decribing + describing + dectect + detect + defendent + defendant + defendents + defendants + deffensively + defensively + deffine + define + deffined + defined + definance + defiance + definate + definite + definately + definitely + definatly + definitely + definetly + definitely + definining + defining + definit + definite + definitly + definitely + definiton + definition + defintion + definition + degrate + degrade + delagates + delegates + delapidated + dilapidated + delerious + delirious + delevopment + development + deliberatly + deliberately + delusionally + delusively + demenor + demeanor + demographical + demographic + demolision + demolition + demorcracy + democracy + demostration + demonstration + denegrating + denigrating + densly + densely + deparment + department + deparmental + departmental + deparments + departments + dependance + dependence + dependancy + dependency + dependant + dependent + deram + dream + deriviated + derived + derivitive + derivative + derogitory + derogatory + descendands + descendants + descibed + described + descision + decision + descisions + decisions + descriibes + describes + descripters + descriptors + descripton + description + desctruction + destruction + descuss + discuss + desgined + designed + deside + decide + desigining + designing + desinations + destinations + desintegrated + disintegrated + desintegration + disintegration + desireable + desirable + desitned + destined + desktiop + desktop + desorder + disorder + desoriented + disoriented + desparate + desperate + despict + depict + despiration + desperation + dessicated + desiccated + dessigned + designed + destablized + destabilized + destory + destroy + detailled + detailed + detatched + detached + deteoriated + deteriorated + deteriate + deteriorate + deterioriating + deteriorating + determinining + determining + detremental + detrimental + devasted + devastated + develope + develop + developement + development + developped + developed + develpment + development + devels + delves + devestated + devastated + devestating + devastating + devide + divide + devided + divided + devistating + devastating + devolopement + development + diablical + diabolical + diamons + diamonds + diaster + disaster + dichtomy + dichotomy + diconnects + disconnects + dicover + discover + dicovered + discovered + dicovering + discovering + dicovers + discovers + dicovery + discovery + dicussed + discussed + didnt + didn't + diea + idea + dieing + dying + dieties + deities + diety + deity + diferent + different + diferrent + different + differentiatiations + differentiations + differnt + different + difficulity + difficulty + diffrent + different + dificulties + difficulties + dificulty + difficulty + dimenions + dimensions + dimention + dimension + dimentional + dimensional + dimentions + dimensions + dimesnional + dimensional + diminuitive + diminutive + dimunitive + diminutive + diosese + diocese + diphtong + diphthong + diphtongs + diphthongs + diplomancy + diplomacy + dipthong + diphthong + dipthongs + diphthongs + dirived + derived + disagreeed + disagreed + disapeared + disappeared + disapointing + disappointing + disappearred + disappeared + disaproval + disapproval + disasterous + disastrous + disatisfaction + dissatisfaction + disatisfied + dissatisfied + disatrous + disastrous + discontentment + discontent + discribe + describe + discribed + described + discribes + describes + discribing + describing + disctinction + distinction + disctinctive + distinctive + disemination + dissemination + disenchanged + disenchanted + disiplined + disciplined + disobediance + disobedience + disobediant + disobedient + disolved + dissolved + disover + discover + dispair + despair + disparingly + disparagingly + dispence + dispense + dispenced + dispensed + dispencing + dispensing + dispicable + despicable + dispite + despite + dispostion + disposition + disproportiate + disproportionate + disputandem + disputandum + disricts + districts + dissagreement + disagreement + dissapear + disappear + dissapearance + disappearance + dissapeared + disappeared + dissapearing + disappearing + dissapears + disappears + dissappear + disappear + dissappears + disappears + dissappointed + disappointed + dissarray + disarray + dissobediance + disobedience + dissobediant + disobedient + dissobedience + disobedience + dissobedient + disobedient + distiction + distinction + distingish + distinguish + distingished + distinguished + distingishes + distinguishes + distingishing + distinguishing + distingquished + distinguished + distrubution + distribution + distruction + destruction + distructive + destructive + ditributed + distributed + diversed + diverged + divice + device + divison + division + divisons + divisions + doccument + document + doccumented + documented + doccuments + documents + docrines + doctrines + doctines + doctrines + documenatry + documentary + doens + does + doesnt + doesn't + doign + doing + dominaton + domination + dominent + dominant + dominiant + dominant + donig + doing + dont + don't + dosen't + doesn't + doub + doubt + doulbe + double + dowloads + downloads + dramtic + dramatic + draughtman + draughtsman + dreasm + dreams + driectly + directly + drnik + drink + druming + drumming + drummless + drumless + dupicate + duplicate + durig + during + durring + during + duting + during + dyas + dryas + eahc + each + ealier + earlier + earlies + earliest + earnt + earned + ecclectic + eclectic + eceonomy + economy + ecidious + deciduous + eclispe + eclipse + ecomonic + economic + ect + etc + eearly + early + efel + evil + effeciency + efficiency + effecient + efficient + effeciently + efficiently + efficency + efficiency + efficent + efficient + efficently + efficiently + efford + effort + effords + efforts + effulence + effluence + eigth + eight + eiter + either + elction + election + electic + electric + electon + electron + electrial + electrical + electricly + electrically + electricty + electricity + elementay + elementary + eleminated + eliminated + eleminating + eliminating + eles + eels + eletricity + electricity + elicided + elicited + eligable + eligible + elimentary + elementary + ellected + elected + elphant + elephant + embarass + embarrass + embarassed + embarrassed + embarassing + embarrassing + embarassment + embarrassment + embargos + embargoes + embarras + embarrass + embarrased + embarrassed + embarrasing + embarrassing + embarrasment + embarrassment + embezelled + embezzled + emblamatic + emblematic + eminate + emanate + eminated + emanated + emision + emission + emited + emitted + emiting + emitting + emition + emission + emmediately + immediately + emmigrated + immigrated + emminently + eminently + emmisaries + emissaries + emmisarries + emissaries + emmisarry + emissary + emmisary + emissary + emmision + emission + emmisions + emissions + emmited + emitted + emmiting + emitting + emmitted + emitted + emmitting + emitting + emnity + enmity + emperical + empirical + emphaised + emphasised + emphsis + emphasis + emphysyma + emphysema + emprisoned + imprisoned + enameld + enameled + enchancement + enhancement + encouraing + encouraging + encryptiion + encryption + encylopedia + encyclopedia + endevors + endeavors + endevour + endeavour + endig + ending + endolithes + endoliths + enduce + induce + ened + need + enflamed + inflamed + enforceing + enforcing + engagment + engagement + engeneer + engineer + engeneering + engineering + engieneer + engineer + engieneers + engineers + enlargment + enlargement + enlargments + enlargements + enourmous + enormous + enourmously + enormously + ensconsed + ensconced + entaglements + entanglements + enteratinment + entertainment + enthusiatic + enthusiastic + entitity + entity + entitlied + entitled + entrepeneur + entrepreneur + entrepeneurs + entrepreneurs + enviorment + environment + enviormental + environmental + enviormentally + environmentally + enviorments + environments + enviornment + environment + enviornmental + environmental + enviornmentalist + environmentalist + enviornmentally + environmentally + enviornments + environments + enviroment + environment + enviromental + environmental + enviromentalist + environmentalist + enviromentally + environmentally + enviroments + environments + envolutionary + evolutionary + envrionments + environments + enxt + next + epidsodes + episodes + epsiode + episode + equialent + equivalent + equilibium + equilibrium + equilibrum + equilibrium + equiped + equipped + equippment + equipment + equitorial + equatorial + equivelant + equivalent + equivelent + equivalent + equivilant + equivalent + equivilent + equivalent + equivlalent + equivalent + erally + really + eratic + erratic + eratically + erratically + eraticly + erratically + errupted + erupted + esential + essential + esitmated + estimated + esle + else + especialy + especially + essencial + essential + essense + essence + essentail + essential + essentialy + essentially + essentual + essential + essesital + essential + estabishes + establishes + establising + establishing + ethnocentricm + ethnocentrism + ethose + those + evenhtually + eventually + eventally + eventually + eventhough + even though + eventially + eventually + eventualy + eventually + everthing + everything + everytime + every time + everyting + everything + eveyr + every + evidentally + evidently + exagerate + exaggerate + exagerated + exaggerated + exagerates + exaggerates + exagerating + exaggerating + exagerrate + exaggerate + exagerrated + exaggerated + exagerrates + exaggerates + exagerrating + exaggerating + examinated + examined + exampt + exempt + exapansion + expansion + excact + exact + excange + exchange + excecute + execute + excecuted + executed + excecutes + executes + excecuting + executing + excecution + execution + excedded + exceeded + excelent + excellent + excell + excel + excellance + excellence + excellant + excellent + excells + excels + excercise + exercise + exchanching + exchanging + excisted + existed + exculsivly + exclusively + execising + exercising + exection + execution + exectued + executed + exeedingly + exceedingly + exelent + excellent + exellent + excellent + exemple + example + exept + except + exeptional + exceptional + exerbate + exacerbate + exerbated + exacerbated + exerciese + exercises + exerpt + excerpt + exerpts + excerpts + exersize + exercise + exerternal + external + exhalted + exalted + exhibtion + exhibition + exibition + exhibition + exibitions + exhibitions + exicting + exciting + exinct + extinct + existance + existence + existant + existent + existince + existence + exliled + exiled + exludes + excludes + exmaple + example + exonorate + exonerate + exoskelaton + exoskeleton + expalin + explain + expatriot + expatriate + expeced + expected + expecially + especially + expeditonary + expeditionary + expeiments + experiments + expell + expel + expells + expels + experiance + experience + experianced + experienced + expiditions + expeditions + expierence + experience + explaination + explanation + explaning + explaining + explictly + explicitly + exploititive + exploitative + explotation + exploitation + expropiated + expropriated + expropiation + expropriation + exressed + expressed + extemely + extremely + extention + extension + extentions + extensions + extered + exerted + extermist + extremist + extint + extinct + extradiction + extradition + extraterrestial + extraterrestrial + extraterrestials + extraterrestrials + extravagent + extravagant + extrememly + extremely + extremeophile + extremophile + extremly + extremely + extrordinarily + extraordinarily + extrordinary + extraordinary + eyar + year + eyars + years + eyasr + years + faciliate + facilitate + faciliated + facilitated + faciliates + facilitates + facilites + facilities + facillitate + facilitate + facinated + fascinated + facist + fascist + familes + families + familliar + familiar + famoust + famous + fanatism + fanaticism + fatc + fact + faught + fought + favoutrable + favourable + feasable + feasible + fedreally + federally + feromone + pheromone + fertily + fertility + fianite + finite + fianlly + finally + ficticious + fictitious + fictious + fictitious + fidn + find + fiercly + fiercely + fightings + fighting + filiament + filament + fimilies + families + finacial + financial + finaly + finally + financialy + financially + firends + friends + firts + first + fisionable + fissionable + flamable + flammable + flawess + flawless + fleed + fled + florescent + fluorescent + flourescent + fluorescent + flourine + fluorine + fluorish + flourish + follwoing + following + folowing + following + fomed + formed + fomr + from + fonetic + phonetic + fontrier + fontier + foootball + football + forbad + forbade + forbiden + forbidden + foreward + foreword + forfiet + forfeit + forhead + forehead + foriegn + foreign + formallize + formalize + formallized + formalized + formaly + formally + formelly + formerly + formidible + formidable + formost + foremost + forsaw + foresaw + forseeable + foreseeable + fortelling + foretelling + forunner + forerunner + foucs + focus + foudn + found + fougth + fought + foundaries + foundries + foundary + foundry + fourties + forties + fourty + forty + fouth + fourth + foward + forward + freind + friend + freindly + friendly + frequentily + frequently + frome + from + fromed + formed + froniter + frontier + fucntion + function + fucntioning + functioning + fufill + fulfill + fufilled + fulfilled + fulfiled + fulfilled + fullfill + fulfill + fullfilled + fulfilled + fundametal + fundamental + fundametals + fundamentals + funguses + fungi + funtion + function + furuther + further + futher + further + futhermore + furthermore + galatic + galactic + gallaxies + galaxies + galvinized + galvanized + ganerate + generate + ganes + games + ganster + gangster + garantee + guarantee + garanteed + guaranteed + garantees + guarantees + garnison + garrison + gaurantee + guarantee + gauranteed + guaranteed + gaurantees + guarantees + gaurd + guard + gaurentee + guarantee + gaurenteed + guaranteed + gaurentees + guarantees + geneological + genealogical + geneologies + genealogies + geneology + genealogy + generaly + generally + generatting + generating + genialia + genitalia + geographicial + geographical + geometrician + geometer + geometricians + geometers + gerat + great + glight + flight + gnawwed + gnawed + godess + goddess + godesses + goddesses + gogin + going + goign + going + gonig + going + gouvener + governor + govement + government + govenment + government + govenrment + government + goverance + governance + goverment + government + govermental + governmental + governer + governor + governmnet + government + govorment + government + govormental + governmental + govornment + government + gracefull + graceful + graet + great + grafitti + graffiti + gramatically + grammatically + grammaticaly + grammatically + grammer + grammar + grat + great + gratuitious + gratuitous + greatful + grateful + greatfully + gratefully + greif + grief + gridles + griddles + gropu + group + grwo + grow + guage + gauge + guarentee + guarantee + guarenteed + guaranteed + guarentees + guarantees + guerilla + guerrilla + guerillas + guerrillas + guerrila + guerrilla + guerrilas + guerrillas + guidence + guidance + gunanine + guanine + gurantee + guarantee + guranteed + guaranteed + gurantees + guarantees + guttaral + guttural + gutteral + guttural + habaeus + habeas + habeus + habeas + haemorrage + haemorrhage + haev + have + halp + help + hapen + happen + hapened + happened + hapening + happening + happend + happened + happended + happened + happenned + happened + harased + harassed + harases + harasses + harasment + harassment + harasments + harassments + harassement + harassment + harras + harass + harrased + harassed + harrases + harasses + harrasing + harassing + harrasment + harassment + harrasments + harassments + harrassed + harassed + harrasses + harassed + harrassing + harassing + harrassment + harassment + harrassments + harassments + hasnt + hasn't + haviest + heaviest + headquarer + headquarter + headquater + headquarter + headquatered + headquartered + headquaters + headquarters + healthercare + healthcare + heared + heard + heathy + healthy + heigher + higher + heirarchy + hierarchy + heiroglyphics + hieroglyphics + helment + helmet + helpfull + helpful + helpped + helped + hemmorhage + hemorrhage + herad + heard + heridity + heredity + heroe + hero + heros + heroes + hertiage + heritage + hertzs + hertz + hesistant + hesitant + heterogenous + heterogeneous + hieght + height + hierachical + hierarchical + hierachies + hierarchies + hierachy + hierarchy + hierarcical + hierarchical + hierarcy + hierarchy + hieroglph + hieroglyph + hieroglphs + hieroglyphs + higer + higher + higest + highest + higway + highway + hillarious + hilarious + himselv + himself + hinderance + hindrance + hinderence + hindrance + hindrence + hindrance + hipopotamus + hippopotamus + hismelf + himself + histocompatability + histocompatibility + historicians + historians + hitsingles + hit singles + holliday + holiday + homestate + home state + homogeneize + homogenize + homogeneized + homogenized + honory + honorary + horrifing + horrifying + hosited + hoisted + hospitible + hospitable + hounour + honour + housr + hours + howver + however + hsitorians + historians + hstory + history + hten + then + htere + there + htey + they + htikn + think + hting + thing + htink + think + htis + this + humer + humor + humerous + humorous + huminoid + humanoid + humoural + humoral + humurous + humorous + husban + husband + hvae + have + hvaing + having + hvea + have + hwihc + which + hwile + while + hwole + whole + hydogen + hydrogen + hydropile + hydrophile + hydropilic + hydrophilic + hydropobe + hydrophobe + hydropobic + hydrophobic + hygeine + hygiene + hypocracy + hypocrisy + hypocrasy + hypocrisy + hypocricy + hypocrisy + hypocrit + hypocrite + hypocrits + hypocrites + i + I + iconclastic + iconoclastic + idaeidae + idea + idaes + ideas + idealogies + ideologies + idealogy + ideology + identicial + identical + identifers + identifiers + ideosyncratic + idiosyncratic + idesa + ideas + idiosyncracy + idiosyncrasy + illegimacy + illegitimacy + illegitmate + illegitimate + illess + illness + illiegal + illegal + illution + illusion + ilness + illness + ilogical + illogical + imagenary + imaginary + imagin + imagine + imaginery + imaginary + imcomplete + incomplete + imediately + immediately + imense + immense + immediatley + immediately + immediatly + immediately + immidately + immediately + immidiately + immediately + immitate + imitate + immitated + imitated + immitating + imitating + immitator + imitator + immunosupressant + immunosuppressant + impecabbly + impeccably + impedence + impedance + implamenting + implementing + impliment + implement + implimented + implemented + imploys + employs + importamt + important + imprioned + imprisoned + imprisonned + imprisoned + improvision + improvisation + improvments + improvements + inablility + inability + inaccessable + inaccessible + inadiquate + inadequate + inadquate + inadequate + inadvertant + inadvertent + inadvertantly + inadvertently + inagurated + inaugurated + inaguration + inauguration + inappropiate + inappropriate + inaugures + inaugurates + inbalance + imbalance + inbalanced + imbalanced + inbetween + between + incarcirated + incarcerated + incidentially + incidentally + incidently + incidentally + inclreased + increased + includ + include + includng + including + incompatabilities + incompatibilities + incompatability + incompatibility + incompatable + incompatible + incompatablities + incompatibilities + incompatablity + incompatibility + incompatiblities + incompatibilities + incompatiblity + incompatibility + incompetance + incompetence + incompetant + incompetent + incomptable + incompatible + incomptetent + incompetent + inconsistant + inconsistent + incoroporated + incorporated + incorperation + incorporation + incorportaed + incorporated + incorprates + incorporates + incorruptable + incorruptible + incramentally + incrementally + increadible + incredible + incredable + incredible + inctroduce + introduce + inctroduced + introduced + incuding + including + incunabla + incunabula + indefinately + indefinitely + indefineable + undefinable + indefinitly + indefinitely + indentical + identical + indepedantly + independently + indepedence + independence + independance + independence + independant + independent + independantly + independently + independece + independence + independendet + independent + indespensable + indispensable + indespensible + indispensable + indictement + indictment + indigineous + indigenous + indipendence + independence + indipendent + independent + indipendently + independently + indispensible + indispensable + indisputible + indisputable + indisputibly + indisputably + indite + indict + individualy + individually + indpendent + independent + indpendently + independently + indulgue + indulge + indutrial + industrial + indviduals + individuals + inefficienty + inefficiently + inevatible + inevitable + inevitible + inevitable + inevititably + inevitably + infalability + infallibility + infallable + infallible + infectuous + infectious + infered + inferred + infilitrate + infiltrate + infilitrated + infiltrated + infilitration + infiltration + infinit + infinite + inflamation + inflammation + influencial + influential + influented + influenced + infomation + information + informtion + information + infrantryman + infantryman + infrigement + infringement + ingenius + ingenious + ingreediants + ingredients + inhabitans + inhabitants + inherantly + inherently + inheritence + inheritance + inital + initial + initally + initially + initation + initiation + initiaitive + initiative + inlcuding + including + inmigrant + immigrant + inmigrants + immigrants + innoculated + inoculated + inocence + innocence + inofficial + unofficial + inot + into + inpeach + impeach + inpolite + impolite + inprisonment + imprisonment + inproving + improving + insectiverous + insectivorous + insensative + insensitive + inseperable + inseparable + insistance + insistence + insitution + institution + insitutions + institutions + inspite + in spite + instade + instead + instatance + instance + institue + institute + instuction + instruction + instuments + instruments + instutionalized + institutionalized + instutions + intuitions + insurence + insurance + intelectual + intellectual + inteligence + intelligence + inteligent + intelligent + intenational + international + intented + intended + intepretation + interpretation + intepretator + interpretor + interational + international + interbread + interbreed + interchangable + interchangeable + interchangably + interchangeably + intercontinetal + intercontinental + intered + interred + interelated + interrelated + interferance + interference + interfereing + interfering + intergrated + integrated + intergration + integration + interm + interim + internation + international + interpet + interpret + interrim + interim + interrugum + interregnum + intertaining + entertaining + interupt + interrupt + intervines + intervenes + intevene + intervene + intial + initial + intially + initially + intrduced + introduced + intrest + interest + introdued + introduced + intruduced + introduced + intrument + instrument + intrumental + instrumental + intruments + instruments + intrusted + entrusted + intutive + intuitive + intutively + intuitively + inudstry + industry + inventer + inventor + invertibrates + invertebrates + investingate + investigate + involvment + involvement + irelevent + irrelevant + iresistable + irresistible + iresistably + irresistibly + iresistible + irresistible + iresistibly + irresistibly + iritable + irritable + iritated + irritated + ironicly + ironically + irregardless + regardless + irrelevent + irrelevant + irreplacable + irreplaceable + irresistable + irresistible + irresistably + irresistibly + isnt + isn't + issueing + issuing + itnroduced + introduced + iunior + junior + iwll + will + iwth + with + jaques + jacques + jeapardy + jeopardy + jewllery + jewellery + jouney + journey + journied + journeyed + journies + journeys + jstu + just + jsut + just + judical + judicial + judisuary + judiciary + juducial + judicial + juristiction + jurisdiction + juristictions + jurisdictions + kindergarden + kindergarten + klenex + kleenex + knifes + knives + knive + knife + knowlege + knowledge + knowlegeable + knowledgeable + knwo + know + knwos + knows + konw + know + konws + knows + kwno + know + labatory + laboratory + labratory + laboratory + laguage + language + laguages + languages + larg + large + largst + largest + larrry + larry + lastr + last + lattitude + latitude + launhed + launched + lavae + larvae + layed + laid + lazyness + laziness + leage + league + leanr + learn + leathal + lethal + lefted + left + legitamate + legitimate + legitmate + legitimate + leibnitz + leibniz + lenght + length + leran + learn + lerans + learns + leutenant + lieutenant + levetate + levitate + levetated + levitated + levetates + levitates + levetating + levitating + levle + level + liasion + liaison + liason + liaison + liasons + liaisons + libary + library + libell + libel + libguistic + linguistic + libguistics + linguistics + libitarianisn + libertarianism + lieing + lying + liek + like + liekd + liked + liesure + leisure + lieuenant + lieutenant + lieved + lived + liftime + lifetime + lightyear + light year + lightyears + light years + likelyhood + likelihood + linnaena + linnaean + lippizaner + lipizzaner + liquify + liquefy + liscense + license + lisence + license + lisense + license + listners + listeners + litature + literature + literaly + literally + literture + literature + littel + little + litterally + literally + liuke + like + livley + lively + lmits + limits + loev + love + lonelyness + loneliness + longitudonal + longitudinal + lonley + lonely + lonly + lonely + loosing + losing + lotharingen + lothringen + lsat + last + lukid + likud + lveo + love + lvoe + love + maching + machine + mackeral + mackerel + magasine + magazine + magincian + magician + magnificient + magnificent + magolia + magnolia + mailny + mainly + maintainance + maintenance + maintainence + maintenance + maintance + maintenance + maintenence + maintenance + maintinaing + maintaining + maintioned + mentioned + majoroty + majority + maked + marked + makse + makes + maltesian + Maltese + mamal + mammal + mamalian + mammalian + managable + manageable + managment + management + maneouvre + manoeuvre + maneouvred + manoeuvred + maneouvres + manoeuvres + maneouvring + manoeuvring + manisfestations + manifestations + manoeuverability + maneuverability + manouver + maneuver + manouverability + maneuverability + manouverable + maneuverable + manouvers + maneuvers + mantained + maintained + manuever + maneuver + manuevers + maneuvers + manufacturedd + manufactured + manufature + manufacture + manufatured + manufactured + manufaturing + manufacturing + manuver + maneuver + mariage + marriage + marjority + majority + markes + marks + marketting + marketing + marmelade + marmalade + marrage + marriage + marraige + marriage + marrtyred + martyred + marryied + married + massmedia + mass media + masterbation + masturbation + mataphysical + metaphysical + materalists + materialist + mathamatics + mathematics + mathematican + mathematician + mathematicas + mathematics + matheticians + mathematicians + mathmatically + mathematically + mathmatician + mathematician + mathmaticians + mathematicians + mccarthyst + mccarthyist + mchanics + mechanics + meaninng + meaning + mear + wear + mechandise + merchandise + medacine + medicine + medeival + medieval + medevial + medieval + mediciney + mediciny + medievel + medieval + mediterainnean + mediterranean + meerkrat + meerkat + melieux + milieux + membranaphone + membranophone + memeber + member + menally + mentally + meranda + Miranda + mercentile + mercantile + messanger + messenger + messenging + messaging + metalic + metallic + metalurgic + metallurgic + metalurgical + metallurgical + metalurgy + metallurgy + metamorphysis + metamorphosis + metaphoricial + metaphorical + meterologist + meteorologist + meterology + meteorology + methaphor + metaphor + methaphors + metaphors + micoscopy + microscopy + midwifes + midwives + mileau + milieu + milennia + millennia + milennium + millennium + mileu + milieu + miliary + military + milion + million + miliraty + military + millenia + millennia + millenial + millennial + millenialism + millennialism + millenium + millennium + millepede + millipede + millioniare + millionaire + millitary + military + millon + million + miltary + military + minature + miniature + minerial + mineral + miniscule + minuscule + ministery + ministry + minstries + ministries + minstry + ministry + minumum + minimum + mirrorred + mirrored + miscelaneous + miscellaneous + miscellanious + miscellaneous + miscellanous + miscellaneous + mischeivous + mischievous + mischevious + mischievous + mischievious + mischievous + misdameanor + misdemeanor + misdameanors + misdemeanors + misdemenor + misdemeanor + misdemenors + misdemeanors + misfourtunes + misfortunes + misile + missile + mispell + misspell + mispelled + misspelled + mispelling + misspelling + missen + mizzen + missle + missile + missonary + missionary + misterious + mysterious + mistery + mystery + misteryous + mysterious + mkae + make + mkaes + makes + mkaing + making + mkea + make + moderm + modem + modle + model + moent + moment + moeny + money + mohammedans + muslims + moil + soil + moleclues + molecules + momento + memento + monestaries + monasteries + monestary + monastery + monickers + monikers + monolite + monolithic + montains + mountains + montanous + mountainous + monts + months + montypic + monotypic + moreso + more so + morgage + mortgage + morroccan + moroccan + morrocco + morocco + morroco + morocco + mortage + mortgage + mosture + moisture + motiviated + motivated + mounth + month + movei + movie + movment + movement + mroe + more + mucuous + mucous + muder + murder + mudering + murdering + muhammadan + muslim + multicultralism + multiculturalism + multipled + multiplied + multiplers + multipliers + munbers + numbers + muncipalities + municipalities + muncipality + municipality + munnicipality + municipality + muscels + muscles + muscial + musical + muscician + musician + muscicians + musicians + mutiliated + mutilated + myraid + myriad + mysef + myself + mysogynist + misogynist + mysogyny + misogyny + mysterous + mysterious + naieve + naive + naturaly + naturally + naturely + naturally + naturual + natural + naturually + naturally + neccesarily + necessarily + neccesary + necessary + neccessarily + necessarily + neccessary + necessary + neccessities + necessities + necesarily + necessarily + necesary + necessary + necessiate + necessitate + neglible + negligible + negligable + negligible + negociate + negotiate + negociation + negotiation + negociations + negotiations + negotation + negotiation + neice + niece + neigborhood + neighborhood + neigbour + neighbour + neigbourhood + neighbourhood + neolitic + neolithic + nessasarily + necessarily + nessecary + necessary + nestin + nesting + neverthless + nevertheless + newletters + newsletters + nickle + nickel + nightfa;; + nightfall + nightime + nighttime + nineth + ninth + ninteenth + nineteenth + ninties + 1990s + ninty + ninety + nkow + know + nkwo + know + nmae + name + noncombatents + noncombatants + nonsence + nonsense + nontheless + nonetheless + noone + no one + norhern + northern + northen + northern + northereastern + northeastern + notabley + notably + noteable + notable + noteably + notably + noteriety + notoriety + noth + north + nothern + northern + noticable + noticeable + noticably + noticeably + noticeing + noticing + noticible + noticeable + notwhithstanding + notwithstanding + noveau + nouveau + nowdays + nowadays + nowe + now + nto + not + nucular + nuclear + nuculear + nuclear + nuisanse + nuisance + numberous + numerous + nusance + nuisance + nutritent + nutrient + nutritents + nutrients + nuturing + nurturing + obediance + obedience + obediant + obedient + obession + obsession + obssessed + obsessed + obstacal + obstacle + obstancles + obstacles + obstruced + obstructed + ocasion + occasion + ocasional + occasional + ocasionally + occasionally + ocasionaly + occasionally + ocasioned + occasioned + ocasions + occasions + ocassion + occasion + ocassional + occasional + ocassionally + occasionally + ocassionaly + occasionally + ocassioned + occasioned + ocassions + occasions + occaison + occasion + occassion + occasion + occassional + occasional + occassionally + occasionally + occassionaly + occasionally + occassioned + occasioned + occassions + occasions + occationally + occasionally + occour + occur + occurance + occurrence + occurances + occurrences + occured + occurred + occurence + occurrence + occurences + occurrences + occuring + occurring + occurr + occur + occurrance + occurrence + occurrances + occurrences + octohedra + octahedra + octohedral + octahedral + octohedron + octahedron + ocuntries + countries + ocuntry + country + ocurr + occur + ocurrance + occurrence + ocurred + occurred + ocurrence + occurrence + offcers + officers + offcially + officially + offereings + offerings + offical + official + offically + officially + officals + officials + officaly + officially + officialy + officially + offred + offered + oftenly + often + oging + going + omision + omission + omited + omitted + omiting + omitting + omlette + omelette + ommision + omission + ommited + omitted + ommiting + omitting + ommitted + omitted + ommitting + omitting + omniverous + omnivorous + omniverously + omnivorously + omre + more + onot + note + onxy + onyx + onyl + only + openess + openness + oponent + opponent + oportunity + opportunity + opose + oppose + oposite + opposite + oposition + opposition + oppenly + openly + oppinion + opinion + opponant + opponent + oppononent + opponent + oppositition + opposition + oppossed + opposed + opprotunity + opportunity + opression + oppression + opressive + oppressive + opthalmic + ophthalmic + opthalmologist + ophthalmologist + opthalmology + ophthalmology + opthamologist + ophthalmologist + optmizations + optimizations + optomism + optimism + orded + ordered + organim + organism + organistion + organisation + organiztion + organization + orgin + origin + orginal + original + orginally + originally + orginize + organise + oridinarily + ordinarily + origanaly + originally + originall + original + originaly + originally + originially + originally + originnally + originally + origional + original + orignally + originally + orignially + originally + otehr + other + oublisher + publisher + ouevre + oeuvre + oustanding + outstanding + overshaddowed + overshadowed + overthere + over there + overwelming + overwhelming + overwheliming + overwhelming + owrk + work + owudl + would + oxigen + oxygen + oximoron + oxymoron + p0enis + penis + paide + paid + paitience + patience + palce + place + paleolitic + paleolithic + paliamentarian + parliamentarian + pallete + palette + pamflet + pamphlet + pamplet + pamphlet + pantomine + pantomime + paralel + parallel + paralell + parallel + paralelly + parallelly + paralely + parallelly + parallely + parallelly + paranthesis + parenthesis + paraphenalia + paraphernalia + parellels + parallels + parituclar + particular + parliment + parliament + parrakeets + parakeets + parralel + parallel + parrallel + parallel + parrallell + parallel + parrallelly + parallelly + parrallely + parallelly + partialy + partially + particually + particularly + particualr + particular + particuarly + particularly + particularily + particularly + particulary + particularly + pary + party + pased + passed + pasengers + passengers + passerbys + passersby + pasttime + pastime + pastural + pastoral + paticular + particular + pattented + patented + pavillion + pavilion + payed + paid + pblisher + publisher + pbulisher + publisher + peacefuland + peaceful and + peageant + pageant + peculure + peculiar + pedestrain + pedestrian + peformed + performed + peice + piece + penatly + penalty + penerator + penetrator + penisula + peninsula + penisular + peninsular + penninsula + peninsula + penninsular + peninsular + pennisula + peninsula + pensinula + peninsula + peom + poem + peoms + poems + peopel + people + peotry + poetry + perade + parade + percepted + perceived + percieve + perceive + percieved + perceived + perenially + perennially + perfomance + performance + perfomers + performers + performence + performance + performes + performed + perhasp + perhaps + perheaps + perhaps + perhpas + perhaps + peripathetic + peripatetic + peristent + persistent + perjery + perjury + perjorative + pejorative + permanant + permanent + permenant + permanent + permenantly + permanently + permissable + permissible + perogative + prerogative + peronal + personal + perosnality + personality + perphas + perhaps + perpindicular + perpendicular + perseverence + perseverance + persistance + persistence + persistant + persistent + personel + personnel + personell + personnel + personnell + personnel + persuded + persuaded + persue + pursue + persued + pursued + persuing + pursuing + persuit + pursuit + persuits + pursuits + pertubation + perturbation + pertubations + perturbations + pessiary + pessary + petetion + petition + phenomenom + phenomenon + phenomenonal + phenomenal + phenomenonly + phenomenally + phenomonenon + phenomenon + phenomonon + phenomenon + phenonmena + phenomena + philisopher + philosopher + philisophical + philosophical + philisophy + philosophy + phillosophically + philosophically + philospher + philosopher + philosphies + philosophies + philosphy + philosophy + phongraph + phonograph + phylosophical + philosophical + physicaly + physically + piblisher + publisher + pich + pitch + pilgrimmage + pilgrimage + pilgrimmages + pilgrimages + pinapple + pineapple + pinnaple + pineapple + pinoneered + pioneered + plagarism + plagiarism + planation + plantation + planed + planned + plantiff + plaintiff + plateu + plateau + plausable + plausible + playright + playwright + playwrite + playwright + playwrites + playwrights + pleasent + pleasant + plebicite + plebiscite + plesant + pleasant + poenis + penis + poeoples + peoples + poety + poetry + poisin + poison + polical + political + polinator + pollinator + polinators + pollinators + politican + politician + politicans + politicians + poltical + political + polute + pollute + poluted + polluted + polutes + pollutes + poluting + polluting + polution + pollution + polyphonyic + polyphonic + polysaccaride + polysaccharide + polysaccharid + polysaccharide + pomegranite + pomegranate + pomotion + promotion + poportional + proportional + popoulation + population + popularaty + popularity + populare + popular + populer + popular + portait + portrait + portayed + portrayed + portraing + portraying + portuguease + portuguese + portugues + Portuguese + posess + possess + posessed + possessed + posesses + possesses + posessing + possessing + posession + possession + posessions + possessions + posion + poison + positon + position + possable + possible + possably + possibly + posseses + possesses + possesing + possessing + possesion + possession + possessess + possesses + possibile + possible + possibilty + possibility + possiblility + possibility + possiblilty + possibility + possiblities + possibilities + possiblity + possibility + possition + position + posthomous + posthumous + postion + position + postive + positive + potatos + potatoes + potrait + portrait + potrayed + portrayed + poulations + populations + poverful + powerful + poweful + powerful + powerfull + powerful + ppublisher + publisher + practial + practical + practially + practically + practicaly + practically + practicioner + practitioner + practicioners + practitioners + practicly + practically + practioner + practitioner + practioners + practitioners + prairy + prairie + prarie + prairie + praries + prairies + pratice + practice + preample + preamble + precedessor + predecessor + preceed + precede + preceeded + preceded + preceeding + preceding + preceeds + precedes + precentage + percentage + precice + precise + precisly + precisely + precurser + precursor + predecesors + predecessors + predicatble + predictable + predicitons + predictions + predomiantly + predominately + prefered + preferred + prefering + preferring + preferrably + preferably + pregancies + pregnancies + preiod + period + preliferation + proliferation + premeire + premiere + premeired + premiered + premillenial + premillennial + preminence + preeminence + premission + permission + preocupation + preoccupation + prepair + prepare + prepartion + preparation + prepatory + preparatory + preperation + preparation + preperations + preparations + preriod + period + presedential + presidential + presense + presence + presidenital + presidential + presidental + presidential + presitgious + prestigious + prespective + perspective + prestigeous + prestigious + prestigous + prestigious + presumabely + presumably + presumibly + presumably + pretection + protection + prevelant + prevalent + preverse + perverse + previvous + previous + pricipal + principal + priciple + principle + priestood + priesthood + primarly + primarily + primative + primitive + primatively + primitively + primatives + primitives + primordal + primordial + priveledges + privileges + privelege + privilege + priveleged + privileged + priveleges + privileges + privelige + privilege + priveliged + privileged + priveliges + privileges + privelleges + privileges + privilage + privilege + priviledge + privilege + priviledges + privileges + privledge + privilege + privte + private + probabilaty + probability + probablistic + probabilistic + probablly + probably + probalibity + probability + probaly + probably + probelm + problem + proccess + process + proccessing + processing + procede + proceed + proceded + proceeded + procedes + proceeds + procedger + procedure + proceding + proceeding + procedings + proceedings + proceedure + procedure + proces + process + processer + processor + proclaimation + proclamation + proclamed + proclaimed + proclaming + proclaiming + proclomation + proclamation + profesion + profession + profesor + professor + professer + professor + proffesed + professed + proffesion + profession + proffesional + professional + proffesor + professor + profilic + prolific + progessed + progressed + programable + programmable + progrom + program + progroms + programs + prohabition + prohibition + prologomena + prolegomena + prominance + prominence + prominant + prominent + prominantly + prominently + prominately + prominently + promiscous + promiscuous + promotted + promoted + pronomial + pronominal + pronouced + pronounced + pronounched + pronounced + pronounciation + pronunciation + proove + prove + prooved + proved + prophacy + prophecy + propietary + proprietary + propmted + prompted + propoganda + propaganda + propogate + propagate + propogates + propagates + propogation + propagation + propostion + proposition + propotions + proportions + propper + proper + propperly + properly + proprietory + proprietary + proseletyzing + proselytizing + protaganist + protagonist + protaganists + protagonists + protocal + protocol + protoganist + protagonist + protrayed + portrayed + protruberance + protuberance + protruberances + protuberances + prouncements + pronouncements + provacative + provocative + provded + provided + provicial + provincial + provinicial + provincial + provisiosn + provision + provisonal + provisional + proximty + proximity + pseudononymous + pseudonymous + pseudonyn + pseudonym + psuedo + pseudo + psycology + psychology + psyhic + psychic + pubilsher + publisher + pubisher + publisher + publiaher + publisher + publically + publicly + publicaly + publicly + publicher + publisher + publihser + publisher + publisehr + publisher + publiser + publisher + publisger + publisher + publisheed + published + publisherr + publisher + publishher + publisher + publishor + publisher + publishre + publisher + publissher + publisher + publlisher + publisher + publsiher + publisher + publusher + publisher + puchasing + purchasing + pulisher + publisher + pumkin + pumpkin + puplisher + publisher + puritannical + puritanical + purposedly + purposely + purpotedly + purportedly + pursuade + persuade + pursuaded + persuaded + pursuades + persuades + pususading + persuading + puting + putting + pwoer + power + pyscic + psychic + qtuie + quiet + quantaty + quantity + quantitiy + quantity + quarantaine + quarantine + questonable + questionable + quicklyu + quickly + quinessential + quintessential + quitted + quit + quizes + quizzes + qutie + quiet + rabinnical + rabbinical + racaus + raucous + radiactive + radioactive + radify + ratify + raelly + really + rarified + rarefied + reaccurring + recurring + reacing + reaching + reacll + recall + readmition + readmission + realitvely + relatively + realsitic + realistic + realtions + relations + realy + really + realyl + really + reasearch + research + rebiulding + rebuilding + rebllions + rebellions + rebounce + rebound + reccomend + recommend + reccomendations + recommendations + reccomended + recommended + reccomending + recommending + reccommend + recommend + reccommended + recommended + reccommending + recommending + reccuring + recurring + receeded + receded + receeding + receding + receivedfrom + received from + recepient + recipient + recepients + recipients + receving + receiving + rechargable + rechargeable + reched + reached + recide + reside + recided + resided + recident + resident + recidents + residents + reciding + residing + reciepents + recipients + reciept + receipt + recieve + receive + recieved + received + reciever + receiver + recievers + receivers + recieves + receives + recieving + receiving + recipiant + recipient + recipiants + recipients + recived + received + recivership + receivership + recogise + recognise + recogize + recognize + recomend + recommend + recomended + recommended + recomending + recommending + recomends + recommends + recommedations + recommendations + reconaissance + reconnaissance + reconcilation + reconciliation + reconized + recognized + reconnaisance + reconnaissance + reconnaissence + reconnaissance + recontructed + reconstructed + recordproducer + record producer + recquired + required + recrational + recreational + recrod + record + recuiting + recruiting + recuring + recurring + recurrance + recurrence + rediculous + ridiculous + reedeming + redeeming + reenforced + reinforced + refect + reflect + refedendum + referendum + referal + referral + referece + reference + refereces + references + refered + referred + referemce + reference + referemces + references + referencs + references + referenece + reference + refereneced + referenced + refereneces + references + referiang + referring + refering + referring + refernce + references + refernces + references + referrence + reference + referrences + references + referrs + refers + reffered + referred + refference + reference + reffering + referring + refrence + reference + refrences + references + refrers + refers + refridgeration + refrigeration + refridgerator + refrigerator + refromist + reformist + refusla + refusal + regardes + regards + regluar + regular + reguarly + regularly + regulaion + regulation + regulaotrs + regulators + regularily + regularly + rehersal + rehearsal + reicarnation + reincarnation + reigining + reigning + reknown + renown + reknowned + renowned + rela + real + relaly + really + relatiopnship + relationship + relativly + relatively + relected + reelected + releive + relieve + releived + relieved + releiver + reliever + releses + releases + relevence + relevance + relevent + relevant + reliablity + reliability + relient + reliant + religeous + religious + religous + religious + religously + religiously + relinqushment + relinquishment + relitavely + relatively + relized + realized + relpacement + replacement + remaing + remaining + remeber + remember + rememberable + memorable + rememberance + remembrance + remembrence + remembrance + remenant + remnant + remenicent + reminiscent + reminent + remnant + reminescent + reminiscent + reminscent + reminiscent + reminsicent + reminiscent + rendevous + rendezvous + rendezous + rendezvous + renedered + rende + renewl + renewal + rennovate + renovate + rennovated + renovated + rennovating + renovating + rennovation + renovation + rentors + renters + reoccurrence + recurrence + reorganision + reorganisation + repatition + repetition + repectively + respectively + repeition + repetition + repentence + repentance + repentent + repentant + repeteadly + repeatedly + repetion + repetition + repid + rapid + reponse + response + reponsible + responsible + reportadly + reportedly + represantative + representative + representive + representative + representives + representatives + reproducable + reproducible + reprtoire + repertoire + repsectively + respectively + reptition + repetition + requirment + requirement + requred + required + resaurant + restaurant + resembelance + resemblance + resembes + resembles + resemblence + resemblance + resevoir + reservoir + residental + residential + resignement + resignment + resistable + resistible + resistence + resistance + resistent + resistant + respectivly + respectively + responce + response + responibilities + responsibilities + responisble + responsible + responnsibilty + responsibility + responsability + responsibility + responsibile + responsible + responsibilites + responsibilities + responsiblities + responsibilities + responsiblity + responsibility + ressemblance + resemblance + ressemble + resemble + ressembled + resembled + ressemblence + resemblance + ressembling + resembling + resssurecting + resurrecting + ressurect + resurrect + ressurected + resurrected + ressurection + resurrection + ressurrection + resurrection + restarant + restaurant + restarants + restaurants + restaraunt + restaurant + restaraunteur + restaurateur + restaraunteurs + restaurateurs + restaraunts + restaurants + restauranteurs + restaurateurs + restauration + restoration + restauraunt + restaurant + resteraunt + restaurant + resteraunts + restaurants + resticted + restricted + restraunt + restraint + resturant + restaurant + resturants + restaurants + resturaunt + restaurant + resturaunts + restaurants + resurecting + resurrecting + retalitated + retaliated + retalitation + retaliation + retreive + retrieve + returnd + returned + revaluated + reevaluated + reveiw + review + reveral + reversal + reversable + reversible + revolutionar + revolutionary + rewitten + rewritten + rewriet + rewrite + rference + reference + rferences + references + rhymme + rhyme + rhythem + rhythm + rhythim + rhythm + rhytmic + rhythmic + rigourous + rigorous + rininging + ringing + rised + rose + rococco + rococo + rocord + record + roomate + roommate + rougly + roughly + rucuperate + recuperate + rudimentatry + rudimentary + rulle + rule + runing + running + runnung + running + russina + Russian + rwite + write + rythem + rhythm + rythim + rhythm + rythm + rhythm + rythmic + rhythmic + rythyms + rhythms + sacrafice + sacrifice + sacreligious + sacrilegious + sacrifical + sacrificial + saftey + safety + safty + safety + salery + salary + sanctionning + sanctioning + sandwhich + sandwich + santioned + sanctioned + sargant + sergeant + sargeant + sergeant + satelite + satellite + satelites + satellites + satisfactority + satisfactorily + satric + satiric + satrical + satirical + satrically + satirically + sattelite + satellite + sattelites + satellites + saught + sought + saveing + saving + saxaphone + saxophone + scaleable + scalable + scandanavia + Scandinavia + scaricity + scarcity + scavanged + scavenged + schedual + schedule + scholarhip + scholarship + scholarstic + scholastic + scientfic + scientific + scientifc + scientific + scientis + scientist + scince + science + scinece + science + scirpt + script + scoll + scroll + screenwrighter + screenwriter + scrutinity + scrutiny + scuptures + sculptures + seach + search + seached + searched + seaches + searches + secratary + secretary + secretery + secretary + sedereal + sidereal + seeked + sought + segementation + segmentation + seguoys + segues + seige + siege + seing + seeing + seinor + senior + seldomly + seldom + senarios + scenarios + senstive + sensitive + sensure + censure + seperate + separate + seperated + separated + seperately + separately + seperates + separates + seperating + separating + seperation + separation + seperatism + separatism + seperatist + separatist + sepina + subpoena + sergent + sergeant + settelement + settlement + settlment + settlement + severeal + several + severley + severely + severly + severely + sevice + service + shadasloo + shadaloo + shaddow + shadow + shadoloo + shadaloo + shamen + shaman + sheat + sheath + sheild + shield + sherif + sheriff + shineing + shining + shiped + shipped + shiping + shipping + shopkeeepers + shopkeepers + shorly + shortly + shortwhile + short while + shoudl + should + shoudln + shouldn't + shouldnt + shouldn't + shreak + shriek + shrinked + shrunk + sicne + since + sideral + sidereal + siezure + seizure + siezures + seizures + siginificant + significant + signficant + significant + signficiant + significant + signfies + signifies + signifantly + significantly + significently + significantly + signifigant + significant + signifigantly + significantly + signitories + signatories + signitory + signatory + similarily + similarly + similiar + similar + similiarity + similarity + similiarly + similarly + simmilar + similar + simpley + simply + simplier + simpler + simultanous + simultaneous + simultanously + simultaneously + sincerley + sincerely + singsog + singsong + sinse + since + skateing + skating + slaugterhouses + slaughterhouses + slighly + slightly + slowy + slowly + smae + same + smealting + smelting + smoe + some + sneeks + sneaks + snese + sneeze + socalism + socialism + socities + societies + soem + some + sofware + software + sohw + show + soilders + soldiers + solatary + solitary + soley + solely + soliders + soldiers + soliliquy + soliloquy + soluable + soluble + somene + someone + somtimes + sometimes + somwhere + somewhere + sophicated + sophisticated + sophmore + sophomore + sorceror + sorcerer + sorrounding + surrounding + sotry + story + sotyr + story + soudn + sound + soudns + sounds + sould + could + sountrack + soundtrack + sourth + south + sourthern + southern + souvenier + souvenir + souveniers + souvenirs + soveits + soviets + sovereignity + sovereignty + soverign + sovereign + soverignity + sovereignty + soverignty + sovereignty + spainish + Spanish + speach + speech + specfic + specific + speciallized + specialized + specifiying + specifying + speciman + specimen + spectauclar + spectacular + spectaulars + spectaculars + spectum + spectrum + speices + species + spendour + splendour + spermatozoan + spermatozoon + spoace + space + sponser + sponsor + sponsered + sponsored + spontanous + spontaneous + sponzored + sponsored + spoonfulls + spoonfuls + sppeches + speeches + spreaded + spread + sprech + speech + spred + spread + spriritual + spiritual + spritual + spiritual + sqaure + square + stablility + stability + stainlees + stainless + staion + station + standars + standards + stange + strange + startegic + strategic + startegies + strategies + startegy + strategy + stateman + statesman + statememts + statements + statment + statement + steriods + steroids + sterotypes + stereotypes + stilus + stylus + stingent + stringent + stiring + stirring + stirrs + stirs + stlye + style + stomache + stomach + stong + strong + stopry + story + storeis + stories + storise + stories + stornegst + strongest + stoyr + story + stpo + stop + stradegies + strategies + stradegy + strategy + strat + start + stratagically + strategically + streemlining + streamlining + stregth + strength + strenghen + strengthen + strenghened + strengthened + strenghening + strengthening + strenght + strength + strenghten + strengthen + strenghtened + strengthened + strenghtening + strengthening + strengtened + strengthened + strenous + strenuous + strictist + strictest + strikely + strikingly + strnad + strand + stroy + story + structual + structural + stubborness + stubbornness + stucture + structure + stuctured + structured + studdy + study + studing + studying + stuggling + struggling + sturcture + structure + subcatagories + subcategories + subcatagory + subcategory + subconsiously + subconsciously + subjudgation + subjugation + submachne + submachine + subpecies + subspecies + subsidary + subsidiary + subsiduary + subsidiary + subsquent + subsequent + subsquently + subsequently + substace + substance + substancial + substantial + substatial + substantial + substituded + substituted + substract + subtract + substracted + subtracted + substracting + subtracting + substraction + subtraction + substracts + subtracts + subtances + substances + subterranian + subterranean + suburburban + suburban + succceeded + succeeded + succcesses + successes + succedded + succeeded + succeded + succeeded + succeds + succeeds + succesful + successful + succesfully + successfully + succesfuly + successfully + succesion + succession + succesive + successive + successfull + successful + successully + successfully + succsess + success + succsessfull + successful + suceed + succeed + suceeded + succeeded + suceeding + succeeding + suceeds + succeeds + sucesful + successful + sucesfully + successfully + sucesfuly + successfully + sucesion + succession + sucess + success + sucesses + successes + sucessful + successful + sucessfull + successful + sucessfully + successfully + sucessfuly + successfully + sucession + succession + sucessive + successive + sucessor + successor + sucessot + successor + sucide + suicide + sucidial + suicidal + sufferage + suffrage + sufferred + suffered + sufferring + suffering + sufficent + sufficient + sufficently + sufficiently + sumary + summary + sunglases + sunglasses + suop + soup + superceeded + superseded + superintendant + superintendent + suphisticated + sophisticated + suplimented + supplemented + supose + suppose + suposed + supposed + suposedly + supposedly + suposes + supposes + suposing + supposing + supplamented + supplemented + suppliementing + supplementing + suppoed + supposed + supposingly + supposedly + suppy + supply + supress + suppress + supressed + suppressed + supresses + suppresses + supressing + suppressing + suprise + surprise + suprised + surprised + suprising + surprising + suprisingly + surprisingly + suprize + surprise + suprized + surprised + suprizing + surprising + suprizingly + surprisingly + surfce + surface + surley + surely + suround + surround + surounded + surrounded + surounding + surrounding + suroundings + surroundings + surounds + surrounds + surplanted + supplanted + surpress + suppress + surpressed + suppressed + surprize + surprise + surprized + surprised + surprizing + surprising + surprizingly + surprisingly + surrended + surrendered + surrepetitious + surreptitious + surrepetitiously + surreptitiously + surreptious + surreptitious + surreptiously + surreptitiously + surronded + surrounded + surrouded + surrounded + surrouding + surrounding + surrundering + surrendering + surveilence + surveillance + surveill + surveil + surveyer + surveyor + surviver + survivor + survivers + survivors + survivied + survived + suseptable + susceptible + suseptible + susceptible + suspention + suspension + swaer + swear + swaers + swears + swepth + swept + swiming + swimming + syas + says + symetrical + symmetrical + symetrically + symmetrically + symetry + symmetry + symettric + symmetric + symmetral + symmetric + symmetricaly + symmetrically + synagouge + synagogue + syncronization + synchronization + synonomous + synonymous + synonymns + synonyms + synphony + symphony + syphyllis + syphilis + sypmtoms + symptoms + syrap + syrup + sysmatically + systematically + sytem + system + sytle + style + tabacco + tobacco + tahn + than + taht + that + talekd + talked + targetted + targeted + targetting + targeting + tast + taste + tath + that + tattooes + tattoos + taxanomic + taxonomic + taxanomy + taxonomy + teached + taught + techician + technician + techicians + technicians + techiniques + techniques + technitian + technician + technnology + technology + technolgy + technology + teh + the + tehy + they + telelevision + television + televsion + television + telphony + telephony + temerature + temperature + tempalte + template + tempaltes + templates + temparate + temperate + temperarily + temporarily + temperment + temperament + tempertaure + temperature + temperture + temperature + temprary + temporary + tenacle + tentacle + tenacles + tentacles + tendacy + tendency + tendancies + tendencies + tendancy + tendency + tennisplayer + tennis player + tepmorarily + temporarily + terrestial + terrestrial + terriories + territories + terriory + territory + territorist + terrorist + territoy + territory + terroist + terrorist + testiclular + testicular + tghe + the + thast + that's + theather + theater + theese + these + theif + thief + theives + thieves + themselfs + themselves + themslves + themselves + ther + there + therafter + thereafter + therby + thereby + theri + their + theyre + they're + thgat + that + thge + the + thier + their + thign + thing + thigns + things + thigsn + things + thikn + think + thikning + thinking + thikns + thinks + thiunk + think + thn + then + thna + than + thne + then + thnig + thing + thnigs + things + thoughout + throughout + threatend + threatened + threatning + threatening + threee + three + threshhold + threshold + thrid + third + throrough + thorough + throughly + thoroughly + throught + throat + througout + throughout + thru + through + thsi + this + thsoe + those + thta + that + thyat + that + tiem + time + tihkn + think + tihs + this + timne + time + tiome + time + tje + the + tjhe + the + tjpanishad + upanishad + tkae + take + tkaes + takes + tkaing + taking + tlaking + talking + tobbaco + tobacco + todays + today's + todya + today + toghether + together + toke + took + tolerence + tolerance + tomatos + tomatoes + tommorow + tomorrow + tommorrow + tomorrow + tongiht + tonight + toriodal + toroidal + tormenters + tormentors + tornadoe + tornado + torpeados + torpedoes + torpedos + torpedoes + tothe + to the + toubles + troubles + tounge + tongue + tourch + torch + towords + towards + towrad + toward + tradionally + traditionally + traditionaly + traditionally + traditionnal + traditional + traditition + tradition + tradtionally + traditionally + trafficed + trafficked + trafficing + trafficking + trafic + traffic + trancendent + transcendent + trancending + transcending + tranform + transform + tranformed + transformed + transcendance + transcendence + transcendant + transcendent + transcendentational + transcendental + transcripting + transcribing + transending + transcending + transesxuals + transsexuals + transfered + transferred + transfering + transferring + transformaton + transformation + transistion + transition + translater + translator + translaters + translators + transmissable + transmissible + transporation + transportation + tremelo + tremolo + tremelos + tremolos + triguered + triggered + triology + trilogy + troling + trolling + troup + troupe + troups + troops + truely + truly + trustworthyness + trustworthiness + turnk + trunk + tust + trust + twelth + twelfth + twon + town + twpo + two + tyhat + that + tyhe + they + typcial + typical + typicaly + typically + tyranies + tyrannies + tyrany + tyranny + tyrranies + tyrannies + tyrrany + tyranny + ubiquitious + ubiquitous + ublisher + publisher + uise + use + ultimely + ultimately + unacompanied + unaccompanied + unahppy + unhappy + unanymous + unanimous + unathorised + unauthorised + unavailible + unavailable + unballance + unbalance + unbeknowst + unbeknownst + unbeleivable + unbelievable + uncertainity + uncertainty + unchallengable + unchallengeable + unchangable + unchangeable + uncompetive + uncompetitive + unconcious + unconscious + unconciousness + unconsciousness + unconfortability + discomfort + uncontitutional + unconstitutional + unconvential + unconventional + undecideable + undecidable + understoon + understood + undesireable + undesirable + undetecable + undetectable + undoubtely + undoubtedly + undreground + underground + uneccesary + unnecessary + unecessary + unnecessary + unequalities + inequalities + unforetunately + unfortunately + unforgetable + unforgettable + unforgiveable + unforgivable + unfortunatley + unfortunately + unfortunatly + unfortunately + unfourtunately + unfortunately + unihabited + uninhabited + unilateraly + unilaterally + unilatreal + unilateral + unilatreally + unilaterally + uninterruped + uninterrupted + uninterupted + uninterrupted + univeral + universal + univeristies + universities + univeristy + university + univerity + university + universtiy + university + univesities + universities + univesity + university + unkown + unknown + unlikey + unlikely + unmanouverable + unmaneuverable + unmistakeably + unmistakably + unneccesarily + unnecessarily + unneccesary + unnecessary + unneccessarily + unnecessarily + unneccessary + unnecessary + unnecesarily + unnecessarily + unnecesary + unnecessary + unoffical + unofficial + unoperational + nonoperational + unoticeable + unnoticeable + unplease + displease + unplesant + unpleasant + unprecendented + unprecedented + unprecidented + unprecedented + unrepentent + unrepentant + unrepetant + unrepentant + unrepetent + unrepentant + unsed + unused + unsubstanciated + unsubstantiated + unsuccesful + unsuccessful + unsuccesfully + unsuccessfully + unsuccessfull + unsuccessful + unsucesful + unsuccessful + unsucesfuly + unsuccessfully + unsucessful + unsuccessful + unsucessfull + unsuccessful + unsucessfully + unsuccessfully + unsuprised + unsurprised + unsuprising + unsurprising + unsuprisingly + unsurprisingly + unsuprized + unsurprised + unsuprizing + unsurprising + unsuprizingly + unsurprisingly + unsurprized + unsurprised + unsurprizing + unsurprising + unsurprizingly + unsurprisingly + untill + until + untranslateable + untranslatable + unuseable + unusable + unusuable + unusable + unviersity + university + unwarrented + unwarranted + unweildly + unwieldy + unwieldly + unwieldy + upcomming + upcoming + upgradded + upgraded + upto + up to + usally + usually + useage + usage + usefull + useful + usefuly + usefully + useing + using + usualy + usually + ususally + usually + vaccum + vacuum + vaccume + vacuum + vacinity + vicinity + vaguaries + vagaries + vaieties + varieties + vailidty + validity + valetta + valletta + valuble + valuable + valueable + valuable + varations + variations + varient + variant + variey + variety + varing + varying + varities + varieties + varity + variety + vasall + vassal + vasalls + vassals + vegatarian + vegetarian + vegitable + vegetable + vegitables + vegetables + vegtable + vegetable + vehicule + vehicle + vell + well + venemous + venomous + vengance + vengeance + vengence + vengeance + verfication + verification + verison + version + verisons + versions + vermillion + vermilion + versitilaty + versatility + versitlity + versatility + vetween + between + veyr + very + vigeur + vigor + vigilence + vigilance + vigourous + vigorous + villian + villain + villification + vilification + villify + vilify + villin + villain + vincinity + vicinity + violentce + violence + virtualy + virtually + virutal + virtual + virutally + virtually + visable + visible + visably + visibly + visting + visiting + vistors + visitors + vitories + victories + volcanoe + volcano + voleyball + volleyball + volontary + voluntary + volonteer + volunteer + volonteered + volunteered + volonteering + volunteering + volonteers + volunteers + volounteer + volunteer + volounteered + volunteered + volounteering + volunteering + volounteers + volunteers + volumne + volume + vreity + variety + vrey + very + vriety + variety + vulnerablility + vulnerability + vyer + very + vyre + very + waht + what + wanna + want to + warantee + warranty + wardobe + wardrobe + warrent + warrant + warrriors + warriors + wasnt + wasn't + wass + was + watn + want + wayword + wayward + weaponary + weaponry + weas + was + wehn + when + weild + wield + weilded + wielded + wendsay + Wednesday + wensday + Wednesday + wereabouts + whereabouts + whant + want + whants + wants + whcih + which + wheras + whereas + wherease + whereas + whereever + wherever + whic + which + whihc + which + whith + with + whlch + which + whn + when + wholey + wholly + wholy + holy + whta + what + whther + whether + wich + which + widesread + widespread + wief + wife + wierd + weird + wiew + view + wih + with + wiht + with + wille + will + willingless + willingness + wirting + writing + withdrawl + withdrawal + witheld + withheld + withh + with + withing + within + withold + withhold + witht + with + witn + with + wiull + will + wnat + want + wnated + wanted + wnats + wants + wohle + whole + wokr + work + wokring + working + wonderfull + wonderful + wont + won't + wordlwide + worldwide + workststion + workstation + worls + world + worstened + worsened + woudl + would + wresters + wrestlers + wriet + write + writen + written + wroet + wrote + wrok + work + wroking + working + wtih + with + wupport + support + xenophoby + xenophobia + yaching + yachting + yaer + year + yaerly + yearly + yaers + years + yatch + yacht + yearm + year + yeasr + years + yeild + yield + yeilding + yielding + yera + year + yeras + years + yersa + years + yotube + YouTube + youre + you're + youseff + yousef + youself + yourself + ytou + you + yuo + you + zeebra + zebra + + enabled + 1 + priority + 5 + wordStyle + 1 + + + diff --git a/indra/newview/llautocorrect.cpp b/indra/newview/llautocorrect.cpp new file mode 100644 index 0000000000..08643fea93 --- /dev/null +++ b/indra/newview/llautocorrect.cpp @@ -0,0 +1,402 @@ +/** + * @file llautocorrect.cpp + * @brief Auto Correct Manager + * @copyright Copyright (c) 2011 LordGregGreg Back + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "llviewerprecompiledheaders.h" +#include "llautocorrect.h" +#include "llsdserialize.h" +#include "llboost.h" +#include "llcontrol.h" +#include "llviewercontrol.h" +#include "llnotificationsutil.h" + +AutoCorrect* AutoCorrect::sInstance; + +AutoCorrect::AutoCorrect() +{ + sInstance = this; + sInstance->loadFromDisk(); +} + +AutoCorrect::~AutoCorrect() +{ + sInstance = NULL; +} + +AutoCorrect* AutoCorrect::getInstance() +{ + if(sInstance)return sInstance; + else + { + sInstance = new AutoCorrect(); + return sInstance; + } +} +void AutoCorrect::save() +{ + saveToDisk(mAutoCorrects); +} +std::string AutoCorrect::getFileName() +{ + std::string path=gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, ""); + + if (!path.empty()) + { + path = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, "settings_autocorrect.xml"); + } + return path; +} +std::string AutoCorrect::getDefaultFileName() +{ + std::string path=gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, ""); + + if (!path.empty()) + { + path = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "settings_autocorrect.xml"); + } + return path; +} +LLSD AutoCorrect::exportList(std::string listName) +{ + LLSD toReturn; + if(mAutoCorrects.has(listName)) + { + toReturn["listName"]=listName; + toReturn["data"]=mAutoCorrects[listName]["data"]; + toReturn["author"]=mAutoCorrects[listName]["author"]; + toReturn["wordStyle"]=mAutoCorrects[listName]["wordStyle"]; + toReturn["priority"]=mAutoCorrects[listName]["priority"]; + } + return toReturn; +} +BOOL AutoCorrect::addCorrectionList(LLSD newList) +{ + if(newList.has("listName")) + { + std::string name = newList["listName"]; + //if(!mAutoCorrects.has(name)){ + LLSD newPart; + newPart["data"]=newList["data"]; + newPart["enabled"]=TRUE; + newPart["announce"]=FALSE; + newPart["author"]=newList["author"]; + newPart["wordStyle"]=newList["wordStyle"]; + newPart["priority"]=newList["priority"].asInteger(); + llinfos << "adding new list with settings priority "<fileExists(filename)) + { + std::string defaultName = getDefaultFileName(); + llinfos << " user settings file doesnt exist, going to try and read default one from "<fileExists(defaultName)) + { + LLSD blankllsd; + llifstream file; + file.open(defaultName.c_str()); + if (file.is_open()) + { + LLSDSerialize::fromXMLDocument(blankllsd, file); + } + file.close(); + saveToDisk(blankllsd); + }else + saveToDisk(getExampleLLSD()); + } + else + { + llifstream file; + file.open(filename.c_str()); + if (file.is_open()) + { + LLSDSerialize::fromXML(mAutoCorrects, file); + } + file.close(); + } +} +void AutoCorrect::saveToDisk(LLSD newSettings) +{ + mAutoCorrects=newSettings; + std::string filename=getFileName(); + llofstream file; + file.open(filename.c_str()); + LLSDSerialize::toPrettyXML(mAutoCorrects, file); + file.close(); +} +void AutoCorrect::runTest() +{ + std::string startS("He just abandonned all his abilties"); + std::string endS = replaceWords(startS); + llinfos << "!!! Test of autoreplace; start with "< doAnything(gSavedSettings, "EnableAutoCorrect"); + if(!(doAnything))return currentWord; + //loop through priorities + for(int currentPriority = 10;currentPriority>=0;currentPriority--) + { + LLSD::map_const_iterator loc_it = mAutoCorrects.beginMap(); + LLSD::map_const_iterator loc_end = mAutoCorrects.endMap(); + for ( ; loc_it != loc_end; ++loc_it) + { + const std::string& location = (*loc_it).first; + //llinfos << "location is "< " << replacement.c_str() << llendl; + return replacement; + } + } + } + } + return currentWord; +} +std::string AutoCorrect::replaceWords(std::string words) +{ + static LLCachedControl doAnything(gSavedSettings, "EnableAutoCorrect"); + if(!(doAnything))return words; + //TODO update this function to use the "wordStyle" thing, + //but so far this function is never used, so later + + boost_tokenizer tokens(words, boost::char_separator(" ")); + for (boost_tokenizer::iterator token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter) + { + std::string currentWord(*token_iter); + LLSD::map_const_iterator loc_it = mAutoCorrects.beginMap(); + LLSD::map_const_iterator loc_end = mAutoCorrects.endMap(); + for ( ; loc_it != loc_end; ++loc_it) + { + const std::string& location = (*loc_it).first; + //llinfos << "location is "< " << replacement.c_str() << llendl; + int wordStart = words.find(currentWord); + words.replace(wordStart,currentWord.length(),replacement); + return replaceWords(words);//lol recursion! + } + } + } + return words; +} +BOOL AutoCorrect::addEntryToList(std::string wrong, std::string right, std::string listName) +{ + // *HACK: Make sure the "Custom" list exists, because the design of this + // system prevents us from updating it by changing the original file... + if(mAutoCorrects.has(listName)) + { + mAutoCorrects[listName]["data"][wrong]=right; + return TRUE; + } + else if(listName == "Custom") + { + mAutoCorrects[listName]["announce"] = 0; + mAutoCorrects[listName]["author"] = "You"; + mAutoCorrects[listName]["data"][wrong] = right; + mAutoCorrects[listName]["enabled"] = 1; + mAutoCorrects[listName]["priority"] = 10; + mAutoCorrects[listName]["wordStyle"] = 1; + return TRUE; + } + + return FALSE; +} +BOOL AutoCorrect::removeEntryFromList(std::string wrong, std::string listName) +{ + if(mAutoCorrects.has(listName)) + { + if(mAutoCorrects[listName]["data"].has(wrong)) + { + mAutoCorrects[listName]["data"].erase(wrong); + return TRUE; + } + } + return FALSE; +} + +LLSD AutoCorrect::getExampleLLSD() +{ + LLSD toReturn; + + LLSD listone; + LLSD listtwo; + + LLSD itemOne; + itemOne["wrong"]="wrong1"; + itemOne["right"]="right1"; + listone[0]=itemOne; + + LLSD itemTwo; + itemTwo["wrong"]="wrong2"; + itemTwo["right"]="right2"; + listone[1]=itemTwo; + + toReturn["listOne"]=listone; + + + itemOne["wrong"]="secondwrong1"; + itemOne["right"]="secondright1"; + listone[0]=itemOne; + + itemTwo["wrong"]="secondwrong2"; + itemTwo["right"]="secondright2"; + listone[1]=itemTwo; + + toReturn["listTwo"]=listone; + + return toReturn; +} + diff --git a/indra/newview/llautocorrect.h b/indra/newview/llautocorrect.h new file mode 100644 index 0000000000..ed8e819ca1 --- /dev/null +++ b/indra/newview/llautocorrect.h @@ -0,0 +1,60 @@ +/** + * @file llautocorrect.h + * @brief Auto Correct Manager + * @copyright Copyright (c) 2011 LordGregGreg Back + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +#ifndef AUTO_CORRECT +#define AUTO_CORRECT +class AutoCorrect +{ + AutoCorrect(); + ~AutoCorrect(); + static AutoCorrect* sInstance; +public: + static AutoCorrect* getInstance(); + BOOL addCorrectionList(LLSD newList); + BOOL removeCorrectionList(std::string listName); + BOOL setListEnabled(std::string listName, BOOL enabled); + BOOL setListAnnounceeState(std::string listName, BOOL announce); + BOOL setListPriority(std::string listName, int priority); + BOOL setListStyle(std::string listName, BOOL announce); + std::string replaceWords(std::string words); + std::string replaceWord(std::string currentWord); + BOOL addEntryToList(std::string wrong, std::string right, std::string listName); + BOOL removeEntryFromList(std::string wrong, std::string listName); + BOOL saveListToDisk(std::string listName, std::string fileName); + LLSD exportList(std::string listName); + void runTest(); + LLSD getAutoCorrects(); + LLSD getAutoCorrectEntries(std::string listName); + void save(); + + void loadFromDisk(); + +private: + void saveToDisk(LLSD newSettings); + LLSD getExampleLLSD(); + std::string getFileName(); + std::string getDefaultFileName(); + + LLSD mAutoCorrects; + +}; + + + +#endif diff --git a/indra/newview/llautocorrectfloater.cpp b/indra/newview/llautocorrectfloater.cpp new file mode 100644 index 0000000000..6dca759b02 --- /dev/null +++ b/indra/newview/llautocorrectfloater.cpp @@ -0,0 +1,384 @@ +/** + * @file llautocorrectfloater.cpp + * @brief Auto Correct List floater + * @copyright Copyright (c) 2011 LordGregGreg Back + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "llviewerprecompiledheaders.h" + +#include "llautocorrectfloater.h" + +#include "llagentdata.h" +#include "llcommandhandler.h" +#include "llfloater.h" +#include "lluictrlfactory.h" +#include "llagent.h" +#include "llpanel.h" +#include "llbutton.h" +#include "llcolorswatch.h" +#include "llcombobox.h" +#include "llview.h" +#include "llhttpclient.h" +#include "llbufferstream.h" +#include "llcheckboxctrl.h" +#include "llviewercontrol.h" + +#include "llui.h" +#include "llcontrol.h" +#include "llscrollingpanellist.h" +#include "llautocorrect.h" +#include "llfilepicker.h" +#include "llfile.h" +#include "llsdserialize.h" +//#include "llfloaterchat.h" +#include "llchat.h" +#include "llinventorymodel.h" +#include "llhost.h" +#include "llassetstorage.h" +#include "roles_constants.h" +#include "llviewertexteditor.h" +#include + +#include +#include "llfloaterreg.h" +#include "llinspecttoast.h" +#include "llnotificationhandler.h" +#include "llnotificationmanager.h" + + +AutoCorrectFloater::AutoCorrectFloater(const LLSD& key) : +LLFloater(key) +{ +} +void AutoCorrectFloater::onClose(bool app_quitting) +{ + destroy(); +} + +BOOL AutoCorrectFloater::postBuild(void) +{ + + namesList = getChild("ac_list_name"); + entryList = getChild("ac_list_entry"); + + childSetCommitCallback("ac_enable",onBoxCommitEnabled,this); + + childSetCommitCallback("ac_list_enabled",onEntrySettingChange,this); + childSetCommitCallback("ac_list_show",onEntrySettingChange,this); + childSetCommitCallback("ac_list_style",onEntrySettingChange,this); + childSetCommitCallback("ac_priority",onEntrySettingChange,this); + + + + updateEnabledStuff(); + updateNamesList(); + + + namesList->setCommitOnSelectionChange(TRUE); + childSetCommitCallback("ac_list_name", onSelectName, this); + + childSetAction("ac_deletelist",removeList,this); + childSetAction("ac_rementry",deleteEntry,this); + childSetAction("ac_exportlist",exportList,this); + childSetAction("ac_addentry",addEntry,this); + childSetAction("ac_loadlist",loadList,this); + + return true; +} + +void AutoCorrectFloater::onSelectName(LLUICtrl* ctrl, void* user_data) +{ + if ( user_data ) + { + AutoCorrectFloater* self = ( AutoCorrectFloater* )user_data; + if ( self ) + self->updateItemsList(); + } + +} +void AutoCorrectFloater::updateItemsList() +{ + entryList->deleteAllItems(); + if((namesList->getAllSelected().size())<=0) + { + + updateListControlsEnabled(FALSE); + return; + } + + updateListControlsEnabled(TRUE); + std::string listName= namesList->getFirstSelected()->getColumn(0)->getValue().asString(); + + LLSD listData = AutoCorrect::getInstance()->getAutoCorrectEntries(listName); + childSetValue("ac_list_enabled",listData["enabled"].asBoolean()); + childSetValue("ac_list_style",listData["wordStyle"].asBoolean()); + childSetValue("ac_list_show",listData["announce"].asBoolean()); + childSetValue("ac_text_name",listName); + childSetValue("ac_text_author",listData["author"]); + childSetValue("ac_priority",listData["priority"]); + static LLCachedControl countAuto(gSavedSettings, "AutoCorrectCount"); + childSetValue("ac_stats",(S32)countAuto); + + LLSD autoCorrects = listData["data"]; + LLSD::map_const_iterator loc_it = autoCorrects.beginMap(); + LLSD::map_const_iterator loc_end = autoCorrects.endMap(); + for ( ; loc_it != loc_end; ++loc_it) + { + const std::string& wrong = (*loc_it).first; + const std::string& right = (*loc_it).second; + + //std::string lentry(wrong+"=>"+right); + + LLSD element; + element["id"] = wrong; + LLSD& s_column = element["columns"][0]; + s_column["column"] = "Search"; + s_column["value"] = wrong; + s_column["font"] = "SANSSERIF"; + LLSD& r_column = element["columns"][1]; + r_column["column"] = "Replace"; + r_column["value"] = right; + r_column["font"] = "SANSSERIF"; + + entryList->addElement(element, ADD_BOTTOM); + } + +} +void AutoCorrectFloater::updateNamesList() +{ + namesList->deleteAllItems(); + static LLCachedControl enabledd(gSavedSettings, "EnableAutoCorrect"); + if(!(enabledd)) + { + updateItemsList(); + return; + } + static LLCachedControl countAuto(gSavedSettings, "AutoCorrectCount"); + childSetValue("ac_stats",(S32)countAuto); + LLSD autoCorrects = AutoCorrect::getInstance()->getAutoCorrects(); + LLSD::map_const_iterator loc_it = autoCorrects.beginMap(); + LLSD::map_const_iterator loc_end = autoCorrects.endMap(); + for ( ; loc_it != loc_end; ++loc_it) + { + const std::string& listName = (*loc_it).first; + + LLSD element; + element["id"] = listName; + LLSD& friend_column = element["columns"][0]; + friend_column["column"] = "Entries"; + friend_column["value"] = listName; + //friend_column["font"] = "SANSSERIF"; + const LLSD& loc_map = (*loc_it).second; + if(loc_map["enabled"].asBoolean()) + friend_column["font"] = "SANSSERIF"; + //friend_column["style"] = "BOLD"; + else + friend_column["font"] = "SANSSERIF_SMALL"; + //friend_column["style"] = "NORMAL"; + if(namesList) + namesList->addElement(element, ADD_BOTTOM); + } + updateItemsList(); +} +void AutoCorrectFloater::updateListControlsEnabled(BOOL selected) +{ + + childSetEnabled("ac_text1",selected); + childSetEnabled("ac_text2",selected); + childSetEnabled("ac_text_name",selected); + childSetEnabled("ac_text_author",selected); + childSetEnabled("ac_list_enabled",selected); + childSetEnabled("ac_list_show",selected); + childSetEnabled("ac_list_style",selected); + childSetEnabled("ac_deletelist",selected); + childSetEnabled("ac_exportlist",selected); + childSetEnabled("ac_addentry",selected); + childSetEnabled("ac_rementry",selected); + childSetEnabled("ac_priority",selected); + +} +void AutoCorrectFloater::updateEnabledStuff() +{ + static LLCachedControl enabledd(gSavedSettings, "EnableAutoCorrect"); + if(!(enabledd)) + { + LLCheckBoxCtrl *enBox = getChild("ac_enable"); + enBox->setDisabledColor(LLColor4::red); + getChild("ac_enable")->setEnabledColor(LLColor4(1.0f,0.0f,0.0f,1.0f)); + }else + { + getChild("ac_enable")->setEnabledColor( + LLUIColorTable::instance().getColor( "LabelTextColor" )); + } + + childSetEnabled("ac_list_name",enabledd); + childSetEnabled("ac_list_entry",enabledd); + updateListControlsEnabled(enabledd); + updateNamesList(); + AutoCorrect::getInstance()->save(); + +} +void AutoCorrectFloater::setData(void * data) +{ + //empanel = (LLPanel*)data; +} +void AutoCorrectFloater::onBoxCommitEnabled(LLUICtrl* caller, void* user_data) +{ + if ( user_data ) + { + AutoCorrectFloater* self = ( AutoCorrectFloater* )user_data; + if ( self ) + { + self->updateEnabledStuff(); + } + } +} +void AutoCorrectFloater::onEntrySettingChange(LLUICtrl* caller, void* user_data) +{ + if ( user_data ) + { + AutoCorrectFloater* self = ( AutoCorrectFloater* )user_data; + if ( self ) + { + std::string listName= self->namesList->getFirstSelected()->getColumn(0)->getValue().asString(); + AutoCorrect::getInstance()->setListEnabled(listName,self->childGetValue("ac_list_enabled").asBoolean()); + AutoCorrect::getInstance()->setListAnnounceeState(listName,self->childGetValue("ac_list_show").asBoolean()); + AutoCorrect::getInstance()->setListStyle(listName,self->childGetValue("ac_list_style").asBoolean()); + AutoCorrect::getInstance()->setListPriority(listName,self->childGetValue("ac_priority").asInteger()); + + //sInstance->updateEnabledStuff(); + self->updateItemsList(); + AutoCorrect::getInstance()->save(); + } + } +} +void AutoCorrectFloater::deleteEntry(void* data) +{ + if ( data ) + { + AutoCorrectFloater* self = ( AutoCorrectFloater* )data; + if ( self ) + { + + std::string listName=self->namesList->getFirstSelected()->getColumn(0)->getValue().asString(); + + if((self->entryList->getAllSelected().size())>0) + { + std::string wrong= self->entryList->getFirstSelected()->getColumn(0)->getValue().asString(); + AutoCorrect::getInstance()->removeEntryFromList(wrong,listName); + self->updateItemsList(); + AutoCorrect::getInstance()->save(); + } + } + } +} +void AutoCorrectFloater::loadList(void* data) +{ + LLFilePicker& picker = LLFilePicker::instance(); + + if(!picker.getOpenFile( LLFilePicker::FFLOAD_XML) ) + {return; + } + llifstream file; + file.open(picker.getFirstFile().c_str()); + LLSD blankllsd; + if (file.is_open()) + { + LLSDSerialize::fromXMLDocument(blankllsd, file); + } + file.close(); + gSavedSettings.setBOOL("EnableAutoCorrect",true); + AutoCorrect::getInstance()->addCorrectionList(blankllsd); + if ( data ) + { + AutoCorrectFloater* self = ( AutoCorrectFloater* )data; + if ( self ) + self->updateEnabledStuff(); + } +} +void AutoCorrectFloater::removeList(void* data) +{ + if ( data ) + { + AutoCorrectFloater* self = ( AutoCorrectFloater* )data; + if ( self ) + { + std::string listName= self->namesList->getFirstSelected()->getColumn(0)->getValue().asString(); + AutoCorrect::getInstance()->removeCorrectionList(listName); + self->updateEnabledStuff(); + } + + } +} +void AutoCorrectFloater::exportList(void *data) +{ + if ( data ) + { + AutoCorrectFloater* self = ( AutoCorrectFloater* )data; + if ( self ) + { + std::string listName=self->namesList->getFirstSelected()->getColumn(0)->getValue().asString(); + + LLFilePicker& picker = LLFilePicker::instance(); + + if(!picker.getSaveFile( LLFilePicker::FFSAVE_XML) ) + {return; + } + llofstream file; + file.open(picker.getFirstFile().c_str()); + LLSDSerialize::toPrettyXML(AutoCorrect::getInstance()->exportList(listName), file); + file.close(); + } + + } +} +void AutoCorrectFloater::addEntry(void* data) +{ + if ( data ) + { + AutoCorrectFloater* self = ( AutoCorrectFloater* )data; + if ( self ) + { + std::string listName= self->namesList->getFirstSelected()->getColumn(0)->getValue().asString(); + LLChat chat; + chat.mText ="To add an entry, please type in chat \""+gSavedSettings.getString("CmdLineAutocorrect")+" "+listName+"|wrongWord|rightWord\""; + + chat.mSourceType = CHAT_SOURCE_SYSTEM; + LLSD args; + args["type"] = LLNotificationsUI::NT_NEARBYCHAT; + LLNotificationsUI::LLNotificationManager::instance().onChat(chat, args); + + } + } + +} +AutoCorrectFloater* AutoCorrectFloater::showFloater() +{ + AutoCorrectFloater *floater = dynamic_cast(LLFloaterReg::getInstance("autocorrect")); + if(floater) + { + floater->setVisible(true); + floater->setFrontmost(true); + floater->center(); + return floater; + } + else + { + LL_WARNS("AutoCorrect") << "Can't find floater!" << LL_ENDL; + return NULL; + } +} diff --git a/indra/newview/llautocorrectfloater.h b/indra/newview/llautocorrectfloater.h new file mode 100644 index 0000000000..bec7161d1a --- /dev/null +++ b/indra/newview/llautocorrectfloater.h @@ -0,0 +1,67 @@ +/** + * @file llautocorrectfloater.h + * @brief Auto Correct List floater + * @copyright Copyright (c) 2011 LordGregGreg Back + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AUTOCORRECTFLOATER_H +#define AUTOCORRECTFLOATER_H + +#include "llfloater.h" +#include "llmediactrl.h" +#include "llscrolllistctrl.h" + +#include "llviewerinventory.h" +#include + +class AutoCorrectFloater : +public LLFloater +{ +public: + AutoCorrectFloater(const LLSD& key); + + /*virtual*/ BOOL postBuild(); + /*virtual*/ void onClose(bool app_quitting); + + static AutoCorrectFloater* showFloater(); + + void setData(void * data); + void updateEnabledStuff(); + void updateNamesList(); + void updateListControlsEnabled(BOOL selected); + void updateItemsList(); + + LLScrollListCtrl *namesList; + LLScrollListCtrl *entryList; + //LLPanel * empanel; +private: + //static JCInvDropTarget* mNotecardDropTarget; + static void onBoxCommitEnabled(LLUICtrl* caller, void* user_data); + static void onEntrySettingChange(LLUICtrl* caller, void* user_data); + static void onSelectName(LLUICtrl* caller, void* user_data); + //static void ResponseItemDrop(LLViewerInventoryItem* item); + //static void onNotecardLoadComplete(LLVFS *vfs,const LLUUID& asset_uuid,LLAssetType::EType type,void* user_data, S32 status, LLExtStat ext_status); + + + static void deleteEntry(void* data); + static void addEntry(void* data); + static void exportList(void* data); + static void removeList(void* data); + static void loadList(void* data); +}; + +#endif // AUTOCORRECTFLOATER_H diff --git a/indra/newview/llfloaterpreference.cpp b/indra/newview/llfloaterpreference.cpp index a333989e7e..368d8f1efe 100755 --- a/indra/newview/llfloaterpreference.cpp +++ b/indra/newview/llfloaterpreference.cpp @@ -35,7 +35,7 @@ #include "llfloaterpreference.h" #include "message.h" - +#include "llautocorrectfloater.h" #include "llagent.h" #include "llavatarconstants.h" #include "llcheckboxctrl.h" @@ -354,6 +354,8 @@ LLFloaterPreference::LLFloaterPreference(const LLSD& key) gSavedSettings.getControl("NameTagShowUsernames")->getCommitSignal()->connect(boost::bind(&handleNameTagOptionChanged, _2)); gSavedSettings.getControl("NameTagShowFriends")->getCommitSignal()->connect(boost::bind(&handleNameTagOptionChanged, _2)); gSavedSettings.getControl("UseDisplayNames")->getCommitSignal()->connect(boost::bind(&handleDisplayNamesOptionChanged, _2)); + + mCommitCallbackRegistrar.add("Pref.ShowAC", boost::bind(&AutoCorrectFloater::showFloater)); LLAvatarPropertiesProcessor::getInstance()->addObserver( gAgent.getID(), this ); } diff --git a/indra/newview/llviewerfloaterreg.cpp b/indra/newview/llviewerfloaterreg.cpp index 8406f639df..3d33125b6a 100644 --- a/indra/newview/llviewerfloaterreg.cpp +++ b/indra/newview/llviewerfloaterreg.cpp @@ -30,7 +30,7 @@ #include "llfloaterreg.h" #include "llviewerfloaterreg.h" - +#include "llautocorrectfloater.h" #include "llcompilequeue.h" #include "llcallfloater.h" #include "llfasttimerview.h" @@ -169,6 +169,7 @@ void LLViewerFloaterReg::registerFloaters() LLFloaterReg::add("about_land", "floater_about_land.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("appearance", "floater_my_appearance.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("auction", "floater_auction.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); + LLFloaterReg::add("autocorrect", "floater_autocorrect.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("avatar", "floater_avatar.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("avatar_picker", "floater_avatar_picker.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("avatar_textures", "floater_avatar_textures.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); diff --git a/indra/newview/skins/default/xui/en/floater_autocorrect.xml b/indra/newview/skins/default/xui/en/floater_autocorrect.xml new file mode 100644 index 0000000000..0b8ed1c067 --- /dev/null +++ b/indra/newview/skins/default/xui/en/floater_autocorrect.xml @@ -0,0 +1,83 @@ + + + + - \ No newline at end of file + + -- cgit v1.3 From 125bdb31b05d2d8791f8ec5c3c5000c4d7a54060 Mon Sep 17 00:00:00 2001 From: Todd Stinson Date: Wed, 1 Feb 2012 17:55:49 -0800 Subject: Renaming the pathfinding console to be pathfinding setup. --- indra/newview/CMakeLists.txt | 4 +- indra/newview/llfloaterpathfindingconsole.cpp | 654 -------------------------- indra/newview/llfloaterpathfindingconsole.h | 151 ------ indra/newview/llfloaterpathfindingsetup.cpp | 654 ++++++++++++++++++++++++++ indra/newview/llfloaterpathfindingsetup.h | 151 ++++++ indra/newview/llnavmeshstation.cpp | 2 +- indra/newview/llviewerdisplay.cpp | 2 +- indra/newview/llviewerfloaterreg.cpp | 2 +- indra/newview/llviewerwindow.cpp | 2 +- 9 files changed, 811 insertions(+), 811 deletions(-) delete mode 100644 indra/newview/llfloaterpathfindingconsole.cpp delete mode 100644 indra/newview/llfloaterpathfindingconsole.h create mode 100644 indra/newview/llfloaterpathfindingsetup.cpp create mode 100644 indra/newview/llfloaterpathfindingsetup.h (limited to 'indra/newview/llviewerfloaterreg.cpp') diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt index 2e4c537942..1015aae055 100644 --- a/indra/newview/CMakeLists.txt +++ b/indra/newview/CMakeLists.txt @@ -218,8 +218,8 @@ set(viewer_SOURCE_FILES llfloaterobjectweights.cpp llfloateropenobject.cpp llfloateroutbox.cpp - llfloaterpathfindingconsole.cpp llfloaterpathfindinglinksets.cpp + llfloaterpathfindingsetup.cpp llfloaterpay.cpp llfloaterperms.cpp llfloaterpostprocess.cpp @@ -779,8 +779,8 @@ set(viewer_HEADER_FILES llfloaterobjectweights.h llfloateropenobject.h llfloateroutbox.h - llfloaterpathfindingconsole.h llfloaterpathfindinglinksets.h + llfloaterpathfindingsetup.h llfloaterpay.h llfloaterperms.h llfloaterpostprocess.h diff --git a/indra/newview/llfloaterpathfindingconsole.cpp b/indra/newview/llfloaterpathfindingconsole.cpp deleted file mode 100644 index 50edc55d76..0000000000 --- a/indra/newview/llfloaterpathfindingconsole.cpp +++ /dev/null @@ -1,654 +0,0 @@ -/** -* @file llfloaterpathfindingconsole.cpp -* @author William Todd Stinson -* @brief "Pathfinding console" floater, allowing manipulation of the Havok AI pathfinding settings. -* -* $LicenseInfo:firstyear=2002&license=viewerlgpl$ -* Second Life Viewer Source Code -* Copyright (C) 2010, Linden Research, Inc. -* -* This library is free software; you can redistribute it and/or -* modify it under the terms of the GNU Lesser General Public -* License as published by the Free Software Foundation; -* version 2.1 of the License only. -* -* This library is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -* Lesser General Public License for more details. -* -* You should have received a copy of the GNU Lesser General Public -* License along with this library; if not, write to the Free Software -* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA -* -* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA -* $/LicenseInfo$ -*/ - -#include "llviewerprecompiledheaders.h" -#include "llfloaterpathfindingconsole.h" -#include "llfloaterpathfindinglinksets.h" - -#include "llsd.h" -#include "llagent.h" -#include "llbutton.h" -#include "llradiogroup.h" -#include "llsliderctrl.h" -#include "lllineeditor.h" -#include "lltextbase.h" -#include "lltextvalidate.h" -#include "llnavmeshstation.h" -#include "llviewerregion.h" - -#include "LLPathingLib.h" - -#define XUI_RENDER_OVERLAY_ON_FIXED_PHYSICS_GEOMETRY 1 -#define XUI_RENDER_OVERLAY_ON_ALL_RENDERABLE_GEOMETRY 2 - -#define XUI_PATH_SELECT_NONE 0 -#define XUI_PATH_SELECT_START_POINT 1 -#define XUI_PATH_SELECT_END_POINT 2 - -#define XUI_CHARACTER_TYPE_A 1 -#define XUI_CHARACTER_TYPE_B 2 -#define XUI_CHARACTER_TYPE_C 3 -#define XUI_CHARACTER_TYPE_D 4 - -const int CURRENT_REGION = 99; -const int MAX_OBSERVERS = 10; -//--------------------------------------------------------------------------- -// LLFloaterPathfindingConsole -//--------------------------------------------------------------------------- - -BOOL LLFloaterPathfindingConsole::postBuild() -{ - childSetAction("view_and_edit_linksets", boost::bind(&LLFloaterPathfindingConsole::onViewEditLinksetClicked, this)); - childSetAction("rebuild_navmesh", boost::bind(&LLFloaterPathfindingConsole::onRebuildNavMeshClicked, this)); - childSetAction("refresh_navmesh", boost::bind(&LLFloaterPathfindingConsole::onRefreshNavMeshClicked, this)); - - mShowNavMeshCheckBox = findChild("show_navmesh_overlay"); - llassert(mShowNavMeshCheckBox != NULL); - mShowNavMeshCheckBox->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onShowNavMeshToggle, this)); - - mShowExcludeVolumesCheckBox = findChild("show_exclusion_volumes"); - llassert(mShowExcludeVolumesCheckBox != NULL); - mShowExcludeVolumesCheckBox->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onShowExcludeVolumesToggle, this)); - - mShowPathCheckBox = findChild("show_path"); - llassert(mShowPathCheckBox != NULL); - mShowPathCheckBox->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onShowPathToggle, this)); - - mShowWaterPlaneCheckBox = findChild("show_water_plane"); - llassert(mShowWaterPlaneCheckBox != NULL); - mShowWaterPlaneCheckBox->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onShowWaterPlaneToggle, this)); - - mRegionOverlayDisplayRadioGroup = findChild("region_overlay_display"); - llassert(mRegionOverlayDisplayRadioGroup != NULL); - mRegionOverlayDisplayRadioGroup->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onRegionOverlayDisplaySwitch, this)); - - mPathSelectionRadioGroup = findChild("path_selection"); - llassert(mPathSelectionRadioGroup != NULL); - mPathSelectionRadioGroup ->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onPathSelectionSwitch, this)); - - mCharacterWidthSlider = findChild("character_width"); - llassert(mCharacterWidthSlider != NULL); - mCharacterWidthSlider->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onCharacterWidthSet, this)); - - mCharacterTypeRadioGroup = findChild("character_type"); - llassert(mCharacterTypeRadioGroup != NULL); - mCharacterTypeRadioGroup->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onCharacterTypeSwitch, this)); - - mPathfindingStatus = findChild("pathfinding_status"); - llassert(mPathfindingStatus != NULL); - - mTerrainMaterialA = findChild("terrain_material_a"); - llassert(mTerrainMaterialA != NULL); - mTerrainMaterialA->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onTerrainMaterialASet, this)); - mTerrainMaterialA->setPrevalidate(LLTextValidate::validateFloat); - - mTerrainMaterialB = findChild("terrain_material_b"); - llassert(mTerrainMaterialB != NULL); - mTerrainMaterialB->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onTerrainMaterialBSet, this)); - mTerrainMaterialB->setPrevalidate(LLTextValidate::validateFloat); - - mTerrainMaterialC = findChild("terrain_material_c"); - llassert(mTerrainMaterialC != NULL); - mTerrainMaterialC->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onTerrainMaterialCSet, this)); - mTerrainMaterialC->setPrevalidate(LLTextValidate::validateFloat); - - mTerrainMaterialD = findChild("terrain_material_d"); - llassert(mTerrainMaterialD != NULL); - mTerrainMaterialD->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onTerrainMaterialDSet, this)); - mTerrainMaterialD->setPrevalidate(LLTextValidate::validateFloat); - - return LLFloater::postBuild(); -} - -LLFloaterPathfindingConsole::ERegionOverlayDisplay LLFloaterPathfindingConsole::getRegionOverlayDisplay() const -{ - ERegionOverlayDisplay regionOverlayDisplay; - switch (mRegionOverlayDisplayRadioGroup->getValue().asInteger()) - { - case XUI_RENDER_OVERLAY_ON_FIXED_PHYSICS_GEOMETRY : - regionOverlayDisplay = kRenderOverlayOnFixedPhysicsGeometry; - break; - case XUI_RENDER_OVERLAY_ON_ALL_RENDERABLE_GEOMETRY : - regionOverlayDisplay = kRenderOverlayOnAllRenderableGeometry; - break; - default : - regionOverlayDisplay = kRenderOverlayOnFixedPhysicsGeometry; - llassert(0); - break; - } - - return regionOverlayDisplay; -} - -void LLFloaterPathfindingConsole::setRegionOverlayDisplay(ERegionOverlayDisplay pRegionOverlayDisplay) -{ - LLSD radioGroupValue; - - switch (pRegionOverlayDisplay) - { - case kRenderOverlayOnFixedPhysicsGeometry : - radioGroupValue = XUI_RENDER_OVERLAY_ON_FIXED_PHYSICS_GEOMETRY; - break; - case kRenderOverlayOnAllRenderableGeometry : - radioGroupValue = XUI_RENDER_OVERLAY_ON_ALL_RENDERABLE_GEOMETRY; - break; - default : - radioGroupValue = XUI_RENDER_OVERLAY_ON_FIXED_PHYSICS_GEOMETRY; - llassert(0); - break; - } - - mRegionOverlayDisplayRadioGroup->setValue(radioGroupValue); -} - -LLFloaterPathfindingConsole::EPathSelectionState LLFloaterPathfindingConsole::getPathSelectionState() const -{ - EPathSelectionState pathSelectionState; - - switch (mPathSelectionRadioGroup->getValue().asInteger()) - { - case XUI_PATH_SELECT_START_POINT : - pathSelectionState = kPathSelectStartPoint; - break; - case XUI_PATH_SELECT_END_POINT : - pathSelectionState = kPathSelectEndPoint; - break; - default : - pathSelectionState = kPathSelectNone; - break; - } - - return pathSelectionState; -} - -void LLFloaterPathfindingConsole::setPathSelectionState(EPathSelectionState pPathSelectionState) -{ - LLSD radioGroupValue; - - switch (pPathSelectionState) - { - case kPathSelectStartPoint : - radioGroupValue = XUI_PATH_SELECT_START_POINT; - break; - case kPathSelectEndPoint : - radioGroupValue = XUI_PATH_SELECT_END_POINT; - break; - default : - radioGroupValue = XUI_PATH_SELECT_NONE; - break; - } - - mPathSelectionRadioGroup->setValue(radioGroupValue); -} - -F32 LLFloaterPathfindingConsole::getCharacterWidth() const -{ - return mCharacterWidthSlider->getValueF32(); -} - -void LLFloaterPathfindingConsole::setCharacterWidth(F32 pCharacterWidth) -{ - mCharacterWidthSlider->setValue(LLSD(pCharacterWidth)); -} - -LLFloaterPathfindingConsole::ECharacterType LLFloaterPathfindingConsole::getCharacterType() const -{ - ECharacterType characterType; - - switch (mCharacterTypeRadioGroup->getValue().asInteger()) - { - case XUI_CHARACTER_TYPE_A : - characterType = kCharacterTypeA; - break; - case XUI_CHARACTER_TYPE_B : - characterType = kCharacterTypeB; - break; - case XUI_CHARACTER_TYPE_C : - characterType = kCharacterTypeC; - break; - case XUI_CHARACTER_TYPE_D : - characterType = kCharacterTypeD; - break; - default : - characterType = kCharacterTypeA; - llassert(0); - break; - } - - return characterType; -} - -void LLFloaterPathfindingConsole::setCharacterType(ECharacterType pCharacterType) -{ - LLSD radioGroupValue; - - switch (pCharacterType) - { - case kCharacterTypeA : - radioGroupValue = XUI_CHARACTER_TYPE_A; - break; - case kCharacterTypeB : - radioGroupValue = XUI_CHARACTER_TYPE_B; - break; - case kCharacterTypeC : - radioGroupValue = XUI_CHARACTER_TYPE_C; - break; - case kCharacterTypeD : - radioGroupValue = XUI_CHARACTER_TYPE_D; - break; - default : - radioGroupValue = XUI_CHARACTER_TYPE_A; - llassert(0); - break; - } - - mCharacterTypeRadioGroup->setValue(radioGroupValue); -} - -F32 LLFloaterPathfindingConsole::getTerrainMaterialA() const -{ - return mTerrainMaterialA->getValue().asReal(); -} - -void LLFloaterPathfindingConsole::setTerrainMaterialA(F32 pTerrainMaterial) -{ - mTerrainMaterialA->setValue(LLSD(pTerrainMaterial)); -} - -F32 LLFloaterPathfindingConsole::getTerrainMaterialB() const -{ - return mTerrainMaterialB->getValue().asReal(); -} - -void LLFloaterPathfindingConsole::setTerrainMaterialB(F32 pTerrainMaterial) -{ - mTerrainMaterialB->setValue(LLSD(pTerrainMaterial)); -} - -F32 LLFloaterPathfindingConsole::getTerrainMaterialC() const -{ - return mTerrainMaterialC->getValue().asReal(); -} - -void LLFloaterPathfindingConsole::setTerrainMaterialC(F32 pTerrainMaterial) -{ - mTerrainMaterialC->setValue(LLSD(pTerrainMaterial)); -} - -F32 LLFloaterPathfindingConsole::getTerrainMaterialD() const -{ - return mTerrainMaterialD->getValue().asReal(); -} - -void LLFloaterPathfindingConsole::setTerrainMaterialD(F32 pTerrainMaterial) -{ - mTerrainMaterialD->setValue(LLSD(pTerrainMaterial)); -} - -void LLFloaterPathfindingConsole::setHasNavMeshReceived() -{ - std::string str = getString("navmesh_fetch_complete_available"); - mPathfindingStatus->setText((LLStringExplicit)str); - //check to see if all regions are done loading and they are then stitch the navmeshes together - --mNavMeshCnt; - if ( mNavMeshCnt == 0 ) - { - //LLPathingLib::getInstance()->stitchNavMeshes(); - } -} - -void LLFloaterPathfindingConsole::setHasNoNavMesh() -{ - std::string str = getString("navmesh_fetch_complete_none"); - mPathfindingStatus->setText((LLStringExplicit)str); -} - -LLFloaterPathfindingConsole::LLFloaterPathfindingConsole(const LLSD& pSeed) - : LLFloater(pSeed), - mShowNavMeshCheckBox(NULL), - mShowExcludeVolumesCheckBox(NULL), - mShowPathCheckBox(NULL), - mShowWaterPlaneCheckBox(NULL), - mRegionOverlayDisplayRadioGroup(NULL), - mPathSelectionRadioGroup(NULL), - mCharacterWidthSlider(NULL), - mCharacterTypeRadioGroup(NULL), - mPathfindingStatus(NULL), - mTerrainMaterialA(NULL), - mTerrainMaterialB(NULL), - mTerrainMaterialC(NULL), - mTerrainMaterialD(NULL), - mNavMeshCnt(0), - mHasStartPoint(false), - mHasEndPoint(false) -{ - for (int i=0;isetText((LLStringExplicit)str, styleParams); - llwarns <<"Errror: cannout find pathing library implementation."< regions; - regions.push_back( pCurrentRegion ); - //pCurrentRegion->getNeighboringRegions( regions ); - - std::vector shift; - shift.push_back( CURRENT_REGION ); - //pCurrentRegion->getNeighboringRegionsStatus( shift ); - - //If the navmesh shift ops and the total region counts do not match - use the current region, only. - if ( shift.size() != regions.size() ) - { - shift.clear();regions.clear(); - regions.push_back( pCurrentRegion ); - shift.push_back( CURRENT_REGION ); - } - int regionCnt = regions.size(); - mNavMeshCnt = regionCnt; - for ( int i=0; igetCapability( capability ); - - if ( !url.empty() ) - { - std::string str = getString("navmesh_fetch_inprogress"); - mPathfindingStatus->setText((LLStringExplicit)str); - LLNavMeshStation::getInstance()->setNavMeshDownloadURL( url ); - int dir = shift[i]; - LLNavMeshStation::getInstance()->downloadNavMeshSrc( mNavMeshDownloadObserver[mCurrentMDO].getObserverHandle(), dir ); - ++mCurrentMDO; - } - else - { - --mNavMeshCnt; - std::string str = getString("navmesh_region_not_enabled"); - LLStyle::Params styleParams; - styleParams.color = LLUIColorTable::instance().getColor("DrYellow"); - mPathfindingStatus->setText((LLStringExplicit)str, styleParams); - llinfos<<"Region has does not required caps of type ["<get(); - - LLPathingLib *llPathingLibInstance = LLPathingLib::getInstance(); - if (llPathingLibInstance != NULL) - { - llPathingLibInstance->setRenderNavMesh(checkBoxValue); - } - else - { - mShowNavMeshCheckBox->set(FALSE); - llwarns << "cannot find LLPathingLib instance" << llendl; - } -} - -void LLFloaterPathfindingConsole::onShowExcludeVolumesToggle() -{ - BOOL checkBoxValue = mShowExcludeVolumesCheckBox->get(); - - LLPathingLib *llPathingLibInstance = LLPathingLib::getInstance(); - if (llPathingLibInstance != NULL) - { - llPathingLibInstance->setRenderShapes(checkBoxValue); - } - else - { - mShowExcludeVolumesCheckBox->set(FALSE); - llwarns << "cannot find LLPathingLib instance" << llendl; - } -} - -void LLFloaterPathfindingConsole::onShowPathToggle() -{ - BOOL checkBoxValue = mShowPathCheckBox->get(); - - LLPathingLib *llPathingLibInstance = LLPathingLib::getInstance(); - if (llPathingLibInstance != NULL) - { - llPathingLibInstance->setRenderPath(checkBoxValue); - } - else - { - mShowPathCheckBox->set(FALSE); - llwarns << "cannot find LLPathingLib instance" << llendl; - } -} - -void LLFloaterPathfindingConsole::onShowWaterPlaneToggle() -{ - BOOL checkBoxValue = mShowWaterPlaneCheckBox->get(); - - LLPathingLib *llPathingLibInstance = LLPathingLib::getInstance(); - if (llPathingLibInstance != NULL) - { - llPathingLibInstance->setRenderWaterPlane(checkBoxValue); - } - else - { - mShowWaterPlaneCheckBox->set(FALSE); - llwarns << "cannot find LLPathingLib instance" << llendl; - } - - llwarns << "functionality has not yet been implemented to toggle '" - << mShowWaterPlaneCheckBox->getLabel() << "' to " - << (checkBoxValue ? "ON" : "OFF") << llendl; -} - -void LLFloaterPathfindingConsole::onRegionOverlayDisplaySwitch() -{ - LLPathingLib *llPathingLibInstance = LLPathingLib::getInstance(); - if (llPathingLibInstance != NULL) - { - switch (getRegionOverlayDisplay()) - { - case kRenderOverlayOnFixedPhysicsGeometry : - llPathingLibInstance->setRenderOverlayMode(false); - break; - case kRenderOverlayOnAllRenderableGeometry : - llPathingLibInstance->setRenderOverlayMode(true); - break; - default : - llPathingLibInstance->setRenderOverlayMode(false); - llassert(0); - break; - } - } - else - { - this->setRegionOverlayDisplay(kRenderOverlayOnFixedPhysicsGeometry); - llwarns << "cannot find LLPathingLib instance" << llendl; - } -} - -void LLFloaterPathfindingConsole::onPathSelectionSwitch() -{ - switch (getPathSelectionState()) - { - case kPathSelectNone : - break; - case kPathSelectStartPoint : - break; - case kPathSelectEndPoint : - break; - default : - llassert(0); - break; - } -} - -void LLFloaterPathfindingConsole::onCharacterWidthSet() -{ - generatePath(); -} - -void LLFloaterPathfindingConsole::onCharacterTypeSwitch() -{ - switch (getCharacterType()) - { - case kCharacterTypeA : - llwarns << "functionality has not yet been implemented to toggle '" - << mCharacterTypeRadioGroup->getName() << "' to CharacterTypeA" - << llendl; - break; - case kCharacterTypeB : - llwarns << "functionality has not yet been implemented to toggle '" - << mCharacterTypeRadioGroup->getName() << "' to CharacterTypeB" - << llendl; - break; - case kCharacterTypeC : - llwarns << "functionality has not yet been implemented to toggle '" - << mCharacterTypeRadioGroup->getName() << "' to CharacterTypeC" - << llendl; - break; - case kCharacterTypeD : - llwarns << "functionality has not yet been implemented to toggle '" - << mCharacterTypeRadioGroup->getName() << "' to CharacterTypeD" - << llendl; - break; - default : - llassert(0); - break; - } - -} - -void LLFloaterPathfindingConsole::onViewEditLinksetClicked() -{ - LLFloaterPathfindingLinksets::openLinksetsEditor(); -} - -void LLFloaterPathfindingConsole::onRebuildNavMeshClicked() -{ - llwarns << "functionality has not yet been implemented to handle rebuilding of the navmesh" << llendl; -} - -void LLFloaterPathfindingConsole::onRefreshNavMeshClicked() -{ - llwarns << "functionality has not yet been implemented to handle refreshing of the navmesh" << llendl; -} - -void LLFloaterPathfindingConsole::onTerrainMaterialASet() -{ - F32 terrainMaterial = getTerrainMaterialA(); - llwarns << "functionality has not yet been implemented to setting '" << mTerrainMaterialA->getName() - << "' to value (" << terrainMaterial << ")" << llendl; -} - -void LLFloaterPathfindingConsole::onTerrainMaterialBSet() -{ - F32 terrainMaterial = getTerrainMaterialB(); - llwarns << "functionality has not yet been implemented to setting '" << mTerrainMaterialB->getName() - << "' to value (" << terrainMaterial << ")" << llendl; -} - -void LLFloaterPathfindingConsole::onTerrainMaterialCSet() -{ - F32 terrainMaterial = getTerrainMaterialC(); - llwarns << "functionality has not yet been implemented to setting '" << mTerrainMaterialC->getName() - << "' to value (" << terrainMaterial << ")" << llendl; -} - -void LLFloaterPathfindingConsole::onTerrainMaterialDSet() -{ - F32 terrainMaterial = getTerrainMaterialD(); - llwarns << "functionality has not yet been implemented to setting '" << mTerrainMaterialD->getName() - << "' to value (" << terrainMaterial << ")" << llendl; -} - - -void LLFloaterPathfindingConsole::providePathingData( const LLVector3& point1, const LLVector3& point2 ) -{ - switch (getPathSelectionState()) - { - case kPathSelectNone : - llwarns << "not yet been implemented to toggle '" - << mPathSelectionRadioGroup->getName() << "' to PathSelectNone" - << llendl; - break; - - case kPathSelectStartPoint : - mPathData.mStartPointA = point1; - mPathData.mEndPointA = point2; - mHasStartPoint = true; - break; - - case kPathSelectEndPoint : - mPathData.mStartPointB = point1; - mPathData.mEndPointB = point2; - mHasEndPoint = true; - break; - - default : - llassert(0); - break; - } - - generatePath(); -} - -void LLFloaterPathfindingConsole::generatePath() -{ - if (mHasStartPoint && mHasEndPoint) - { - mPathData.mCharacterWidth = getCharacterWidth(); - LLPathingLib::getInstance()->generatePath(mPathData); - } -} diff --git a/indra/newview/llfloaterpathfindingconsole.h b/indra/newview/llfloaterpathfindingconsole.h deleted file mode 100644 index f62fd9742b..0000000000 --- a/indra/newview/llfloaterpathfindingconsole.h +++ /dev/null @@ -1,151 +0,0 @@ -/** - * @file llfloaterpathfindingconsole.h - * @author William Todd Stinson - * @brief "Pathfinding console" floater, allowing manipulation of the Havok AI pathfinding settings. - * - * $LicenseInfo:firstyear=2002&license=viewerlgpl$ - * Second Life Viewer Source Code - * Copyright (C) 2010, Linden Research, Inc. - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; - * version 2.1 of the License only. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * - * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA - * $/LicenseInfo$ - */ - -#ifndef LL_LLFLOATERPATHFINDINGCONSOLE_H -#define LL_LLFLOATERPATHFINDINGCONSOLE_H - -#include "llfloater.h" -#include "llnavmeshstation.h" -#include "LLPathingLib.h" - -class LLSD; -class LLRadioGroup; -class LLSliderCtrl; -class LLLineEditor; -class LLTextBase; -class LLCheckBoxCtrl; - -class LLFloaterPathfindingConsole -: public LLFloater -{ - friend class LLFloaterReg; - -public: - typedef enum - { - kRenderOverlayOnFixedPhysicsGeometry = 0, - kRenderOverlayOnAllRenderableGeometry = 1 - } ERegionOverlayDisplay; - - typedef enum - { - kPathSelectNone = 0, - kPathSelectStartPoint = 1, - kPathSelectEndPoint = 2 - } EPathSelectionState; - - typedef enum - { - kCharacterTypeA = 0, - kCharacterTypeB = 1, - kCharacterTypeC = 2, - kCharacterTypeD = 3 - } ECharacterType; - - virtual BOOL postBuild(); - //Populates a data packet that is forwarded onto the LLPathingSystem - void providePathingData( const LLVector3& point1, const LLVector3& point2 ); - - ERegionOverlayDisplay getRegionOverlayDisplay() const; - void setRegionOverlayDisplay(ERegionOverlayDisplay pRegionOverlayDisplay); - - EPathSelectionState getPathSelectionState() const; - void setPathSelectionState(EPathSelectionState pPathSelectionState); - - F32 getCharacterWidth() const; - void setCharacterWidth(F32 pCharacterWidth); - - ECharacterType getCharacterType() const; - void setCharacterType(ECharacterType pCharacterType); - - F32 getTerrainMaterialA() const; - void setTerrainMaterialA(F32 pTerrainMaterial); - - F32 getTerrainMaterialB() const; - void setTerrainMaterialB(F32 pTerrainMaterial); - - F32 getTerrainMaterialC() const; - void setTerrainMaterialC(F32 pTerrainMaterial); - - F32 getTerrainMaterialD() const; - void setTerrainMaterialD(F32 pTerrainMaterial); - - void setHasNavMeshReceived(); - void setHasNoNavMesh(); - -protected: - -private: - // Does its own instance management, so clients not allowed - // to allocate or destroy. - LLFloaterPathfindingConsole(const LLSD& pSeed); - virtual ~LLFloaterPathfindingConsole(); - - virtual void onOpen(const LLSD& pKey); - - void onShowNavMeshToggle(); - void onShowExcludeVolumesToggle(); - void onShowPathToggle(); - void onShowWaterPlaneToggle(); - void onRegionOverlayDisplaySwitch(); - void onPathSelectionSwitch(); - void onCharacterWidthSet(); - void onCharacterTypeSwitch(); - void onViewEditLinksetClicked(); - void onRebuildNavMeshClicked(); - void onRefreshNavMeshClicked(); - void onTerrainMaterialASet(); - void onTerrainMaterialBSet(); - void onTerrainMaterialCSet(); - void onTerrainMaterialDSet(); - void generatePath(); - - LLCheckBoxCtrl *mShowNavMeshCheckBox; - LLCheckBoxCtrl *mShowExcludeVolumesCheckBox; - LLCheckBoxCtrl *mShowPathCheckBox; - LLCheckBoxCtrl *mShowWaterPlaneCheckBox; - LLRadioGroup *mRegionOverlayDisplayRadioGroup; - LLRadioGroup *mPathSelectionRadioGroup; - LLSliderCtrl *mCharacterWidthSlider; - LLRadioGroup *mCharacterTypeRadioGroup; - LLTextBase *mPathfindingStatus; - LLLineEditor *mTerrainMaterialA; - LLLineEditor *mTerrainMaterialB; - LLLineEditor *mTerrainMaterialC; - LLLineEditor *mTerrainMaterialD; - - LLNavMeshDownloadObserver mNavMeshDownloadObserver[10]; - int mCurrentMDO; - int mNavMeshCnt; - - //Container that is populated and subsequently submitted to the LLPathingSystem for processing - LLPathingLib::PathingPacket mPathData; - bool mHasStartPoint; - bool mHasEndPoint; -}; - -#endif // LL_LLFLOATERPATHFINDINGCONSOLE_H diff --git a/indra/newview/llfloaterpathfindingsetup.cpp b/indra/newview/llfloaterpathfindingsetup.cpp new file mode 100644 index 0000000000..2fb5129a91 --- /dev/null +++ b/indra/newview/llfloaterpathfindingsetup.cpp @@ -0,0 +1,654 @@ +/** +* @file llfloaterpathfindingconsole.cpp +* @author William Todd Stinson +* @brief "Pathfinding console" floater, allowing manipulation of the Havok AI pathfinding settings. +* +* $LicenseInfo:firstyear=2002&license=viewerlgpl$ +* Second Life Viewer Source Code +* Copyright (C) 2010, Linden Research, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; +* version 2.1 of the License only. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +* +* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA +* $/LicenseInfo$ +*/ + +#include "llviewerprecompiledheaders.h" +#include "llfloaterpathfindingsetup.h" +#include "llfloaterpathfindinglinksets.h" + +#include "llsd.h" +#include "llagent.h" +#include "llbutton.h" +#include "llradiogroup.h" +#include "llsliderctrl.h" +#include "lllineeditor.h" +#include "lltextbase.h" +#include "lltextvalidate.h" +#include "llnavmeshstation.h" +#include "llviewerregion.h" + +#include "LLPathingLib.h" + +#define XUI_RENDER_OVERLAY_ON_FIXED_PHYSICS_GEOMETRY 1 +#define XUI_RENDER_OVERLAY_ON_ALL_RENDERABLE_GEOMETRY 2 + +#define XUI_PATH_SELECT_NONE 0 +#define XUI_PATH_SELECT_START_POINT 1 +#define XUI_PATH_SELECT_END_POINT 2 + +#define XUI_CHARACTER_TYPE_A 1 +#define XUI_CHARACTER_TYPE_B 2 +#define XUI_CHARACTER_TYPE_C 3 +#define XUI_CHARACTER_TYPE_D 4 + +const int CURRENT_REGION = 99; +const int MAX_OBSERVERS = 10; +//--------------------------------------------------------------------------- +// LLFloaterPathfindingConsole +//--------------------------------------------------------------------------- + +BOOL LLFloaterPathfindingConsole::postBuild() +{ + childSetAction("view_and_edit_linksets", boost::bind(&LLFloaterPathfindingConsole::onViewEditLinksetClicked, this)); + childSetAction("rebuild_navmesh", boost::bind(&LLFloaterPathfindingConsole::onRebuildNavMeshClicked, this)); + childSetAction("refresh_navmesh", boost::bind(&LLFloaterPathfindingConsole::onRefreshNavMeshClicked, this)); + + mShowNavMeshCheckBox = findChild("show_navmesh_overlay"); + llassert(mShowNavMeshCheckBox != NULL); + mShowNavMeshCheckBox->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onShowNavMeshToggle, this)); + + mShowExcludeVolumesCheckBox = findChild("show_exclusion_volumes"); + llassert(mShowExcludeVolumesCheckBox != NULL); + mShowExcludeVolumesCheckBox->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onShowExcludeVolumesToggle, this)); + + mShowPathCheckBox = findChild("show_path"); + llassert(mShowPathCheckBox != NULL); + mShowPathCheckBox->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onShowPathToggle, this)); + + mShowWaterPlaneCheckBox = findChild("show_water_plane"); + llassert(mShowWaterPlaneCheckBox != NULL); + mShowWaterPlaneCheckBox->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onShowWaterPlaneToggle, this)); + + mRegionOverlayDisplayRadioGroup = findChild("region_overlay_display"); + llassert(mRegionOverlayDisplayRadioGroup != NULL); + mRegionOverlayDisplayRadioGroup->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onRegionOverlayDisplaySwitch, this)); + + mPathSelectionRadioGroup = findChild("path_selection"); + llassert(mPathSelectionRadioGroup != NULL); + mPathSelectionRadioGroup ->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onPathSelectionSwitch, this)); + + mCharacterWidthSlider = findChild("character_width"); + llassert(mCharacterWidthSlider != NULL); + mCharacterWidthSlider->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onCharacterWidthSet, this)); + + mCharacterTypeRadioGroup = findChild("character_type"); + llassert(mCharacterTypeRadioGroup != NULL); + mCharacterTypeRadioGroup->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onCharacterTypeSwitch, this)); + + mPathfindingStatus = findChild("pathfinding_status"); + llassert(mPathfindingStatus != NULL); + + mTerrainMaterialA = findChild("terrain_material_a"); + llassert(mTerrainMaterialA != NULL); + mTerrainMaterialA->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onTerrainMaterialASet, this)); + mTerrainMaterialA->setPrevalidate(LLTextValidate::validateFloat); + + mTerrainMaterialB = findChild("terrain_material_b"); + llassert(mTerrainMaterialB != NULL); + mTerrainMaterialB->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onTerrainMaterialBSet, this)); + mTerrainMaterialB->setPrevalidate(LLTextValidate::validateFloat); + + mTerrainMaterialC = findChild("terrain_material_c"); + llassert(mTerrainMaterialC != NULL); + mTerrainMaterialC->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onTerrainMaterialCSet, this)); + mTerrainMaterialC->setPrevalidate(LLTextValidate::validateFloat); + + mTerrainMaterialD = findChild("terrain_material_d"); + llassert(mTerrainMaterialD != NULL); + mTerrainMaterialD->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onTerrainMaterialDSet, this)); + mTerrainMaterialD->setPrevalidate(LLTextValidate::validateFloat); + + return LLFloater::postBuild(); +} + +LLFloaterPathfindingConsole::ERegionOverlayDisplay LLFloaterPathfindingConsole::getRegionOverlayDisplay() const +{ + ERegionOverlayDisplay regionOverlayDisplay; + switch (mRegionOverlayDisplayRadioGroup->getValue().asInteger()) + { + case XUI_RENDER_OVERLAY_ON_FIXED_PHYSICS_GEOMETRY : + regionOverlayDisplay = kRenderOverlayOnFixedPhysicsGeometry; + break; + case XUI_RENDER_OVERLAY_ON_ALL_RENDERABLE_GEOMETRY : + regionOverlayDisplay = kRenderOverlayOnAllRenderableGeometry; + break; + default : + regionOverlayDisplay = kRenderOverlayOnFixedPhysicsGeometry; + llassert(0); + break; + } + + return regionOverlayDisplay; +} + +void LLFloaterPathfindingConsole::setRegionOverlayDisplay(ERegionOverlayDisplay pRegionOverlayDisplay) +{ + LLSD radioGroupValue; + + switch (pRegionOverlayDisplay) + { + case kRenderOverlayOnFixedPhysicsGeometry : + radioGroupValue = XUI_RENDER_OVERLAY_ON_FIXED_PHYSICS_GEOMETRY; + break; + case kRenderOverlayOnAllRenderableGeometry : + radioGroupValue = XUI_RENDER_OVERLAY_ON_ALL_RENDERABLE_GEOMETRY; + break; + default : + radioGroupValue = XUI_RENDER_OVERLAY_ON_FIXED_PHYSICS_GEOMETRY; + llassert(0); + break; + } + + mRegionOverlayDisplayRadioGroup->setValue(radioGroupValue); +} + +LLFloaterPathfindingConsole::EPathSelectionState LLFloaterPathfindingConsole::getPathSelectionState() const +{ + EPathSelectionState pathSelectionState; + + switch (mPathSelectionRadioGroup->getValue().asInteger()) + { + case XUI_PATH_SELECT_START_POINT : + pathSelectionState = kPathSelectStartPoint; + break; + case XUI_PATH_SELECT_END_POINT : + pathSelectionState = kPathSelectEndPoint; + break; + default : + pathSelectionState = kPathSelectNone; + break; + } + + return pathSelectionState; +} + +void LLFloaterPathfindingConsole::setPathSelectionState(EPathSelectionState pPathSelectionState) +{ + LLSD radioGroupValue; + + switch (pPathSelectionState) + { + case kPathSelectStartPoint : + radioGroupValue = XUI_PATH_SELECT_START_POINT; + break; + case kPathSelectEndPoint : + radioGroupValue = XUI_PATH_SELECT_END_POINT; + break; + default : + radioGroupValue = XUI_PATH_SELECT_NONE; + break; + } + + mPathSelectionRadioGroup->setValue(radioGroupValue); +} + +F32 LLFloaterPathfindingConsole::getCharacterWidth() const +{ + return mCharacterWidthSlider->getValueF32(); +} + +void LLFloaterPathfindingConsole::setCharacterWidth(F32 pCharacterWidth) +{ + mCharacterWidthSlider->setValue(LLSD(pCharacterWidth)); +} + +LLFloaterPathfindingConsole::ECharacterType LLFloaterPathfindingConsole::getCharacterType() const +{ + ECharacterType characterType; + + switch (mCharacterTypeRadioGroup->getValue().asInteger()) + { + case XUI_CHARACTER_TYPE_A : + characterType = kCharacterTypeA; + break; + case XUI_CHARACTER_TYPE_B : + characterType = kCharacterTypeB; + break; + case XUI_CHARACTER_TYPE_C : + characterType = kCharacterTypeC; + break; + case XUI_CHARACTER_TYPE_D : + characterType = kCharacterTypeD; + break; + default : + characterType = kCharacterTypeA; + llassert(0); + break; + } + + return characterType; +} + +void LLFloaterPathfindingConsole::setCharacterType(ECharacterType pCharacterType) +{ + LLSD radioGroupValue; + + switch (pCharacterType) + { + case kCharacterTypeA : + radioGroupValue = XUI_CHARACTER_TYPE_A; + break; + case kCharacterTypeB : + radioGroupValue = XUI_CHARACTER_TYPE_B; + break; + case kCharacterTypeC : + radioGroupValue = XUI_CHARACTER_TYPE_C; + break; + case kCharacterTypeD : + radioGroupValue = XUI_CHARACTER_TYPE_D; + break; + default : + radioGroupValue = XUI_CHARACTER_TYPE_A; + llassert(0); + break; + } + + mCharacterTypeRadioGroup->setValue(radioGroupValue); +} + +F32 LLFloaterPathfindingConsole::getTerrainMaterialA() const +{ + return mTerrainMaterialA->getValue().asReal(); +} + +void LLFloaterPathfindingConsole::setTerrainMaterialA(F32 pTerrainMaterial) +{ + mTerrainMaterialA->setValue(LLSD(pTerrainMaterial)); +} + +F32 LLFloaterPathfindingConsole::getTerrainMaterialB() const +{ + return mTerrainMaterialB->getValue().asReal(); +} + +void LLFloaterPathfindingConsole::setTerrainMaterialB(F32 pTerrainMaterial) +{ + mTerrainMaterialB->setValue(LLSD(pTerrainMaterial)); +} + +F32 LLFloaterPathfindingConsole::getTerrainMaterialC() const +{ + return mTerrainMaterialC->getValue().asReal(); +} + +void LLFloaterPathfindingConsole::setTerrainMaterialC(F32 pTerrainMaterial) +{ + mTerrainMaterialC->setValue(LLSD(pTerrainMaterial)); +} + +F32 LLFloaterPathfindingConsole::getTerrainMaterialD() const +{ + return mTerrainMaterialD->getValue().asReal(); +} + +void LLFloaterPathfindingConsole::setTerrainMaterialD(F32 pTerrainMaterial) +{ + mTerrainMaterialD->setValue(LLSD(pTerrainMaterial)); +} + +void LLFloaterPathfindingConsole::setHasNavMeshReceived() +{ + std::string str = getString("navmesh_fetch_complete_available"); + mPathfindingStatus->setText((LLStringExplicit)str); + //check to see if all regions are done loading and they are then stitch the navmeshes together + --mNavMeshCnt; + if ( mNavMeshCnt == 0 ) + { + //LLPathingLib::getInstance()->stitchNavMeshes(); + } +} + +void LLFloaterPathfindingConsole::setHasNoNavMesh() +{ + std::string str = getString("navmesh_fetch_complete_none"); + mPathfindingStatus->setText((LLStringExplicit)str); +} + +LLFloaterPathfindingConsole::LLFloaterPathfindingConsole(const LLSD& pSeed) + : LLFloater(pSeed), + mShowNavMeshCheckBox(NULL), + mShowExcludeVolumesCheckBox(NULL), + mShowPathCheckBox(NULL), + mShowWaterPlaneCheckBox(NULL), + mRegionOverlayDisplayRadioGroup(NULL), + mPathSelectionRadioGroup(NULL), + mCharacterWidthSlider(NULL), + mCharacterTypeRadioGroup(NULL), + mPathfindingStatus(NULL), + mTerrainMaterialA(NULL), + mTerrainMaterialB(NULL), + mTerrainMaterialC(NULL), + mTerrainMaterialD(NULL), + mNavMeshCnt(0), + mHasStartPoint(false), + mHasEndPoint(false) +{ + for (int i=0;isetText((LLStringExplicit)str, styleParams); + llwarns <<"Errror: cannout find pathing library implementation."< regions; + regions.push_back( pCurrentRegion ); + //pCurrentRegion->getNeighboringRegions( regions ); + + std::vector shift; + shift.push_back( CURRENT_REGION ); + //pCurrentRegion->getNeighboringRegionsStatus( shift ); + + //If the navmesh shift ops and the total region counts do not match - use the current region, only. + if ( shift.size() != regions.size() ) + { + shift.clear();regions.clear(); + regions.push_back( pCurrentRegion ); + shift.push_back( CURRENT_REGION ); + } + int regionCnt = regions.size(); + mNavMeshCnt = regionCnt; + for ( int i=0; igetCapability( capability ); + + if ( !url.empty() ) + { + std::string str = getString("navmesh_fetch_inprogress"); + mPathfindingStatus->setText((LLStringExplicit)str); + LLNavMeshStation::getInstance()->setNavMeshDownloadURL( url ); + int dir = shift[i]; + LLNavMeshStation::getInstance()->downloadNavMeshSrc( mNavMeshDownloadObserver[mCurrentMDO].getObserverHandle(), dir ); + ++mCurrentMDO; + } + else + { + --mNavMeshCnt; + std::string str = getString("navmesh_region_not_enabled"); + LLStyle::Params styleParams; + styleParams.color = LLUIColorTable::instance().getColor("DrYellow"); + mPathfindingStatus->setText((LLStringExplicit)str, styleParams); + llinfos<<"Region has does not required caps of type ["<get(); + + LLPathingLib *llPathingLibInstance = LLPathingLib::getInstance(); + if (llPathingLibInstance != NULL) + { + llPathingLibInstance->setRenderNavMesh(checkBoxValue); + } + else + { + mShowNavMeshCheckBox->set(FALSE); + llwarns << "cannot find LLPathingLib instance" << llendl; + } +} + +void LLFloaterPathfindingConsole::onShowExcludeVolumesToggle() +{ + BOOL checkBoxValue = mShowExcludeVolumesCheckBox->get(); + + LLPathingLib *llPathingLibInstance = LLPathingLib::getInstance(); + if (llPathingLibInstance != NULL) + { + llPathingLibInstance->setRenderShapes(checkBoxValue); + } + else + { + mShowExcludeVolumesCheckBox->set(FALSE); + llwarns << "cannot find LLPathingLib instance" << llendl; + } +} + +void LLFloaterPathfindingConsole::onShowPathToggle() +{ + BOOL checkBoxValue = mShowPathCheckBox->get(); + + LLPathingLib *llPathingLibInstance = LLPathingLib::getInstance(); + if (llPathingLibInstance != NULL) + { + llPathingLibInstance->setRenderPath(checkBoxValue); + } + else + { + mShowPathCheckBox->set(FALSE); + llwarns << "cannot find LLPathingLib instance" << llendl; + } +} + +void LLFloaterPathfindingConsole::onShowWaterPlaneToggle() +{ + BOOL checkBoxValue = mShowWaterPlaneCheckBox->get(); + + LLPathingLib *llPathingLibInstance = LLPathingLib::getInstance(); + if (llPathingLibInstance != NULL) + { + llPathingLibInstance->setRenderWaterPlane(checkBoxValue); + } + else + { + mShowWaterPlaneCheckBox->set(FALSE); + llwarns << "cannot find LLPathingLib instance" << llendl; + } + + llwarns << "functionality has not yet been implemented to toggle '" + << mShowWaterPlaneCheckBox->getLabel() << "' to " + << (checkBoxValue ? "ON" : "OFF") << llendl; +} + +void LLFloaterPathfindingConsole::onRegionOverlayDisplaySwitch() +{ + LLPathingLib *llPathingLibInstance = LLPathingLib::getInstance(); + if (llPathingLibInstance != NULL) + { + switch (getRegionOverlayDisplay()) + { + case kRenderOverlayOnFixedPhysicsGeometry : + llPathingLibInstance->setRenderOverlayMode(false); + break; + case kRenderOverlayOnAllRenderableGeometry : + llPathingLibInstance->setRenderOverlayMode(true); + break; + default : + llPathingLibInstance->setRenderOverlayMode(false); + llassert(0); + break; + } + } + else + { + this->setRegionOverlayDisplay(kRenderOverlayOnFixedPhysicsGeometry); + llwarns << "cannot find LLPathingLib instance" << llendl; + } +} + +void LLFloaterPathfindingConsole::onPathSelectionSwitch() +{ + switch (getPathSelectionState()) + { + case kPathSelectNone : + break; + case kPathSelectStartPoint : + break; + case kPathSelectEndPoint : + break; + default : + llassert(0); + break; + } +} + +void LLFloaterPathfindingConsole::onCharacterWidthSet() +{ + generatePath(); +} + +void LLFloaterPathfindingConsole::onCharacterTypeSwitch() +{ + switch (getCharacterType()) + { + case kCharacterTypeA : + llwarns << "functionality has not yet been implemented to toggle '" + << mCharacterTypeRadioGroup->getName() << "' to CharacterTypeA" + << llendl; + break; + case kCharacterTypeB : + llwarns << "functionality has not yet been implemented to toggle '" + << mCharacterTypeRadioGroup->getName() << "' to CharacterTypeB" + << llendl; + break; + case kCharacterTypeC : + llwarns << "functionality has not yet been implemented to toggle '" + << mCharacterTypeRadioGroup->getName() << "' to CharacterTypeC" + << llendl; + break; + case kCharacterTypeD : + llwarns << "functionality has not yet been implemented to toggle '" + << mCharacterTypeRadioGroup->getName() << "' to CharacterTypeD" + << llendl; + break; + default : + llassert(0); + break; + } + +} + +void LLFloaterPathfindingConsole::onViewEditLinksetClicked() +{ + LLFloaterPathfindingLinksets::openLinksetsEditor(); +} + +void LLFloaterPathfindingConsole::onRebuildNavMeshClicked() +{ + llwarns << "functionality has not yet been implemented to handle rebuilding of the navmesh" << llendl; +} + +void LLFloaterPathfindingConsole::onRefreshNavMeshClicked() +{ + llwarns << "functionality has not yet been implemented to handle refreshing of the navmesh" << llendl; +} + +void LLFloaterPathfindingConsole::onTerrainMaterialASet() +{ + F32 terrainMaterial = getTerrainMaterialA(); + llwarns << "functionality has not yet been implemented to setting '" << mTerrainMaterialA->getName() + << "' to value (" << terrainMaterial << ")" << llendl; +} + +void LLFloaterPathfindingConsole::onTerrainMaterialBSet() +{ + F32 terrainMaterial = getTerrainMaterialB(); + llwarns << "functionality has not yet been implemented to setting '" << mTerrainMaterialB->getName() + << "' to value (" << terrainMaterial << ")" << llendl; +} + +void LLFloaterPathfindingConsole::onTerrainMaterialCSet() +{ + F32 terrainMaterial = getTerrainMaterialC(); + llwarns << "functionality has not yet been implemented to setting '" << mTerrainMaterialC->getName() + << "' to value (" << terrainMaterial << ")" << llendl; +} + +void LLFloaterPathfindingConsole::onTerrainMaterialDSet() +{ + F32 terrainMaterial = getTerrainMaterialD(); + llwarns << "functionality has not yet been implemented to setting '" << mTerrainMaterialD->getName() + << "' to value (" << terrainMaterial << ")" << llendl; +} + + +void LLFloaterPathfindingConsole::providePathingData( const LLVector3& point1, const LLVector3& point2 ) +{ + switch (getPathSelectionState()) + { + case kPathSelectNone : + llwarns << "not yet been implemented to toggle '" + << mPathSelectionRadioGroup->getName() << "' to PathSelectNone" + << llendl; + break; + + case kPathSelectStartPoint : + mPathData.mStartPointA = point1; + mPathData.mEndPointA = point2; + mHasStartPoint = true; + break; + + case kPathSelectEndPoint : + mPathData.mStartPointB = point1; + mPathData.mEndPointB = point2; + mHasEndPoint = true; + break; + + default : + llassert(0); + break; + } + + generatePath(); +} + +void LLFloaterPathfindingConsole::generatePath() +{ + if (mHasStartPoint && mHasEndPoint) + { + mPathData.mCharacterWidth = getCharacterWidth(); + LLPathingLib::getInstance()->generatePath(mPathData); + } +} diff --git a/indra/newview/llfloaterpathfindingsetup.h b/indra/newview/llfloaterpathfindingsetup.h new file mode 100644 index 0000000000..bcacdc3dcb --- /dev/null +++ b/indra/newview/llfloaterpathfindingsetup.h @@ -0,0 +1,151 @@ +/** + * @file llfloaterpathfindingsetup.h + * @author William Todd Stinson + * @brief "Pathfinding console" floater, allowing manipulation of the Havok AI pathfinding settings. + * + * $LicenseInfo:firstyear=2002&license=viewerlgpl$ + * Second Life Viewer Source Code + * Copyright (C) 2010, Linden Research, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; + * version 2.1 of the License only. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA + * $/LicenseInfo$ + */ + +#ifndef LL_LLFLOATERPATHFINDINGCONSOLE_H +#define LL_LLFLOATERPATHFINDINGCONSOLE_H + +#include "llfloater.h" +#include "llnavmeshstation.h" +#include "LLPathingLib.h" + +class LLSD; +class LLRadioGroup; +class LLSliderCtrl; +class LLLineEditor; +class LLTextBase; +class LLCheckBoxCtrl; + +class LLFloaterPathfindingConsole +: public LLFloater +{ + friend class LLFloaterReg; + +public: + typedef enum + { + kRenderOverlayOnFixedPhysicsGeometry = 0, + kRenderOverlayOnAllRenderableGeometry = 1 + } ERegionOverlayDisplay; + + typedef enum + { + kPathSelectNone = 0, + kPathSelectStartPoint = 1, + kPathSelectEndPoint = 2 + } EPathSelectionState; + + typedef enum + { + kCharacterTypeA = 0, + kCharacterTypeB = 1, + kCharacterTypeC = 2, + kCharacterTypeD = 3 + } ECharacterType; + + virtual BOOL postBuild(); + //Populates a data packet that is forwarded onto the LLPathingSystem + void providePathingData( const LLVector3& point1, const LLVector3& point2 ); + + ERegionOverlayDisplay getRegionOverlayDisplay() const; + void setRegionOverlayDisplay(ERegionOverlayDisplay pRegionOverlayDisplay); + + EPathSelectionState getPathSelectionState() const; + void setPathSelectionState(EPathSelectionState pPathSelectionState); + + F32 getCharacterWidth() const; + void setCharacterWidth(F32 pCharacterWidth); + + ECharacterType getCharacterType() const; + void setCharacterType(ECharacterType pCharacterType); + + F32 getTerrainMaterialA() const; + void setTerrainMaterialA(F32 pTerrainMaterial); + + F32 getTerrainMaterialB() const; + void setTerrainMaterialB(F32 pTerrainMaterial); + + F32 getTerrainMaterialC() const; + void setTerrainMaterialC(F32 pTerrainMaterial); + + F32 getTerrainMaterialD() const; + void setTerrainMaterialD(F32 pTerrainMaterial); + + void setHasNavMeshReceived(); + void setHasNoNavMesh(); + +protected: + +private: + // Does its own instance management, so clients not allowed + // to allocate or destroy. + LLFloaterPathfindingConsole(const LLSD& pSeed); + virtual ~LLFloaterPathfindingConsole(); + + virtual void onOpen(const LLSD& pKey); + + void onShowNavMeshToggle(); + void onShowExcludeVolumesToggle(); + void onShowPathToggle(); + void onShowWaterPlaneToggle(); + void onRegionOverlayDisplaySwitch(); + void onPathSelectionSwitch(); + void onCharacterWidthSet(); + void onCharacterTypeSwitch(); + void onViewEditLinksetClicked(); + void onRebuildNavMeshClicked(); + void onRefreshNavMeshClicked(); + void onTerrainMaterialASet(); + void onTerrainMaterialBSet(); + void onTerrainMaterialCSet(); + void onTerrainMaterialDSet(); + void generatePath(); + + LLCheckBoxCtrl *mShowNavMeshCheckBox; + LLCheckBoxCtrl *mShowExcludeVolumesCheckBox; + LLCheckBoxCtrl *mShowPathCheckBox; + LLCheckBoxCtrl *mShowWaterPlaneCheckBox; + LLRadioGroup *mRegionOverlayDisplayRadioGroup; + LLRadioGroup *mPathSelectionRadioGroup; + LLSliderCtrl *mCharacterWidthSlider; + LLRadioGroup *mCharacterTypeRadioGroup; + LLTextBase *mPathfindingStatus; + LLLineEditor *mTerrainMaterialA; + LLLineEditor *mTerrainMaterialB; + LLLineEditor *mTerrainMaterialC; + LLLineEditor *mTerrainMaterialD; + + LLNavMeshDownloadObserver mNavMeshDownloadObserver[10]; + int mCurrentMDO; + int mNavMeshCnt; + + //Container that is populated and subsequently submitted to the LLPathingSystem for processing + LLPathingLib::PathingPacket mPathData; + bool mHasStartPoint; + bool mHasEndPoint; +}; + +#endif // LL_LLFLOATERPATHFINDINGCONSOLE_H diff --git a/indra/newview/llnavmeshstation.cpp b/indra/newview/llnavmeshstation.cpp index 87f7e92ddd..16f459ff84 100644 --- a/indra/newview/llnavmeshstation.cpp +++ b/indra/newview/llnavmeshstation.cpp @@ -31,7 +31,7 @@ #include "llagent.h" #include "llviewerregion.h" #include "llsdutil.h" -#include "llfloaterpathfindingconsole.h" +#include "llfloaterpathfindingsetup.h" //=============================================================================== LLNavMeshStation::LLNavMeshStation() diff --git a/indra/newview/llviewerdisplay.cpp b/indra/newview/llviewerdisplay.cpp index 3e21334cd4..719f560101 100644 --- a/indra/newview/llviewerdisplay.cpp +++ b/indra/newview/llviewerdisplay.cpp @@ -78,7 +78,7 @@ #include "llwaterparammanager.h" #include "llpostprocess.h" #include "LLPathingLib.h" -#include "llfloaterpathfindingconsole.h" +#include "llfloaterpathfindingsetup.h" #include "llfloaterreg.h" extern LLPointer gStartTexture; diff --git a/indra/newview/llviewerfloaterreg.cpp b/indra/newview/llviewerfloaterreg.cpp index 0a3bb2f4ba..f28e79f6ad 100644 --- a/indra/newview/llviewerfloaterreg.cpp +++ b/indra/newview/llviewerfloaterreg.cpp @@ -84,7 +84,7 @@ #include "llfloaterobjectweights.h" #include "llfloateropenobject.h" #include "llfloateroutbox.h" -#include "llfloaterpathfindingconsole.h" +#include "llfloaterpathfindingsetup.h" #include "llfloaterpathfindinglinksets.h" #include "llfloaterpay.h" #include "llfloaterperms.h" diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp index ab03463bbc..87d0ebcde2 100644 --- a/indra/newview/llviewerwindow.cpp +++ b/indra/newview/llviewerwindow.cpp @@ -204,7 +204,7 @@ #include "llviewerwindowlistener.h" #include "llpaneltopinfobar.h" #include "LLPathingLib.h" -#include "llfloaterpathfindingconsole.h" +#include "llfloaterpathfindingsetup.h" #if LL_WINDOWS #include // For Unicode conversion methods -- cgit v1.3 From 1156cfc490a543eb88c4077fb9a0ecffee80f3f5 Mon Sep 17 00:00:00 2001 From: Todd Stinson Date: Wed, 1 Feb 2012 18:04:11 -0800 Subject: Renaming the LLPathfindingConsole class to be LLPathfindingSetup. --- indra/newview/llfloaterpathfindingsetup.cpp | 112 ++++++++++++++-------------- indra/newview/llfloaterpathfindingsetup.h | 12 +-- indra/newview/llnavmeshstation.h | 14 ++-- indra/newview/llviewerfloaterreg.cpp | 2 +- indra/newview/llviewerwindow.cpp | 2 +- 5 files changed, 71 insertions(+), 71 deletions(-) (limited to 'indra/newview/llviewerfloaterreg.cpp') diff --git a/indra/newview/llfloaterpathfindingsetup.cpp b/indra/newview/llfloaterpathfindingsetup.cpp index 2fb5129a91..f5df1fe0de 100644 --- a/indra/newview/llfloaterpathfindingsetup.cpp +++ b/indra/newview/llfloaterpathfindingsetup.cpp @@ -1,5 +1,5 @@ /** -* @file llfloaterpathfindingconsole.cpp +* @file llfloaterpathfindingsetup.cpp * @author William Todd Stinson * @brief "Pathfinding console" floater, allowing manipulation of the Havok AI pathfinding settings. * @@ -57,74 +57,74 @@ const int CURRENT_REGION = 99; const int MAX_OBSERVERS = 10; //--------------------------------------------------------------------------- -// LLFloaterPathfindingConsole +// LLFloaterPathfindingSetup //--------------------------------------------------------------------------- -BOOL LLFloaterPathfindingConsole::postBuild() +BOOL LLFloaterPathfindingSetup::postBuild() { - childSetAction("view_and_edit_linksets", boost::bind(&LLFloaterPathfindingConsole::onViewEditLinksetClicked, this)); - childSetAction("rebuild_navmesh", boost::bind(&LLFloaterPathfindingConsole::onRebuildNavMeshClicked, this)); - childSetAction("refresh_navmesh", boost::bind(&LLFloaterPathfindingConsole::onRefreshNavMeshClicked, this)); + childSetAction("view_and_edit_linksets", boost::bind(&LLFloaterPathfindingSetup::onViewEditLinksetClicked, this)); + childSetAction("rebuild_navmesh", boost::bind(&LLFloaterPathfindingSetup::onRebuildNavMeshClicked, this)); + childSetAction("refresh_navmesh", boost::bind(&LLFloaterPathfindingSetup::onRefreshNavMeshClicked, this)); mShowNavMeshCheckBox = findChild("show_navmesh_overlay"); llassert(mShowNavMeshCheckBox != NULL); - mShowNavMeshCheckBox->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onShowNavMeshToggle, this)); + mShowNavMeshCheckBox->setCommitCallback(boost::bind(&LLFloaterPathfindingSetup::onShowNavMeshToggle, this)); mShowExcludeVolumesCheckBox = findChild("show_exclusion_volumes"); llassert(mShowExcludeVolumesCheckBox != NULL); - mShowExcludeVolumesCheckBox->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onShowExcludeVolumesToggle, this)); + mShowExcludeVolumesCheckBox->setCommitCallback(boost::bind(&LLFloaterPathfindingSetup::onShowExcludeVolumesToggle, this)); mShowPathCheckBox = findChild("show_path"); llassert(mShowPathCheckBox != NULL); - mShowPathCheckBox->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onShowPathToggle, this)); + mShowPathCheckBox->setCommitCallback(boost::bind(&LLFloaterPathfindingSetup::onShowPathToggle, this)); mShowWaterPlaneCheckBox = findChild("show_water_plane"); llassert(mShowWaterPlaneCheckBox != NULL); - mShowWaterPlaneCheckBox->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onShowWaterPlaneToggle, this)); + mShowWaterPlaneCheckBox->setCommitCallback(boost::bind(&LLFloaterPathfindingSetup::onShowWaterPlaneToggle, this)); mRegionOverlayDisplayRadioGroup = findChild("region_overlay_display"); llassert(mRegionOverlayDisplayRadioGroup != NULL); - mRegionOverlayDisplayRadioGroup->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onRegionOverlayDisplaySwitch, this)); + mRegionOverlayDisplayRadioGroup->setCommitCallback(boost::bind(&LLFloaterPathfindingSetup::onRegionOverlayDisplaySwitch, this)); mPathSelectionRadioGroup = findChild("path_selection"); llassert(mPathSelectionRadioGroup != NULL); - mPathSelectionRadioGroup ->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onPathSelectionSwitch, this)); + mPathSelectionRadioGroup ->setCommitCallback(boost::bind(&LLFloaterPathfindingSetup::onPathSelectionSwitch, this)); mCharacterWidthSlider = findChild("character_width"); llassert(mCharacterWidthSlider != NULL); - mCharacterWidthSlider->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onCharacterWidthSet, this)); + mCharacterWidthSlider->setCommitCallback(boost::bind(&LLFloaterPathfindingSetup::onCharacterWidthSet, this)); mCharacterTypeRadioGroup = findChild("character_type"); llassert(mCharacterTypeRadioGroup != NULL); - mCharacterTypeRadioGroup->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onCharacterTypeSwitch, this)); + mCharacterTypeRadioGroup->setCommitCallback(boost::bind(&LLFloaterPathfindingSetup::onCharacterTypeSwitch, this)); mPathfindingStatus = findChild("pathfinding_status"); llassert(mPathfindingStatus != NULL); mTerrainMaterialA = findChild("terrain_material_a"); llassert(mTerrainMaterialA != NULL); - mTerrainMaterialA->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onTerrainMaterialASet, this)); + mTerrainMaterialA->setCommitCallback(boost::bind(&LLFloaterPathfindingSetup::onTerrainMaterialASet, this)); mTerrainMaterialA->setPrevalidate(LLTextValidate::validateFloat); mTerrainMaterialB = findChild("terrain_material_b"); llassert(mTerrainMaterialB != NULL); - mTerrainMaterialB->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onTerrainMaterialBSet, this)); + mTerrainMaterialB->setCommitCallback(boost::bind(&LLFloaterPathfindingSetup::onTerrainMaterialBSet, this)); mTerrainMaterialB->setPrevalidate(LLTextValidate::validateFloat); mTerrainMaterialC = findChild("terrain_material_c"); llassert(mTerrainMaterialC != NULL); - mTerrainMaterialC->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onTerrainMaterialCSet, this)); + mTerrainMaterialC->setCommitCallback(boost::bind(&LLFloaterPathfindingSetup::onTerrainMaterialCSet, this)); mTerrainMaterialC->setPrevalidate(LLTextValidate::validateFloat); mTerrainMaterialD = findChild("terrain_material_d"); llassert(mTerrainMaterialD != NULL); - mTerrainMaterialD->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onTerrainMaterialDSet, this)); + mTerrainMaterialD->setCommitCallback(boost::bind(&LLFloaterPathfindingSetup::onTerrainMaterialDSet, this)); mTerrainMaterialD->setPrevalidate(LLTextValidate::validateFloat); return LLFloater::postBuild(); } -LLFloaterPathfindingConsole::ERegionOverlayDisplay LLFloaterPathfindingConsole::getRegionOverlayDisplay() const +LLFloaterPathfindingSetup::ERegionOverlayDisplay LLFloaterPathfindingSetup::getRegionOverlayDisplay() const { ERegionOverlayDisplay regionOverlayDisplay; switch (mRegionOverlayDisplayRadioGroup->getValue().asInteger()) @@ -144,7 +144,7 @@ LLFloaterPathfindingConsole::ERegionOverlayDisplay LLFloaterPathfindingConsole:: return regionOverlayDisplay; } -void LLFloaterPathfindingConsole::setRegionOverlayDisplay(ERegionOverlayDisplay pRegionOverlayDisplay) +void LLFloaterPathfindingSetup::setRegionOverlayDisplay(ERegionOverlayDisplay pRegionOverlayDisplay) { LLSD radioGroupValue; @@ -165,7 +165,7 @@ void LLFloaterPathfindingConsole::setRegionOverlayDisplay(ERegionOverlayDisplay mRegionOverlayDisplayRadioGroup->setValue(radioGroupValue); } -LLFloaterPathfindingConsole::EPathSelectionState LLFloaterPathfindingConsole::getPathSelectionState() const +LLFloaterPathfindingSetup::EPathSelectionState LLFloaterPathfindingSetup::getPathSelectionState() const { EPathSelectionState pathSelectionState; @@ -185,7 +185,7 @@ LLFloaterPathfindingConsole::EPathSelectionState LLFloaterPathfindingConsole::ge return pathSelectionState; } -void LLFloaterPathfindingConsole::setPathSelectionState(EPathSelectionState pPathSelectionState) +void LLFloaterPathfindingSetup::setPathSelectionState(EPathSelectionState pPathSelectionState) { LLSD radioGroupValue; @@ -205,17 +205,17 @@ void LLFloaterPathfindingConsole::setPathSelectionState(EPathSelectionState pPat mPathSelectionRadioGroup->setValue(radioGroupValue); } -F32 LLFloaterPathfindingConsole::getCharacterWidth() const +F32 LLFloaterPathfindingSetup::getCharacterWidth() const { return mCharacterWidthSlider->getValueF32(); } -void LLFloaterPathfindingConsole::setCharacterWidth(F32 pCharacterWidth) +void LLFloaterPathfindingSetup::setCharacterWidth(F32 pCharacterWidth) { mCharacterWidthSlider->setValue(LLSD(pCharacterWidth)); } -LLFloaterPathfindingConsole::ECharacterType LLFloaterPathfindingConsole::getCharacterType() const +LLFloaterPathfindingSetup::ECharacterType LLFloaterPathfindingSetup::getCharacterType() const { ECharacterType characterType; @@ -242,7 +242,7 @@ LLFloaterPathfindingConsole::ECharacterType LLFloaterPathfindingConsole::getChar return characterType; } -void LLFloaterPathfindingConsole::setCharacterType(ECharacterType pCharacterType) +void LLFloaterPathfindingSetup::setCharacterType(ECharacterType pCharacterType) { LLSD radioGroupValue; @@ -269,47 +269,47 @@ void LLFloaterPathfindingConsole::setCharacterType(ECharacterType pCharacterType mCharacterTypeRadioGroup->setValue(radioGroupValue); } -F32 LLFloaterPathfindingConsole::getTerrainMaterialA() const +F32 LLFloaterPathfindingSetup::getTerrainMaterialA() const { return mTerrainMaterialA->getValue().asReal(); } -void LLFloaterPathfindingConsole::setTerrainMaterialA(F32 pTerrainMaterial) +void LLFloaterPathfindingSetup::setTerrainMaterialA(F32 pTerrainMaterial) { mTerrainMaterialA->setValue(LLSD(pTerrainMaterial)); } -F32 LLFloaterPathfindingConsole::getTerrainMaterialB() const +F32 LLFloaterPathfindingSetup::getTerrainMaterialB() const { return mTerrainMaterialB->getValue().asReal(); } -void LLFloaterPathfindingConsole::setTerrainMaterialB(F32 pTerrainMaterial) +void LLFloaterPathfindingSetup::setTerrainMaterialB(F32 pTerrainMaterial) { mTerrainMaterialB->setValue(LLSD(pTerrainMaterial)); } -F32 LLFloaterPathfindingConsole::getTerrainMaterialC() const +F32 LLFloaterPathfindingSetup::getTerrainMaterialC() const { return mTerrainMaterialC->getValue().asReal(); } -void LLFloaterPathfindingConsole::setTerrainMaterialC(F32 pTerrainMaterial) +void LLFloaterPathfindingSetup::setTerrainMaterialC(F32 pTerrainMaterial) { mTerrainMaterialC->setValue(LLSD(pTerrainMaterial)); } -F32 LLFloaterPathfindingConsole::getTerrainMaterialD() const +F32 LLFloaterPathfindingSetup::getTerrainMaterialD() const { return mTerrainMaterialD->getValue().asReal(); } -void LLFloaterPathfindingConsole::setTerrainMaterialD(F32 pTerrainMaterial) +void LLFloaterPathfindingSetup::setTerrainMaterialD(F32 pTerrainMaterial) { mTerrainMaterialD->setValue(LLSD(pTerrainMaterial)); } -void LLFloaterPathfindingConsole::setHasNavMeshReceived() +void LLFloaterPathfindingSetup::setHasNavMeshReceived() { std::string str = getString("navmesh_fetch_complete_available"); mPathfindingStatus->setText((LLStringExplicit)str); @@ -321,13 +321,13 @@ void LLFloaterPathfindingConsole::setHasNavMeshReceived() } } -void LLFloaterPathfindingConsole::setHasNoNavMesh() +void LLFloaterPathfindingSetup::setHasNoNavMesh() { std::string str = getString("navmesh_fetch_complete_none"); mPathfindingStatus->setText((LLStringExplicit)str); } -LLFloaterPathfindingConsole::LLFloaterPathfindingConsole(const LLSD& pSeed) +LLFloaterPathfindingSetup::LLFloaterPathfindingSetup(const LLSD& pSeed) : LLFloater(pSeed), mShowNavMeshCheckBox(NULL), mShowExcludeVolumesCheckBox(NULL), @@ -352,11 +352,11 @@ LLFloaterPathfindingConsole::LLFloaterPathfindingConsole(const LLSD& pSeed) } } -LLFloaterPathfindingConsole::~LLFloaterPathfindingConsole() +LLFloaterPathfindingSetup::~LLFloaterPathfindingSetup() { } -void LLFloaterPathfindingConsole::onOpen(const LLSD& pKey) +void LLFloaterPathfindingSetup::onOpen(const LLSD& pKey) { //make sure we have a pathing system if ( !LLPathingLib::getInstance() ) @@ -424,7 +424,7 @@ void LLFloaterPathfindingConsole::onOpen(const LLSD& pKey) } } -void LLFloaterPathfindingConsole::onShowNavMeshToggle() +void LLFloaterPathfindingSetup::onShowNavMeshToggle() { BOOL checkBoxValue = mShowNavMeshCheckBox->get(); @@ -440,7 +440,7 @@ void LLFloaterPathfindingConsole::onShowNavMeshToggle() } } -void LLFloaterPathfindingConsole::onShowExcludeVolumesToggle() +void LLFloaterPathfindingSetup::onShowExcludeVolumesToggle() { BOOL checkBoxValue = mShowExcludeVolumesCheckBox->get(); @@ -456,7 +456,7 @@ void LLFloaterPathfindingConsole::onShowExcludeVolumesToggle() } } -void LLFloaterPathfindingConsole::onShowPathToggle() +void LLFloaterPathfindingSetup::onShowPathToggle() { BOOL checkBoxValue = mShowPathCheckBox->get(); @@ -472,7 +472,7 @@ void LLFloaterPathfindingConsole::onShowPathToggle() } } -void LLFloaterPathfindingConsole::onShowWaterPlaneToggle() +void LLFloaterPathfindingSetup::onShowWaterPlaneToggle() { BOOL checkBoxValue = mShowWaterPlaneCheckBox->get(); @@ -492,7 +492,7 @@ void LLFloaterPathfindingConsole::onShowWaterPlaneToggle() << (checkBoxValue ? "ON" : "OFF") << llendl; } -void LLFloaterPathfindingConsole::onRegionOverlayDisplaySwitch() +void LLFloaterPathfindingSetup::onRegionOverlayDisplaySwitch() { LLPathingLib *llPathingLibInstance = LLPathingLib::getInstance(); if (llPathingLibInstance != NULL) @@ -518,7 +518,7 @@ void LLFloaterPathfindingConsole::onRegionOverlayDisplaySwitch() } } -void LLFloaterPathfindingConsole::onPathSelectionSwitch() +void LLFloaterPathfindingSetup::onPathSelectionSwitch() { switch (getPathSelectionState()) { @@ -534,12 +534,12 @@ void LLFloaterPathfindingConsole::onPathSelectionSwitch() } } -void LLFloaterPathfindingConsole::onCharacterWidthSet() +void LLFloaterPathfindingSetup::onCharacterWidthSet() { generatePath(); } -void LLFloaterPathfindingConsole::onCharacterTypeSwitch() +void LLFloaterPathfindingSetup::onCharacterTypeSwitch() { switch (getCharacterType()) { @@ -570,43 +570,43 @@ void LLFloaterPathfindingConsole::onCharacterTypeSwitch() } -void LLFloaterPathfindingConsole::onViewEditLinksetClicked() +void LLFloaterPathfindingSetup::onViewEditLinksetClicked() { LLFloaterPathfindingLinksets::openLinksetsEditor(); } -void LLFloaterPathfindingConsole::onRebuildNavMeshClicked() +void LLFloaterPathfindingSetup::onRebuildNavMeshClicked() { llwarns << "functionality has not yet been implemented to handle rebuilding of the navmesh" << llendl; } -void LLFloaterPathfindingConsole::onRefreshNavMeshClicked() +void LLFloaterPathfindingSetup::onRefreshNavMeshClicked() { llwarns << "functionality has not yet been implemented to handle refreshing of the navmesh" << llendl; } -void LLFloaterPathfindingConsole::onTerrainMaterialASet() +void LLFloaterPathfindingSetup::onTerrainMaterialASet() { F32 terrainMaterial = getTerrainMaterialA(); llwarns << "functionality has not yet been implemented to setting '" << mTerrainMaterialA->getName() << "' to value (" << terrainMaterial << ")" << llendl; } -void LLFloaterPathfindingConsole::onTerrainMaterialBSet() +void LLFloaterPathfindingSetup::onTerrainMaterialBSet() { F32 terrainMaterial = getTerrainMaterialB(); llwarns << "functionality has not yet been implemented to setting '" << mTerrainMaterialB->getName() << "' to value (" << terrainMaterial << ")" << llendl; } -void LLFloaterPathfindingConsole::onTerrainMaterialCSet() +void LLFloaterPathfindingSetup::onTerrainMaterialCSet() { F32 terrainMaterial = getTerrainMaterialC(); llwarns << "functionality has not yet been implemented to setting '" << mTerrainMaterialC->getName() << "' to value (" << terrainMaterial << ")" << llendl; } -void LLFloaterPathfindingConsole::onTerrainMaterialDSet() +void LLFloaterPathfindingSetup::onTerrainMaterialDSet() { F32 terrainMaterial = getTerrainMaterialD(); llwarns << "functionality has not yet been implemented to setting '" << mTerrainMaterialD->getName() @@ -614,7 +614,7 @@ void LLFloaterPathfindingConsole::onTerrainMaterialDSet() } -void LLFloaterPathfindingConsole::providePathingData( const LLVector3& point1, const LLVector3& point2 ) +void LLFloaterPathfindingSetup::providePathingData( const LLVector3& point1, const LLVector3& point2 ) { switch (getPathSelectionState()) { @@ -644,7 +644,7 @@ void LLFloaterPathfindingConsole::providePathingData( const LLVector3& point1, c generatePath(); } -void LLFloaterPathfindingConsole::generatePath() +void LLFloaterPathfindingSetup::generatePath() { if (mHasStartPoint && mHasEndPoint) { diff --git a/indra/newview/llfloaterpathfindingsetup.h b/indra/newview/llfloaterpathfindingsetup.h index bcacdc3dcb..edb7072b28 100644 --- a/indra/newview/llfloaterpathfindingsetup.h +++ b/indra/newview/llfloaterpathfindingsetup.h @@ -25,8 +25,8 @@ * $/LicenseInfo$ */ -#ifndef LL_LLFLOATERPATHFINDINGCONSOLE_H -#define LL_LLFLOATERPATHFINDINGCONSOLE_H +#ifndef LL_LLFLOATERPATHFINDINGSETUP_H +#define LL_LLFLOATERPATHFINDINGSETUP_H #include "llfloater.h" #include "llnavmeshstation.h" @@ -39,7 +39,7 @@ class LLLineEditor; class LLTextBase; class LLCheckBoxCtrl; -class LLFloaterPathfindingConsole +class LLFloaterPathfindingSetup : public LLFloater { friend class LLFloaterReg; @@ -102,8 +102,8 @@ protected: private: // Does its own instance management, so clients not allowed // to allocate or destroy. - LLFloaterPathfindingConsole(const LLSD& pSeed); - virtual ~LLFloaterPathfindingConsole(); + LLFloaterPathfindingSetup(const LLSD& pSeed); + virtual ~LLFloaterPathfindingSetup(); virtual void onOpen(const LLSD& pKey); @@ -148,4 +148,4 @@ private: bool mHasEndPoint; }; -#endif // LL_LLFLOATERPATHFINDINGCONSOLE_H +#endif // LL_LLFLOATERPATHFINDINGSETUP_H diff --git a/indra/newview/llnavmeshstation.h b/indra/newview/llnavmeshstation.h index 72bf725688..0aa714dac8 100644 --- a/indra/newview/llnavmeshstation.h +++ b/indra/newview/llnavmeshstation.h @@ -31,7 +31,7 @@ #include "llhandle.h" //=============================================================================== class LLCurlRequest; -class LLFloaterPathfindingConsole; +class LLFloaterPathfindingSetup; //=============================================================================== class LLNavMeshObserver { @@ -44,12 +44,12 @@ public: virtual ~LLNavMeshObserver() {} //Accessor for the observers handle const LLHandle& getObserverHandle() const { return mObserverHandle; } - LLFloaterPathfindingConsole *getPathfindingConsole() {return mPathfindingConsole;} - void setPathfindingConsole(LLFloaterPathfindingConsole *pPathfindingConsole) {mPathfindingConsole = pPathfindingConsole;} + LLFloaterPathfindingSetup *getPathfindingConsole() {return mPathfindingConsole;} + void setPathfindingConsole(LLFloaterPathfindingSetup *pPathfindingConsole) {mPathfindingConsole = pPathfindingConsole;} protected: LLRootHandle mObserverHandle; - LLFloaterPathfindingConsole *mPathfindingConsole; + LLFloaterPathfindingSetup *mPathfindingConsole; }; //=============================================================================== class LLNavMeshDownloadObserver @@ -61,12 +61,12 @@ public: virtual ~LLNavMeshDownloadObserver() {} //Accessor for the observers handle const LLHandle& getObserverHandle() const { return mObserverHandle; } - LLFloaterPathfindingConsole *getPathfindingConsole() {return mPathfindingConsole;} - void setPathfindingConsole(LLFloaterPathfindingConsole *pPathfindingConsole) {mPathfindingConsole = pPathfindingConsole;} + LLFloaterPathfindingSetup *getPathfindingConsole() {return mPathfindingConsole;} + void setPathfindingConsole(LLFloaterPathfindingSetup *pPathfindingConsole) {mPathfindingConsole = pPathfindingConsole;} protected: LLRootHandle mObserverHandle; - LLFloaterPathfindingConsole *mPathfindingConsole; + LLFloaterPathfindingSetup *mPathfindingConsole; }; //=============================================================================== class LLNavMeshStation : public LLSingleton diff --git a/indra/newview/llviewerfloaterreg.cpp b/indra/newview/llviewerfloaterreg.cpp index f28e79f6ad..ba27f3cfc0 100644 --- a/indra/newview/llviewerfloaterreg.cpp +++ b/indra/newview/llviewerfloaterreg.cpp @@ -245,7 +245,7 @@ void LLViewerFloaterReg::registerFloaters() LLFloaterReg::add("outgoing_call", "floater_outgoing_call.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterPayUtil::registerFloater(); - LLFloaterReg::add("pathfinding_console", "floater_pathfinding_console.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); + LLFloaterReg::add("pathfinding_console", "floater_pathfinding_console.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("pathfinding_linksets", "floater_pathfinding_linksets.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("people", "floater_people.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("places", "floater_places.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp index 87d0ebcde2..a513dcc65e 100644 --- a/indra/newview/llviewerwindow.cpp +++ b/indra/newview/llviewerwindow.cpp @@ -964,7 +964,7 @@ BOOL LLViewerWindow::handleAnyMouseClick(LLWindow *window, LLCoordGL pos, MASK MASK currentKeyMask = gKeyboard->currentMask(TRUE); if ( !(currentKeyMask & MASK_ALT) ) { - LLFloaterPathfindingConsole* pFloater = LLFloaterReg::getTypedInstance("pathfinding_console"); + LLFloaterPathfindingSetup* pFloater = LLFloaterReg::getTypedInstance("pathfinding_console"); if ( pFloater ) { //The floater takes care of determining what stage - essentially where the data goes into the pathing packet(start or end) -- cgit v1.3 From beadc65fe4dd40a01069eb3d29659d1b06f6d746 Mon Sep 17 00:00:00 2001 From: Todd Stinson Date: Wed, 1 Feb 2012 18:14:04 -0800 Subject: Renaming the XUI files for the pathfinding console to setup. --- indra/newview/app_settings/commands.xml | 6 +- indra/newview/llviewerfloaterreg.cpp | 2 +- indra/newview/llviewerwindow.cpp | 2 +- .../default/xui/en/floater_pathfinding_console.xml | 466 --------------------- .../default/xui/en/floater_pathfinding_setup.xml | 466 +++++++++++++++++++++ indra/newview/skins/default/xui/en/menu_viewer.xml | 2 +- 6 files changed, 472 insertions(+), 472 deletions(-) delete mode 100644 indra/newview/skins/default/xui/en/floater_pathfinding_console.xml create mode 100644 indra/newview/skins/default/xui/en/floater_pathfinding_setup.xml (limited to 'indra/newview/llviewerfloaterreg.cpp') diff --git a/indra/newview/app_settings/commands.xml b/indra/newview/app_settings/commands.xml index 22dc336399..7d42f237b1 100644 --- a/indra/newview/app_settings/commands.xml +++ b/indra/newview/app_settings/commands.xml @@ -155,15 +155,15 @@ is_running_function="Floater.IsOpen" is_running_parameters="people" /> - ); LLFloaterPayUtil::registerFloater(); - LLFloaterReg::add("pathfinding_console", "floater_pathfinding_console.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("pathfinding_linksets", "floater_pathfinding_linksets.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); + LLFloaterReg::add("pathfinding_setup", "floater_pathfinding_setup.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("people", "floater_people.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("places", "floater_places.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("preferences", "floater_preferences.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp index a513dcc65e..487f849ada 100644 --- a/indra/newview/llviewerwindow.cpp +++ b/indra/newview/llviewerwindow.cpp @@ -964,7 +964,7 @@ BOOL LLViewerWindow::handleAnyMouseClick(LLWindow *window, LLCoordGL pos, MASK MASK currentKeyMask = gKeyboard->currentMask(TRUE); if ( !(currentKeyMask & MASK_ALT) ) { - LLFloaterPathfindingSetup* pFloater = LLFloaterReg::getTypedInstance("pathfinding_console"); + LLFloaterPathfindingSetup* pFloater = LLFloaterReg::getTypedInstance("pathfinding_setup"); if ( pFloater ) { //The floater takes care of determining what stage - essentially where the data goes into the pathing packet(start or end) diff --git a/indra/newview/skins/default/xui/en/floater_pathfinding_console.xml b/indra/newview/skins/default/xui/en/floater_pathfinding_console.xml deleted file mode 100644 index 7b751d525f..0000000000 --- a/indra/newview/skins/default/xui/en/floater_pathfinding_console.xml +++ /dev/null @@ -1,466 +0,0 @@ - - - - Downloading the navmesh ... - Navmesh received. - No navmesh for region. - Pathfinding is not enabled for this region. - Cannot find pathing library implementation. - - Show overlays: - - - - - - - Overlay on: - - - - - - - -Click on two points -to see the path between them. - - - - - - - Character width - - - - m - - - Character type - - - - - - - - - - - - View / edit linkset attributes: - - -- cgit v1.3 From ce17ae8a182cf8b1acd88bbbb3dceb7ff39fd0ff Mon Sep 17 00:00:00 2001 From: Oz Linden Date: Sat, 12 May 2012 07:29:25 -0400 Subject: STORM-1738: get autoreplace preferences working, clean up some coding and naming conventions --- indra/newview/CMakeLists.txt | 4 +- indra/newview/llautoreplacefloater.cpp | 377 --------------------- indra/newview/llautoreplacefloater.h | 75 ---- indra/newview/llfloaterautoreplacesettings.cpp | 367 ++++++++++++++++++++ indra/newview/llfloaterautoreplacesettings.h | 70 ++++ indra/newview/llfloaterpreference.cpp | 12 +- indra/newview/llfloaterpreference.h | 1 + indra/newview/llviewerfloaterreg.cpp | 4 +- .../skins/default/xui/en/floater_autoreplace.xml | 4 +- .../default/xui/en/panel_preferences_chat.xml | 2 +- 10 files changed, 455 insertions(+), 461 deletions(-) delete mode 100644 indra/newview/llautoreplacefloater.cpp delete mode 100644 indra/newview/llautoreplacefloater.h create mode 100644 indra/newview/llfloaterautoreplacesettings.cpp create mode 100644 indra/newview/llfloaterautoreplacesettings.h (limited to 'indra/newview/llviewerfloaterreg.cpp') diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt index 90468ccbef..a45467324b 100644 --- a/indra/newview/CMakeLists.txt +++ b/indra/newview/CMakeLists.txt @@ -99,7 +99,6 @@ set(viewer_SOURCE_FILES llattachmentsmgr.cpp llaudiosourcevo.cpp llautoreplace.cpp - llautoreplacefloater.cpp llavataractions.cpp llavatariconctrl.cpp llavatarlist.cpp @@ -171,6 +170,7 @@ set(viewer_SOURCE_FILES llfloaterabout.cpp llfloaterbvhpreview.cpp llfloaterauction.cpp + llfloaterautoreplacesettings.cpp llfloateravatar.cpp llfloateravatarpicker.cpp llfloateravatartextures.cpp @@ -657,7 +657,6 @@ set(viewer_HEADER_FILES llattachmentsmgr.h llaudiosourcevo.h llautoreplace.h - llautoreplacefloater.h llavataractions.h llavatariconctrl.h llavatarlist.h @@ -729,6 +728,7 @@ set(viewer_HEADER_FILES llfloaterabout.h llfloaterbvhpreview.h llfloaterauction.h + llfloaterautoreplacesettings.h llfloateravatar.h llfloateravatarpicker.h llfloateravatartextures.h diff --git a/indra/newview/llautoreplacefloater.cpp b/indra/newview/llautoreplacefloater.cpp deleted file mode 100644 index c2d7be269b..0000000000 --- a/indra/newview/llautoreplacefloater.cpp +++ /dev/null @@ -1,377 +0,0 @@ -/** - * @file llautoreplacefloater.cpp - * @brief Auto Replace List floater - * - * $LicenseInfo:firstyear=2012&license=viewerlgpl$ - * Second Life Viewer Source Code - * Copyright (C) 2012, Linden Research, Inc. - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * $/LicenseInfo$ - */ - -#include "llviewerprecompiledheaders.h" - -#include "llautoreplacefloater.h" - -#include "llagentdata.h" -#include "llcommandhandler.h" -#include "llfloater.h" -#include "lluictrlfactory.h" -#include "llagent.h" -#include "llpanel.h" -#include "llbutton.h" -#include "llcolorswatch.h" -#include "llcombobox.h" -#include "llview.h" -#include "llhttpclient.h" -#include "llbufferstream.h" -#include "llcheckboxctrl.h" -#include "llviewercontrol.h" - -#include "llui.h" -#include "llcontrol.h" -#include "llscrollingpanellist.h" -#include "llautoreplace.h" -#include "llfilepicker.h" -#include "llfile.h" -#include "llsdserialize.h" -//#include "llfloaterchat.h" -#include "llchat.h" -#include "llinventorymodel.h" -#include "llhost.h" -#include "llassetstorage.h" -#include "roles_constants.h" -#include "llviewertexteditor.h" -#include - -#include -#include "llfloaterreg.h" -#include "llinspecttoast.h" -#include "llnotificationhandler.h" -#include "llnotificationmanager.h" - - -AutoReplaceFloater::AutoReplaceFloater(const LLSD& key) : -LLFloater(key) -{ -} -void AutoReplaceFloater::onClose(bool app_quitting) -{ - destroy(); -} - -BOOL AutoReplaceFloater::postBuild(void) -{ - - namesList = getChild("ac_list_name"); - entryList = getChild("ac_list_entry"); - mOldText = getChild("ac_old_text"); - mNewText = getChild("ac_new_text"); - - childSetCommitCallback("ac_enable",onBoxCommitEnabled,this); - - childSetCommitCallback("ac_list_enabled",onEntrySettingChange,this); - childSetCommitCallback("ac_list_show",onEntrySettingChange,this); - childSetCommitCallback("ac_list_style",onEntrySettingChange,this); - childSetCommitCallback("ac_priority",onEntrySettingChange,this); - - - - updateEnabledStuff(); - updateNamesList(); - - - namesList->setCommitOnSelectionChange(TRUE); - childSetCommitCallback("ac_list_name", onSelectName, this); - - childSetAction("ac_deletelist",removeList,this); - childSetAction("ac_rementry",deleteEntry,this); - childSetAction("ac_exportlist",exportList,this); - childSetAction("ac_addentry",addEntry,this); - childSetAction("ac_loadlist",loadList,this); - - return true; -} - -void AutoReplaceFloater::onSelectName(LLUICtrl* ctrl, void* user_data) -{ - if ( user_data ) - { - AutoReplaceFloater* self = ( AutoReplaceFloater* )user_data; - if ( self ) - self->updateItemsList(); - } - -} -void AutoReplaceFloater::updateItemsList() -{ - entryList->deleteAllItems(); - if((namesList->getAllSelected().size())<=0) - { - - updateListControlsEnabled(FALSE); - return; - } - - updateListControlsEnabled(TRUE); - std::string listName= namesList->getFirstSelected()->getColumn(0)->getValue().asString(); - - LLSD listData = AutoReplace::getInstance()->getAutoReplaceEntries(listName); - childSetValue("ac_list_enabled",listData["enabled"].asBoolean()); - childSetValue("ac_text_name",listName); - childSetValue("ac_priority",listData["priority"]); - - LLSD autoReplaces = listData["data"]; - LLSD::map_const_iterator loc_it = autoReplaces.beginMap(); - LLSD::map_const_iterator loc_end = autoReplaces.endMap(); - for ( ; loc_it != loc_end; ++loc_it) - { - const std::string& wrong = (*loc_it).first; - const std::string& right = (*loc_it).second; - - //std::string lentry(wrong+"=>"+right); - - LLSD element; - element["id"] = wrong; - LLSD& s_column = element["columns"][0]; - s_column["column"] = "Search"; - s_column["value"] = wrong; - s_column["font"] = "SANSSERIF"; - LLSD& r_column = element["columns"][1]; - r_column["column"] = "Replace"; - r_column["value"] = right; - r_column["font"] = "SANSSERIF"; - - entryList->addElement(element, ADD_BOTTOM); - } - -} -void AutoReplaceFloater::updateNamesList() -{ - namesList->deleteAllItems(); - if(!gSavedSettings.getBOOL("AutoReplace")) - { - updateItemsList(); - return; - } - LLSD autoReplaces = AutoReplace::getInstance()->getAutoReplaces(); - LLSD::map_const_iterator loc_it = autoReplaces.beginMap(); - LLSD::map_const_iterator loc_end = autoReplaces.endMap(); - for ( ; loc_it != loc_end; ++loc_it) - { - const std::string& listName = (*loc_it).first; - - LLSD element; - element["id"] = listName; - LLSD& friend_column = element["columns"][0]; - friend_column["column"] = "Entries"; - friend_column["value"] = listName; - //friend_column["font"] = "SANSSERIF"; - const LLSD& loc_map = (*loc_it).second; - if(loc_map["enabled"].asBoolean()) - friend_column["font"] = "SANSSERIF"; - //friend_column["style"] = "BOLD"; - else - friend_column["font"] = "SANSSERIF_SMALL"; - //friend_column["style"] = "NORMAL"; - if(namesList) - namesList->addElement(element, ADD_BOTTOM); - } - updateItemsList(); -} -void AutoReplaceFloater::updateListControlsEnabled(BOOL selected) -{ - - childSetEnabled("ac_text1",selected); - childSetEnabled("ac_text2",selected); - childSetEnabled("ac_text_name",selected); - childSetEnabled("ac_list_enabled",selected); - childSetEnabled("ac_list_show",selected); - childSetEnabled("ac_list_style",selected); - childSetEnabled("ac_deletelist",selected); - childSetEnabled("ac_exportlist",selected); - childSetEnabled("ac_addentry",selected); - childSetEnabled("ac_rementry",selected); - childSetEnabled("ac_priority",selected); - -} -void AutoReplaceFloater::updateEnabledStuff() -{ - BOOL autoreplace = gSavedSettings.getBOOL("AutoReplace"); - if(autoreplace) - { - LLCheckBoxCtrl *enBox = getChild("ac_enable"); - enBox->setDisabledColor(LLColor4::red); - getChild("ac_enable")->setEnabledColor(LLColor4(1.0f,0.0f,0.0f,1.0f)); - }else - { - getChild("ac_enable")->setEnabledColor( - LLUIColorTable::instance().getColor( "LabelTextColor" )); - } - - childSetEnabled("ac_list_name", autoreplace); - childSetEnabled("ac_list_entry", autoreplace); - updateListControlsEnabled(autoreplace); - updateNamesList(); - AutoReplace::getInstance()->save(); - -} -void AutoReplaceFloater::setData(void * data) -{ -} -void AutoReplaceFloater::onBoxCommitEnabled(LLUICtrl* caller, void* user_data) -{ - if ( user_data ) - { - AutoReplaceFloater* self = ( AutoReplaceFloater* )user_data; - if ( self ) - { - self->updateEnabledStuff(); - } - } -} -void AutoReplaceFloater::onEntrySettingChange(LLUICtrl* caller, void* user_data) -{ - if ( user_data ) - { - AutoReplaceFloater* self = ( AutoReplaceFloater* )user_data; - if ( self ) - { - std::string listName= self->namesList->getFirstSelected()->getColumn(0)->getValue().asString(); - AutoReplace::getInstance()->setListEnabled(listName,self->childGetValue("ac_list_enabled").asBoolean()); - AutoReplace::getInstance()->setListPriority(listName,self->childGetValue("ac_priority").asInteger()); - - //sInstance->updateEnabledStuff(); - self->updateItemsList(); - AutoReplace::getInstance()->save(); - } - } -} -void AutoReplaceFloater::deleteEntry(void* data) -{ - if ( data ) - { - AutoReplaceFloater* self = ( AutoReplaceFloater* )data; - if ( self ) - { - - std::string listName=self->namesList->getFirstSelected()->getColumn(0)->getValue().asString(); - - if((self->entryList->getAllSelected().size())>0) - { - std::string wrong= self->entryList->getFirstSelected()->getColumn(0)->getValue().asString(); - AutoReplace::getInstance()->removeEntryFromList(wrong,listName); - self->updateItemsList(); - AutoReplace::getInstance()->save(); - } - } - } -} -void AutoReplaceFloater::loadList(void* data) -{ - LLFilePicker& picker = LLFilePicker::instance(); - - if(!picker.getOpenFile( LLFilePicker::FFLOAD_XML) ) - {return; - } - llifstream file; - file.open(picker.getFirstFile().c_str()); - LLSD blankllsd; - if (file.is_open()) - { - LLSDSerialize::fromXMLDocument(blankllsd, file); - } - file.close(); - gSavedSettings.setBOOL("AutoReplace",true); - AutoReplace::getInstance()->addReplacementList(blankllsd); - if ( data ) - { - AutoReplaceFloater* self = ( AutoReplaceFloater* )data; - if ( self ) - self->updateEnabledStuff(); - } -} -void AutoReplaceFloater::removeList(void* data) -{ - if ( data ) - { - AutoReplaceFloater* self = ( AutoReplaceFloater* )data; - if ( self ) - { - std::string listName= self->namesList->getFirstSelected()->getColumn(0)->getValue().asString(); - AutoReplace::getInstance()->removeReplacementList(listName); - self->updateEnabledStuff(); - } - - } -} -void AutoReplaceFloater::exportList(void *data) -{ - if ( data ) - { - AutoReplaceFloater* self = ( AutoReplaceFloater* )data; - if ( self ) - { - std::string listName=self->namesList->getFirstSelected()->getColumn(0)->getValue().asString(); - - LLFilePicker& picker = LLFilePicker::instance(); - - if(!picker.getSaveFile( LLFilePicker::FFSAVE_XML) ) - {return; - } - llofstream file; - file.open(picker.getFirstFile().c_str()); - LLSDSerialize::toPrettyXML(AutoReplace::getInstance()->exportList(listName), file); - file.close(); - } - - } -} -void AutoReplaceFloater::addEntry(void* data) -{ - if ( data ) - { - AutoReplaceFloater* self = ( AutoReplaceFloater* )data; - if ( self ) - { - std::string listName= self->namesList->getFirstSelected()->getColumn(0)->getValue().asString(); - std::string wrong = self->mOldText->getText(); - std::string right = self->mNewText->getText(); - if(wrong != "" && right != "") - { - AutoReplace::getInstance()->addEntryToList(wrong, right, listName); - self->updateItemsList(); - AutoReplace::getInstance()->save(); - } - } - } -} -AutoReplaceFloater* AutoReplaceFloater::showFloater() -{ - AutoReplaceFloater *floater = dynamic_cast(LLFloaterReg::getInstance("autoreplace")); - if(floater) - { - floater->setVisible(true); - floater->setFrontmost(true); - floater->center(); - return floater; - } - else - { - LL_WARNS("AutoReplace") << "Can't find floater!" << LL_ENDL; - return NULL; - } -} diff --git a/indra/newview/llautoreplacefloater.h b/indra/newview/llautoreplacefloater.h deleted file mode 100644 index 213cf93a30..0000000000 --- a/indra/newview/llautoreplacefloater.h +++ /dev/null @@ -1,75 +0,0 @@ -/** - * @file llautoreplacefloater.h - * @brief Auto Replace List floater - * @copyright Copyright (c) 2011 LordGregGreg Back - * - * $LicenseInfo:firstyear=2012&license=viewerlgpl$ - * Second Life Viewer Source Code - * Copyright (C) 2012, Linden Research, Inc. - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * $/LicenseInfo$ - */ - -#ifndef AUTOREPLACEFLOATER_H -#define AUTOREPLACEFLOATER_H - -#include "llfloater.h" -#include "llmediactrl.h" -#include "llscrolllistctrl.h" -#include "lllineeditor.h" - -#include "llviewerinventory.h" -#include - -class AutoReplaceFloater : -public LLFloater -{ -public: - AutoReplaceFloater(const LLSD& key); - - /*virtual*/ BOOL postBuild(); - /*virtual*/ void onClose(bool app_quitting); - - static AutoReplaceFloater* showFloater(); - - void setData(void * data); - void updateEnabledStuff(); - void updateNamesList(); - void updateListControlsEnabled(BOOL selected); - void updateItemsList(); - - LLScrollListCtrl *namesList; - LLScrollListCtrl *entryList; - LLLineEditor* mOldText; - LLLineEditor* mNewText; - //LLPanel * empanel; -private: - //static JCInvDropTarget* mNotecardDropTarget; - static void onBoxCommitEnabled(LLUICtrl* caller, void* user_data); - static void onEntrySettingChange(LLUICtrl* caller, void* user_data); - static void onSelectName(LLUICtrl* caller, void* user_data); - //static void ResponseItemDrop(LLViewerInventoryItem* item); - //static void onNotecardLoadComplete(LLVFS *vfs,const LLUUID& asset_uuid,LLAssetType::EType type,void* user_data, S32 status, LLExtStat ext_status); - - - static void deleteEntry(void* data); - static void addEntry(void* data); - static void exportList(void* data); - static void removeList(void* data); - static void loadList(void* data); -}; - -#endif // AUTOREPLACEFLOATER_H diff --git a/indra/newview/llfloaterautoreplacesettings.cpp b/indra/newview/llfloaterautoreplacesettings.cpp new file mode 100644 index 0000000000..3dfcfba936 --- /dev/null +++ b/indra/newview/llfloaterautoreplacesettings.cpp @@ -0,0 +1,367 @@ +/** + * @file llautoreplacefloater.cpp + * @brief Auto Replace List floater + * + * $LicenseInfo:firstyear=2012&license=viewerlgpl$ + * Second Life Viewer Source Code + * Copyright (C) 2012, Linden Research, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * $/LicenseInfo$ + */ + +#include "llviewerprecompiledheaders.h" + +#include "llfloaterautoreplacesettings.h" + +#include "llagentdata.h" +#include "llcommandhandler.h" +#include "llfloater.h" +#include "lluictrlfactory.h" +#include "llagent.h" +#include "llpanel.h" +#include "llbutton.h" +#include "llcolorswatch.h" +#include "llcombobox.h" +#include "llview.h" +#include "llhttpclient.h" +#include "llbufferstream.h" +#include "llcheckboxctrl.h" +#include "llviewercontrol.h" + +#include "llui.h" +#include "llcontrol.h" +#include "llscrollingpanellist.h" +#include "llautoreplace.h" +#include "llfilepicker.h" +#include "llfile.h" +#include "llsdserialize.h" +//#include "llfloaterchat.h" +#include "llchat.h" +#include "llinventorymodel.h" +#include "llhost.h" +#include "llassetstorage.h" +#include "roles_constants.h" +#include "llviewertexteditor.h" +#include + +#include +#include "llfloaterreg.h" +#include "llinspecttoast.h" +#include "llnotificationhandler.h" +#include "llnotificationmanager.h" + + +LLFloaterAutoReplaceSettings::LLFloaterAutoReplaceSettings(const LLSD& key) + : LLFloater(key) + , namesList(NULL) + , entryList(NULL) + , mOldText(NULL) + , mNewText(NULL) +{ +} +void LLFloaterAutoReplaceSettings::onClose(bool app_quitting) +{ + destroy(); +} + +BOOL LLFloaterAutoReplaceSettings::postBuild(void) +{ + + namesList = getChild("ac_list_name"); + entryList = getChild("ac_list_entry"); + mOldText = getChild("ac_old_text"); + mNewText = getChild("ac_new_text"); + + childSetCommitCallback("ac_enable",onBoxCommitEnabled,this); + + childSetCommitCallback("ac_list_enabled",onEntrySettingChange,this); + childSetCommitCallback("ac_list_show",onEntrySettingChange,this); + childSetCommitCallback("ac_list_style",onEntrySettingChange,this); + childSetCommitCallback("ac_priority",onEntrySettingChange,this); + + updateEnabledStuff(); + updateNamesList(); + + namesList->setCommitOnSelectionChange(TRUE); + childSetCommitCallback("ac_list_name", onSelectName, this); + + childSetAction("ac_deletelist",removeList,this); + childSetAction("ac_rementry",deleteEntry,this); + childSetAction("ac_exportlist",exportList,this); + childSetAction("ac_addentry",addEntry,this); + childSetAction("ac_loadlist",loadList,this); + + return true; +} + +void LLFloaterAutoReplaceSettings::onSelectName(LLUICtrl* ctrl, void* user_data) +{ + if ( user_data ) + { + LLFloaterAutoReplaceSettings* self = ( LLFloaterAutoReplaceSettings* )user_data; + if ( self ) + { + self->updateItemsList(); + } + } +} +void LLFloaterAutoReplaceSettings::updateItemsList() +{ + entryList->deleteAllItems(); + if((namesList->getAllSelected().size())<=0) + { + updateListControlsEnabled(FALSE); + return; + } + + updateListControlsEnabled(TRUE); + std::string listName= namesList->getFirstSelected()->getColumn(0)->getValue().asString(); + + LLSD listData = AutoReplace::getInstance()->getAutoReplaceEntries(listName); + childSetValue("ac_list_enabled",listData["enabled"].asBoolean()); + childSetValue("ac_text_name",listName); + childSetValue("ac_priority",listData["priority"]); + + LLSD autoReplaces = listData["data"]; + LLSD::map_const_iterator loc_it = autoReplaces.beginMap(); + LLSD::map_const_iterator loc_end = autoReplaces.endMap(); + for ( ; loc_it != loc_end; ++loc_it) + { + const std::string& wrong = (*loc_it).first; + const std::string& right = (*loc_it).second; + + LLSD element; + element["id"] = wrong; + LLSD& s_column = element["columns"][0]; + s_column["column"] = "Search"; + s_column["value"] = wrong; + s_column["font"] = "SANSSERIF"; + LLSD& r_column = element["columns"][1]; + r_column["column"] = "Replace"; + r_column["value"] = right; + r_column["font"] = "SANSSERIF"; + + entryList->addElement(element, ADD_BOTTOM); + } + +} +void LLFloaterAutoReplaceSettings::updateNamesList() +{ + namesList->deleteAllItems(); + if(!gSavedSettings.getBOOL("AutoReplace")) + { + updateItemsList(); + return; + } + LLSD autoReplaces = AutoReplace::getInstance()->getAutoReplaces(); + LLSD::map_const_iterator loc_it = autoReplaces.beginMap(); + LLSD::map_const_iterator loc_end = autoReplaces.endMap(); + for ( ; loc_it != loc_end; ++loc_it) + { + const std::string& listName = (*loc_it).first; + + LLSD element; + element["id"] = listName; + LLSD& friend_column = element["columns"][0]; + friend_column["column"] = "Entries"; + friend_column["value"] = listName; + //friend_column["font"] = "SANSSERIF"; + const LLSD& loc_map = (*loc_it).second; + if(loc_map["enabled"].asBoolean()) + { + friend_column["font"] = "SANSSERIF"; + } + else + { + friend_column["font"] = "SANSSERIF_SMALL"; + } + if(namesList) + { + namesList->addElement(element, ADD_BOTTOM); + } + } + updateItemsList(); +} +void LLFloaterAutoReplaceSettings::updateListControlsEnabled(BOOL selected) +{ + + childSetEnabled("ac_text1",selected); + childSetEnabled("ac_text2",selected); + childSetEnabled("ac_text_name",selected); + childSetEnabled("ac_list_enabled",selected); + childSetEnabled("ac_list_show",selected); + childSetEnabled("ac_list_style",selected); + childSetEnabled("ac_deletelist",selected); + childSetEnabled("ac_exportlist",selected); + childSetEnabled("ac_addentry",selected); + childSetEnabled("ac_rementry",selected); + childSetEnabled("ac_priority",selected); + +} +void LLFloaterAutoReplaceSettings::updateEnabledStuff() +{ + BOOL autoreplace = gSavedSettings.getBOOL("AutoReplace"); + if(autoreplace) + { + LLCheckBoxCtrl *enBox = getChild("ac_enable"); + enBox->setDisabledColor(LLColor4::red); + getChild("ac_enable")->setEnabledColor(LLColor4(1.0f,0.0f,0.0f,1.0f)); + } + else + { + getChild("ac_enable")->setEnabledColor( + LLUIColorTable::instance().getColor( "LabelTextColor" )); + } + + childSetEnabled("ac_list_name", autoreplace); + childSetEnabled("ac_list_entry", autoreplace); + updateListControlsEnabled(autoreplace); + updateNamesList(); + AutoReplace::getInstance()->save(); + +} +void LLFloaterAutoReplaceSettings::setData(void * data) +{ +} +void LLFloaterAutoReplaceSettings::onBoxCommitEnabled(LLUICtrl* caller, void* user_data) +{ + if ( user_data ) + { + LLFloaterAutoReplaceSettings* self = ( LLFloaterAutoReplaceSettings* )user_data; + if ( self ) + { + self->updateEnabledStuff(); + } + } +} +void LLFloaterAutoReplaceSettings::onEntrySettingChange(LLUICtrl* caller, void* user_data) +{ + if ( user_data ) + { + LLFloaterAutoReplaceSettings* self = ( LLFloaterAutoReplaceSettings* )user_data; + if ( self ) + { + std::string listName= self->namesList->getFirstSelected()->getColumn(0)->getValue().asString(); + AutoReplace::getInstance()->setListEnabled(listName,self->childGetValue("ac_list_enabled").asBoolean()); + AutoReplace::getInstance()->setListPriority(listName,self->childGetValue("ac_priority").asInteger()); + + //sInstance->updateEnabledStuff(); + self->updateItemsList(); + AutoReplace::getInstance()->save(); + } + } +} +void LLFloaterAutoReplaceSettings::deleteEntry(void* data) +{ + if ( data ) + { + LLFloaterAutoReplaceSettings* self = ( LLFloaterAutoReplaceSettings* )data; + if ( self ) + { + + std::string listName=self->namesList->getFirstSelected()->getColumn(0)->getValue().asString(); + + if((self->entryList->getAllSelected().size())>0) + { + std::string wrong= self->entryList->getFirstSelected()->getColumn(0)->getValue().asString(); + AutoReplace::getInstance()->removeEntryFromList(wrong,listName); + self->updateItemsList(); + AutoReplace::getInstance()->save(); + } + } + } +} +void LLFloaterAutoReplaceSettings::loadList(void* data) +{ + LLFilePicker& picker = LLFilePicker::instance(); + + if(!picker.getOpenFile( LLFilePicker::FFLOAD_XML) ) + { + return; + } + llifstream file; + file.open(picker.getFirstFile().c_str()); + LLSD blankllsd; + if (file.is_open()) + { + LLSDSerialize::fromXMLDocument(blankllsd, file); + } + file.close(); + gSavedSettings.setBOOL("AutoReplace",true); + AutoReplace::getInstance()->addReplacementList(blankllsd); + if ( data ) + { + LLFloaterAutoReplaceSettings* self = ( LLFloaterAutoReplaceSettings* )data; + if ( self ) + { + self->updateEnabledStuff(); + } + } +} +void LLFloaterAutoReplaceSettings::removeList(void* data) +{ + if ( data ) + { + LLFloaterAutoReplaceSettings* self = ( LLFloaterAutoReplaceSettings* )data; + if ( self ) + { + std::string listName= self->namesList->getFirstSelected()->getColumn(0)->getValue().asString(); + AutoReplace::getInstance()->removeReplacementList(listName); + self->updateEnabledStuff(); + } + + } +} +void LLFloaterAutoReplaceSettings::exportList(void *data) +{ + if ( data ) + { + LLFloaterAutoReplaceSettings* self = ( LLFloaterAutoReplaceSettings* )data; + if ( self ) + { + std::string listName=self->namesList->getFirstSelected()->getColumn(0)->getValue().asString(); + + LLFilePicker& picker = LLFilePicker::instance(); + if(picker.getSaveFile( LLFilePicker::FFSAVE_XML) ) + { + llofstream file; + file.open(picker.getFirstFile().c_str()); + LLSDSerialize::toPrettyXML(AutoReplace::getInstance()->exportList(listName), file); + file.close(); + } + } + } +} +void LLFloaterAutoReplaceSettings::addEntry(void* data) +{ + if ( data ) + { + LLFloaterAutoReplaceSettings* self = ( LLFloaterAutoReplaceSettings* )data; + if ( self ) + { + std::string listName= self->namesList->getFirstSelected()->getColumn(0)->getValue().asString(); + std::string wrong = self->mOldText->getText(); + std::string right = self->mNewText->getText(); + if(wrong != "" && right != "") + { + AutoReplace::getInstance()->addEntryToList(wrong, right, listName); + self->updateItemsList(); + AutoReplace::getInstance()->save(); + } + } + } +} + diff --git a/indra/newview/llfloaterautoreplacesettings.h b/indra/newview/llfloaterautoreplacesettings.h new file mode 100644 index 0000000000..dd0acb613b --- /dev/null +++ b/indra/newview/llfloaterautoreplacesettings.h @@ -0,0 +1,70 @@ +/** + * @file llfloaterautoreplacesettings.h + * @brief Auto Replace List floater + * @copyright Copyright (c) 2011 LordGregGreg Back + * + * $LicenseInfo:firstyear=2012&license=viewerlgpl$ + * Second Life Viewer Source Code + * Copyright (C) 2012, Linden Research, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * $/LicenseInfo$ + */ + +#ifndef LLFLOATERAUTOREPLACESETTINGS_H +#define LLFLOATERAUTOREPLACESETTINGS_H + +#include "llfloater.h" +#include "llmediactrl.h" +#include "llscrolllistctrl.h" +#include "lllineeditor.h" + +#include "llviewerinventory.h" +#include + +class LLFloaterAutoReplaceSettings : +public LLFloater +{ +public: + LLFloaterAutoReplaceSettings(const LLSD& key); + + /*virtual*/ BOOL postBuild(); + /*virtual*/ void onClose(bool app_quitting); + + void setData(void * data); + void updateEnabledStuff(); + void updateNamesList(); + void updateListControlsEnabled(BOOL selected); + void updateItemsList(); + + LLScrollListCtrl *namesList; + LLScrollListCtrl *entryList; + LLLineEditor* mOldText; + LLLineEditor* mNewText; + +private: + + static void onBoxCommitEnabled(LLUICtrl* caller, void* user_data); + static void onEntrySettingChange(LLUICtrl* caller, void* user_data); + static void onSelectName(LLUICtrl* caller, void* user_data); + + static void deleteEntry(void* data); + static void addEntry(void* data); + static void exportList(void* data); + static void removeList(void* data); + static void loadList(void* data); +}; + +#endif // LLFLOATERAUTOREPLACESETTINGS_H diff --git a/indra/newview/llfloaterpreference.cpp b/indra/newview/llfloaterpreference.cpp index 7ef8125896..2c383f09ba 100755 --- a/indra/newview/llfloaterpreference.cpp +++ b/indra/newview/llfloaterpreference.cpp @@ -35,7 +35,7 @@ #include "llfloaterpreference.h" #include "message.h" -#include "llautoreplacefloater.h" +#include "llfloaterautoreplacesettings.h" #include "llagent.h" #include "llavatarconstants.h" #include "llcheckboxctrl.h" @@ -346,7 +346,7 @@ LLFloaterPreference::LLFloaterPreference(const LLSD& key) mCommitCallbackRegistrar.add("Pref.BlockList", boost::bind(&LLFloaterPreference::onClickBlockList, this)); mCommitCallbackRegistrar.add("Pref.Proxy", boost::bind(&LLFloaterPreference::onClickProxySettings, this)); mCommitCallbackRegistrar.add("Pref.TranslationSettings", boost::bind(&LLFloaterPreference::onClickTranslationSettings, this)); - mCommitCallbackRegistrar.add("Pref.AutoReplace.", boost::bind(&AutoReplaceFloater::showFloater, this)); + mCommitCallbackRegistrar.add("Pref.AutoReplace", boost::bind(&LLFloaterPreference::onClickAutoReplace, this)); sSkin = gSavedSettings.getString("SkinCurrent"); @@ -605,6 +605,9 @@ void LLFloaterPreference::cancel() // hide translation settings floater LLFloaterReg::hideInstance("prefs_translation"); + // hide translation settings floater + LLFloaterReg::hideInstance("prefs_autoreplace"); + // cancel hardware menu LLFloaterHardwareSettings* hardware_settings = LLFloaterReg::getTypedInstance("prefs_hardware_settings"); if (hardware_settings) @@ -1516,6 +1519,11 @@ void LLFloaterPreference::onClickTranslationSettings() LLFloaterReg::showInstance("prefs_translation"); } +void LLFloaterPreference::onClickAutoReplace() +{ + LLFloaterReg::showInstance("prefs_autoreplace"); +} + void LLFloaterPreference::onClickActionChange() { mClickActionDirty = true; diff --git a/indra/newview/llfloaterpreference.h b/indra/newview/llfloaterpreference.h index ec5994e917..0b63002345 100644 --- a/indra/newview/llfloaterpreference.h +++ b/indra/newview/llfloaterpreference.h @@ -157,6 +157,7 @@ public: void onClickBlockList(); void onClickProxySettings(); void onClickTranslationSettings(); + void onClickAutoReplace(); void applyUIColor(LLUICtrl* ctrl, const LLSD& param); void getUIColor(LLUICtrl* ctrl, const LLSD& param); diff --git a/indra/newview/llviewerfloaterreg.cpp b/indra/newview/llviewerfloaterreg.cpp index b2480a1805..d66f742a70 100644 --- a/indra/newview/llviewerfloaterreg.cpp +++ b/indra/newview/llviewerfloaterreg.cpp @@ -30,7 +30,7 @@ #include "llfloaterreg.h" #include "llviewerfloaterreg.h" -#include "llautoreplacefloater.h" +#include "llfloaterautoreplacesettings.h" #include "llcompilequeue.h" #include "llcallfloater.h" #include "llfasttimerview.h" @@ -170,7 +170,6 @@ void LLViewerFloaterReg::registerFloaters() LLFloaterReg::add("about_land", "floater_about_land.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("appearance", "floater_my_appearance.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("auction", "floater_auction.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); - LLFloaterReg::add("settings_autoreplace", "floater_autoreplace.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("avatar", "floater_avatar.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("avatar_picker", "floater_avatar_picker.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("avatar_textures", "floater_avatar_textures.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); @@ -250,6 +249,7 @@ void LLViewerFloaterReg::registerFloaters() LLFloaterReg::add("prefs_proxy", "floater_preferences_proxy.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("prefs_hardware_settings", "floater_hardware_settings.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("prefs_translation", "floater_translation_settings.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); + LLFloaterReg::add("prefs_autoreplace", "floater_autoreplace.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("perm_prefs", "floater_perm_prefs.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("picks", "floater_picks.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("pref_joystick", "floater_joystick.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); diff --git a/indra/newview/skins/default/xui/en/floater_autoreplace.xml b/indra/newview/skins/default/xui/en/floater_autoreplace.xml index f68aeacb97..17f64c1433 100644 --- a/indra/newview/skins/default/xui/en/floater_autoreplace.xml +++ b/indra/newview/skins/default/xui/en/floater_autoreplace.xml @@ -96,7 +96,7 @@ -- cgit v1.3 From dd5d7fadca40b43a597b1af14d94273286498ab8 Mon Sep 17 00:00:00 2001 From: Jonathan Yap Date: Fri, 18 May 2012 12:12:42 -0400 Subject: STORM-1860 Remove obsolete code and file(s) for mesh model upload wizard --- doc/contributions.txt | 1 + indra/newview/CMakeLists.txt | 2 - indra/newview/llfloatermodelpreview.cpp | 11 +- indra/newview/llfloatermodelpreview.h | 4 +- indra/newview/llfloatermodelwizard.cpp | 795 ------------------- indra/newview/llfloatermodelwizard.h | 140 ---- indra/newview/llviewerfloaterreg.cpp | 2 - .../skins/default/xui/da/floater_model_wizard.xml | 241 ------ .../skins/default/xui/de/floater_model_wizard.xml | 208 ----- .../skins/default/xui/en/floater_model_wizard.xml | 841 --------------------- .../skins/default/xui/es/floater_model_wizard.xml | 208 ----- .../skins/default/xui/fr/floater_model_wizard.xml | 208 ----- .../skins/default/xui/it/floater_model_wizard.xml | 208 ----- .../skins/default/xui/ja/floater_model_wizard.xml | 208 ----- .../skins/default/xui/pt/floater_model_wizard.xml | 208 ----- .../skins/default/xui/ru/floater_model_wizard.xml | 208 ----- .../skins/default/xui/tr/floater_model_wizard.xml | 208 ----- 17 files changed, 3 insertions(+), 3698 deletions(-) delete mode 100644 indra/newview/llfloatermodelwizard.cpp delete mode 100644 indra/newview/llfloatermodelwizard.h delete mode 100644 indra/newview/skins/default/xui/da/floater_model_wizard.xml delete mode 100644 indra/newview/skins/default/xui/de/floater_model_wizard.xml delete mode 100644 indra/newview/skins/default/xui/en/floater_model_wizard.xml delete mode 100644 indra/newview/skins/default/xui/es/floater_model_wizard.xml delete mode 100644 indra/newview/skins/default/xui/fr/floater_model_wizard.xml delete mode 100644 indra/newview/skins/default/xui/it/floater_model_wizard.xml delete mode 100644 indra/newview/skins/default/xui/ja/floater_model_wizard.xml delete mode 100644 indra/newview/skins/default/xui/pt/floater_model_wizard.xml delete mode 100644 indra/newview/skins/default/xui/ru/floater_model_wizard.xml delete mode 100644 indra/newview/skins/default/xui/tr/floater_model_wizard.xml (limited to 'indra/newview/llviewerfloaterreg.cpp') diff --git a/doc/contributions.txt b/doc/contributions.txt index 3851e62cfb..ca131d826b 100644 --- a/doc/contributions.txt +++ b/doc/contributions.txt @@ -625,6 +625,7 @@ Jonathan Yap STORM-1809 STORM-1793 STORM-1810 + STORM-1860 Kadah Coba STORM-1060 Jondan Lundquist diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt index 3c9bde34b7..87754c0acc 100644 --- a/indra/newview/CMakeLists.txt +++ b/indra/newview/CMakeLists.txt @@ -211,7 +211,6 @@ set(viewer_SOURCE_FILES llfloatermemleak.cpp llfloatermodelpreview.cpp llfloatermodeluploadbase.cpp - llfloatermodelwizard.cpp llfloaternamedesc.cpp llfloaternotificationsconsole.cpp llfloaterobjectweights.cpp @@ -767,7 +766,6 @@ set(viewer_HEADER_FILES llfloatermemleak.h llfloatermodelpreview.h llfloatermodeluploadbase.h - llfloatermodelwizard.h llfloaternamedesc.h llfloaternotificationsconsole.h llfloaterobjectweights.h diff --git a/indra/newview/llfloatermodelpreview.cpp b/indra/newview/llfloatermodelpreview.cpp index 7448f2bb2a..4b8beba546 100755 --- a/indra/newview/llfloatermodelpreview.cpp +++ b/indra/newview/llfloatermodelpreview.cpp @@ -5053,15 +5053,7 @@ BOOL LLModelPreview::render() LLRect preview_rect; - LLFloaterModelWizard* floater_wizard = dynamic_cast(mFMP); - if (floater_wizard) - { - preview_rect = floater_wizard->getPreviewRect(); - } - else - { - preview_rect = mFMP->getChildView("preview_panel")->getRect(); - } + preview_rect = mFMP->getChildView("preview_panel")->getRect(); F32 aspect = (F32) preview_rect.getWidth()/preview_rect.getHeight(); @@ -5605,7 +5597,6 @@ void LLModelPreview::setPreviewLOD(S32 lod) combo_box->setCurrentByIndex((NUM_LOD-1)-mPreviewLOD); // combo box list of lods is in reverse order mFMP->childSetText("lod_file_" + lod_name[mPreviewLOD], mLODFile[mPreviewLOD]); - // the wizard has three lod drop downs LLComboBox* combo_box2 = mFMP->getChild("preview_lod_combo2"); combo_box2->setCurrentByIndex((NUM_LOD-1)-mPreviewLOD); // combo box list of lods is in reverse order diff --git a/indra/newview/llfloatermodelpreview.h b/indra/newview/llfloatermodelpreview.h index 64324854a5..c522e6f734 100644 --- a/indra/newview/llfloatermodelpreview.h +++ b/indra/newview/llfloatermodelpreview.h @@ -30,12 +30,12 @@ #include "llfloaternamedesc.h" #include "lldynamictexture.h" -#include "llfloatermodelwizard.h" #include "llquaternion.h" #include "llmeshrepository.h" #include "llmodel.h" #include "llthread.h" #include "llviewermenufile.h" +#include "llfloatermodeluploadbase.h" class LLComboBox; class LLJoint; @@ -390,9 +390,7 @@ private: protected: friend class LLModelLoader; friend class LLFloaterModelPreview; - friend class LLFloaterModelWizard; friend class LLFloaterModelPreview::DecompRequest; - friend class LLFloaterModelWizard::DecompRequest; friend class LLPhysicsDecomp; LLFloater* mFMP; diff --git a/indra/newview/llfloatermodelwizard.cpp b/indra/newview/llfloatermodelwizard.cpp deleted file mode 100644 index b517b78e5a..0000000000 --- a/indra/newview/llfloatermodelwizard.cpp +++ /dev/null @@ -1,795 +0,0 @@ -/** - * @file llfloatermodelwizard.cpp - * @author Leyla Farazha - * @brief Implementation of the LLFloaterModelWizard class. - * - * $LicenseInfo:firstyear=2002&license=viewerlgpl$ - * Second Life Viewer Source Code - * Copyright (C) 2010, Linden Research, Inc. - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; - * version 2.1 of the License only. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * - * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA - * $/LicenseInfo$ - */ - - -#include "llviewerprecompiledheaders.h" - -#include "llbutton.h" -#include "lldrawable.h" -#include "llcheckboxctrl.h" -#include "llcombobox.h" -#include "llfloater.h" -#include "llfloatermodelwizard.h" -#include "llfloatermodelpreview.h" -#include "llfloaterreg.h" -#include "llsliderctrl.h" -#include "lltoolmgr.h" -#include "llviewerwindow.h" - -LLFloaterModelWizard* LLFloaterModelWizard::sInstance = NULL; - -static const std::string stateNames[]={ - "choose_file", - "optimize", - "physics", - "review", - "upload"}; - -static void swap_controls(LLUICtrl* first_ctrl, LLUICtrl* second_ctrl, bool first_ctr_visible); - -LLFloaterModelWizard::LLFloaterModelWizard(const LLSD& key) - : LLFloaterModelUploadBase(key) - ,mRecalculateGeometryBtn(NULL) - ,mRecalculatePhysicsBtn(NULL) - ,mRecalculatingPhysicsBtn(NULL) - ,mCalculateWeightsBtn(NULL) - ,mCalculatingWeightsBtn(NULL) - ,mChooseFilePreviewPanel(NULL) - ,mOptimizePreviewPanel(NULL) - ,mPhysicsPreviewPanel(NULL) -{ - mLastEnabledState = CHOOSE_FILE; - sInstance = this; - - mCommitCallbackRegistrar.add("Wizard.Choose", boost::bind(&LLFloaterModelWizard::setState, this, CHOOSE_FILE)); - mCommitCallbackRegistrar.add("Wizard.Optimize", boost::bind(&LLFloaterModelWizard::setState, this, OPTIMIZE)); - mCommitCallbackRegistrar.add("Wizard.Physics", boost::bind(&LLFloaterModelWizard::setState, this, PHYSICS)); - mCommitCallbackRegistrar.add("Wizard.Review", boost::bind(&LLFloaterModelWizard::setState, this, REVIEW)); - mCommitCallbackRegistrar.add("Wizard.Upload", boost::bind(&LLFloaterModelWizard::setState, this, UPLOAD)); -} -LLFloaterModelWizard::~LLFloaterModelWizard() -{ - sInstance = NULL; -} -void LLFloaterModelWizard::setState(int state) -{ - - mState = state; - - for(size_t t=0; tsetVisible(state == (int) t ? TRUE : FALSE); - } - } - - LLView* current_preview_panel = NULL; - - if (state == CHOOSE_FILE) - { - mModelPreview->mViewOption["show_physics"] = false; - - current_preview_panel = mChooseFilePreviewPanel; - - getChildView("close")->setVisible(false); - getChildView("back")->setVisible(true); - getChildView("back")->setEnabled(false); - getChildView("next")->setVisible(true); - getChildView("upload")->setVisible(false); - getChildView("cancel")->setVisible(true); - mCalculateWeightsBtn->setVisible(false); - mCalculatingWeightsBtn->setVisible(false); - } - - if (state == OPTIMIZE) - { - if (mLastEnabledState < state) - { - mModelPreview->genLODs(-1); - } - - mModelPreview->mViewOption["show_physics"] = false; - - current_preview_panel = mOptimizePreviewPanel; - - getChildView("back")->setVisible(true); - getChildView("back")->setEnabled(true); - getChildView("close")->setVisible(false); - getChildView("next")->setVisible(true); - getChildView("upload")->setVisible(false); - getChildView("cancel")->setVisible(true); - mCalculateWeightsBtn->setVisible(false); - mCalculatingWeightsBtn->setVisible(false); - } - - if (state == PHYSICS) - { - if (mLastEnabledState < state) - { - mModelPreview->setPhysicsFromLOD(1); - - // Trigger the recalculate physics when first entering - // the Physics step. - onClickRecalculatePhysics(); - } - - mModelPreview->mViewOption["show_physics"] = true; - - current_preview_panel = mPhysicsPreviewPanel; - - getChildView("next")->setVisible(false); - getChildView("upload")->setVisible(false); - getChildView("close")->setVisible(false); - getChildView("back")->setVisible(true); - getChildView("back")->setEnabled(true); - getChildView("cancel")->setVisible(true); - mCalculateWeightsBtn->setVisible(true); - mCalculatingWeightsBtn->setVisible(false); - } - - if (state == REVIEW) - { - - mModelPreview->mViewOption["show_physics"] = false; - - getChildView("close")->setVisible(false); - getChildView("next")->setVisible(false); - getChildView("back")->setVisible(true); - getChildView("back")->setEnabled(true); - getChildView("upload")->setVisible(true); - getChildView("cancel")->setVisible(true); - mCalculateWeightsBtn->setVisible(false); - mCalculatingWeightsBtn->setVisible(false); - } - - if (state == UPLOAD) - { - getChildView("close")->setVisible(true); - getChildView("next")->setVisible(false); - getChildView("back")->setVisible(false); - getChildView("upload")->setVisible(false); - getChildView("cancel")->setVisible(false); - mCalculateWeightsBtn->setVisible(false); - mCalculatingWeightsBtn->setVisible(false); - } - - if (current_preview_panel) - { - LLRect rect; - current_preview_panel->localRectToOtherView(current_preview_panel->getLocalRect(), &rect, this); - - // Reduce the preview rect by 1 px to fit the borders - rect.stretch(-1); - - if (rect != mPreviewRect) - { - mPreviewRect = rect; - mModelPreview->refresh(); - } - } - updateButtons(); -} - - - -void LLFloaterModelWizard::updateButtons() -{ - if (mLastEnabledState < mState) - { - mLastEnabledState = mState; - } - - for(size_t i=0; i(stateNames[i]+"_btn"); - - if (i == mState) - { - button->setEnabled(TRUE); - button->setToggleState(TRUE); - } - else if (i <= mLastEnabledState) - { - button->setEnabled(TRUE); - button->setToggleState(FALSE); - } - else - { - button->setEnabled(FALSE); - } - } -} - -void LLFloaterModelWizard::onClickSwitchToAdvanced() -{ - LLFloaterModelPreview* floater_preview = LLFloaterReg::getTypedInstance("upload_model"); - if (!floater_preview) - { - llwarns << "FLoater model preview not found." << llendl; - return; - } - - // Open floater model preview - floater_preview->openFloater(); - - // Close the wizard - closeFloater(); - - std::string filename = getChild("lod_file")->getValue().asString(); - if (!filename.empty()) - { - // Re-load the model to the floater model preview if it has been loaded - // into the wizard. - floater_preview->loadModel(3, filename); - } -} - -void LLFloaterModelWizard::onClickRecalculateGeometry() -{ - S32 val = getChild("accuracy_slider")->getValue().asInteger(); - - mModelPreview->genLODs(-1, NUM_LOD - val); - - mModelPreview->refresh(); -} - -void LLFloaterModelWizard::onClickRecalculatePhysics() -{ - // Hide the "Recalculate physics" button and show the "Recalculating..." - // button instead. - swap_controls(mRecalculatePhysicsBtn, mRecalculatingPhysicsBtn, false); - - executePhysicsStage("Decompose"); -} - -void LLFloaterModelWizard::onClickCalculateUploadFee() -{ - swap_controls(mCalculateWeightsBtn, mCalculatingWeightsBtn, false); - - mModelPreview->rebuildUploadData(); - - mUploadModelUrl.clear(); - - gMeshRepo.uploadModel(mModelPreview->mUploadData, mModelPreview->mPreviewScale, - true, false, false, mUploadModelUrl, false, getWholeModelFeeObserverHandle()); -} - -void LLFloaterModelWizard::loadModel() -{ - mModelPreview->mLoading = TRUE; - - (new LLMeshFilePicker(mModelPreview, 3))->getFile(); -} - -void LLFloaterModelWizard::onClickCancel() -{ - closeFloater(); -} - -void LLFloaterModelWizard::onClickBack() -{ - setState(llmax((int) CHOOSE_FILE, mState-1)); -} - -void LLFloaterModelWizard::onClickNext() -{ - setState(llmin((int) UPLOAD, mState+1)); -} - -bool LLFloaterModelWizard::onEnableNext() -{ - return true; -} - -bool LLFloaterModelWizard::onEnableBack() -{ - return true; -} - - -//----------------------------------------------------------------------------- -// handleMouseDown() -//----------------------------------------------------------------------------- -BOOL LLFloaterModelWizard::handleMouseDown(S32 x, S32 y, MASK mask) -{ - if (mPreviewRect.pointInRect(x, y)) - { - bringToFront( x, y ); - gFocusMgr.setMouseCapture(this); - gViewerWindow->hideCursor(); - mLastMouseX = x; - mLastMouseY = y; - return TRUE; - } - - return LLFloater::handleMouseDown(x, y, mask); -} - -//----------------------------------------------------------------------------- -// handleMouseUp() -//----------------------------------------------------------------------------- -BOOL LLFloaterModelWizard::handleMouseUp(S32 x, S32 y, MASK mask) -{ - gFocusMgr.setMouseCapture(FALSE); - gViewerWindow->showCursor(); - return LLFloater::handleMouseUp(x, y, mask); -} - -//----------------------------------------------------------------------------- -// handleHover() -//----------------------------------------------------------------------------- -BOOL LLFloaterModelWizard::handleHover (S32 x, S32 y, MASK mask) -{ - MASK local_mask = mask & ~MASK_ALT; - - if (mModelPreview && hasMouseCapture()) - { - if (local_mask == MASK_PAN) - { - // pan here - mModelPreview->pan((F32)(x - mLastMouseX) * -0.005f, (F32)(y - mLastMouseY) * -0.005f); - } - else if (local_mask == MASK_ORBIT) - { - F32 yaw_radians = (F32)(x - mLastMouseX) * -0.01f; - F32 pitch_radians = (F32)(y - mLastMouseY) * 0.02f; - - mModelPreview->rotate(yaw_radians, pitch_radians); - } - else - { - - F32 yaw_radians = (F32)(x - mLastMouseX) * -0.01f; - F32 zoom_amt = (F32)(y - mLastMouseY) * 0.02f; - - mModelPreview->rotate(yaw_radians, 0.f); - mModelPreview->zoom(zoom_amt); - } - - - mModelPreview->refresh(); - - LLUI::setMousePositionLocal(this, mLastMouseX, mLastMouseY); - } - - if (!mPreviewRect.pointInRect(x, y) || !mModelPreview) - { - return LLFloater::handleHover(x, y, mask); - } - else if (local_mask == MASK_ORBIT) - { - gViewerWindow->setCursor(UI_CURSOR_TOOLCAMERA); - } - else if (local_mask == MASK_PAN) - { - gViewerWindow->setCursor(UI_CURSOR_TOOLPAN); - } - else - { - gViewerWindow->setCursor(UI_CURSOR_TOOLZOOMIN); - } - - return TRUE; -} - -//----------------------------------------------------------------------------- -// handleScrollWheel() -//----------------------------------------------------------------------------- -BOOL LLFloaterModelWizard::handleScrollWheel(S32 x, S32 y, S32 clicks) -{ - if (mPreviewRect.pointInRect(x, y) && mModelPreview) - { - mModelPreview->zoom((F32)clicks * -0.2f); - mModelPreview->refresh(); - } - - return TRUE; -} - - -void LLFloaterModelWizard::initDecompControls() -{ - LLSD key; - - static const LLCDStageData* stage = NULL; - static S32 stage_count = 0; - - if (!stage && LLConvexDecomposition::getInstance() != NULL) - { - stage_count = LLConvexDecomposition::getInstance()->getStages(&stage); - } - - static const LLCDParam* param = NULL; - static S32 param_count = 0; - if (!param && LLConvexDecomposition::getInstance() != NULL) - { - param_count = LLConvexDecomposition::getInstance()->getParameters(¶m); - } - - for (S32 j = stage_count-1; j >= 0; --j) - { - gMeshRepo.mDecompThread->mStageID[stage[j].mName] = j; - // protected against stub by stage_count being 0 for stub above - LLConvexDecomposition::getInstance()->registerCallback(j, LLPhysicsDecomp::llcdCallback); - - for (S32 i = 0; i < param_count; ++i) - { - if (param[i].mStage != j) - { - continue; - } - - std::string name(param[i].mName ? param[i].mName : ""); - std::string description(param[i].mDescription ? param[i].mDescription : ""); - - if (param[i].mType == LLCDParam::LLCD_FLOAT) - { - mDecompParams[param[i].mName] = LLSD(param[i].mDefault.mFloat); - } - else if (param[i].mType == LLCDParam::LLCD_INTEGER) - { - mDecompParams[param[i].mName] = LLSD(param[i].mDefault.mIntOrEnumValue); - } - else if (param[i].mType == LLCDParam::LLCD_BOOLEAN) - { - mDecompParams[param[i].mName] = LLSD(param[i].mDefault.mBool); - } - else if (param[i].mType == LLCDParam::LLCD_ENUM) - { - mDecompParams[param[i].mName] = LLSD(param[i].mDefault.mIntOrEnumValue); - } - } - } - - mDecompParams["Simplify Method"] = 0; // set it to retain % -} - -/*virtual*/ -void LLFloaterModelWizard::onPermissionsReceived(const LLSD& result) -{ - std::string upload_status = result["mesh_upload_status"].asString(); - // BAP HACK: handle "" for case that MeshUploadFlag cap is broken. - mHasUploadPerm = (("" == upload_status) || ("valid" == upload_status)); - - getChildView("warning_label")->setVisible(!mHasUploadPerm); - getChildView("warning_text")->setVisible(!mHasUploadPerm); -} - -/*virtual*/ -void LLFloaterModelWizard::setPermissonsErrorStatus(U32 status, const std::string& reason) -{ - llwarns << "LLFloaterModelWizard::setPermissonsErrorStatus(" << status << " : " << reason << ")" << llendl; -} - -/*virtual*/ -void LLFloaterModelWizard::onModelPhysicsFeeReceived(const LLSD& result, std::string upload_url) -{ - swap_controls(mCalculateWeightsBtn, mCalculatingWeightsBtn, true); - - // Enable the "Upload" buton if we have calculated the upload fee - // and have the permission to upload. - getChildView("upload")->setEnabled(mHasUploadPerm); - - mUploadModelUrl = upload_url; - - S32 fee = result["upload_price"].asInteger(); - childSetTextArg("review_fee", "[FEE]", llformat("%d", fee)); - childSetTextArg("charged_fee", "[FEE]", llformat("%d", fee)); - - setState(REVIEW); -} - -/*virtual*/ -void LLFloaterModelWizard::setModelPhysicsFeeErrorStatus(U32 status, const std::string& reason) -{ - swap_controls(mCalculateWeightsBtn, mCalculatingWeightsBtn, true); - - // Disable the "Review" step if it has been previously enabled. - modelChangedCallback(); - - llwarns << "LLFloaterModelWizard::setModelPhysicsFeeErrorStatus(" << status << " : " << reason << ")" << llendl; - - setState(PHYSICS); -} - -/*virtual*/ -void LLFloaterModelWizard::onModelUploadSuccess() -{ - // success! - setState(UPLOAD); -} - -/*virtual*/ -void LLFloaterModelWizard::onModelUploadFailure() -{ - // Failure. Make the user recalculate fees - setState(PHYSICS); - // Disable the "Review" step if it has been previously enabled. - if (mLastEnabledState > PHYSICS) - { - mLastEnabledState = PHYSICS; - } - - updateButtons(); -} - -//static -void LLFloaterModelWizard::executePhysicsStage(std::string stage_name) -{ - if (sInstance) - { - // Invert the slider value so that "performance" end is giving the least detailed physics, - // and the "accuracy" end is giving the most detailed physics - F64 physics_accuracy = 1 - sInstance->getChild("physics_slider")->getValue().asReal(); - - sInstance->mDecompParams["Retain%"] = physics_accuracy; - - if (!sInstance->mCurRequest.empty()) - { - llinfos << "Decomposition request still pending." << llendl; - return; - } - - if (sInstance->mModelPreview) - { - for (S32 i = 0; i < sInstance->mModelPreview->mModel[LLModel::LOD_PHYSICS].size(); ++i) - { - LLModel* mdl = sInstance->mModelPreview->mModel[LLModel::LOD_PHYSICS][i]; - DecompRequest* request = new DecompRequest(stage_name, mdl); - if(request->isValid()) - { - sInstance->mCurRequest.insert(request); - gMeshRepo.mDecompThread->submitRequest(request); - } - } - } - } -} - -LLFloaterModelWizard::DecompRequest::DecompRequest(const std::string& stage, LLModel* mdl) -{ - mStage = stage; - mContinue = 1; - mModel = mdl; - mDecompID = &mdl->mDecompID; - mParams = sInstance->mDecompParams; - - //copy out positions and indices - assignData(mdl) ; -} - - -S32 LLFloaterModelWizard::DecompRequest::statusCallback(const char* status, S32 p1, S32 p2) -{ - setStatusMessage(llformat("%s: %d/%d", status, p1, p2)); - - return mContinue; -} - -void LLFloaterModelWizard::DecompRequest::completed() -{ //called from the main thread - mModel->setConvexHullDecomposition(mHull); - - if (sInstance) - { - if (sInstance->mModelPreview) - { - sInstance->mModelPreview->mDirty = true; - LLFloaterModelWizard::sInstance->mModelPreview->refresh(); - } - - sInstance->mCurRequest.erase(this); - } - - if (mStage == "Decompose") - { - executePhysicsStage("Simplify"); - } - else - { - // Decomp request is complete so we can enable the "Recalculate physics" button again. - swap_controls(sInstance->mRecalculatePhysicsBtn, sInstance->mRecalculatingPhysicsBtn, true); - } -} - - -BOOL LLFloaterModelWizard::postBuild() -{ - childSetValue("import_scale", (F32) 0.67335826); - - getChild("browse")->setCommitCallback(boost::bind(&LLFloaterModelWizard::loadModel, this)); - //getChild("lod_file")->setCommitCallback(boost::bind(&LLFloaterModelWizard::loadModel, this)); - getChild("cancel")->setCommitCallback(boost::bind(&LLFloaterModelWizard::onClickCancel, this)); - getChild("close")->setCommitCallback(boost::bind(&LLFloaterModelWizard::onClickCancel, this)); - getChild("back")->setCommitCallback(boost::bind(&LLFloaterModelWizard::onClickBack, this)); - getChild("next")->setCommitCallback(boost::bind(&LLFloaterModelWizard::onClickNext, this)); - getChild("preview_lod_combo")->setCommitCallback(boost::bind(&LLFloaterModelWizard::onPreviewLODCommit, this, _1)); - getChild("preview_lod_combo2")->setCommitCallback(boost::bind(&LLFloaterModelWizard::onPreviewLODCommit, this, _1)); - getChild("upload")->setCommitCallback(boost::bind(&LLFloaterModelWizard::onUpload, this)); - getChild("switch_to_advanced")->setCommitCallback(boost::bind(&LLFloaterModelWizard::onClickSwitchToAdvanced, this)); - - mRecalculateGeometryBtn = getChild("recalculate_geometry_btn"); - mRecalculateGeometryBtn->setCommitCallback(boost::bind(&LLFloaterModelWizard::onClickRecalculateGeometry, this)); - - mRecalculatePhysicsBtn = getChild("recalculate_physics_btn"); - mRecalculatePhysicsBtn->setCommitCallback(boost::bind(&LLFloaterModelWizard::onClickRecalculatePhysics, this)); - - mRecalculatingPhysicsBtn = getChild("recalculating_physics_btn"); - - mCalculateWeightsBtn = getChild("calculate"); - mCalculateWeightsBtn->setCommitCallback(boost::bind(&LLFloaterModelWizard::onClickCalculateUploadFee, this)); - - mCalculatingWeightsBtn = getChild("calculating"); - - mChooseFilePreviewPanel = getChild("choose_file_preview_panel"); - mOptimizePreviewPanel = getChild("optimize_preview_panel"); - mPhysicsPreviewPanel = getChild("physics_preview_panel"); - - LLUICtrl::EnableCallbackRegistry::ScopedRegistrar enable_registrar; - - enable_registrar.add("Next.OnEnable", boost::bind(&LLFloaterModelWizard::onEnableNext, this)); - enable_registrar.add("Back.OnEnable", boost::bind(&LLFloaterModelWizard::onEnableBack, this)); - - mModelPreview = new LLModelPreview(512, 512, this); - mModelPreview->setPreviewTarget(16.f); - mModelPreview->setDetailsCallback(boost::bind(&LLFloaterModelWizard::setDetails, this, _1, _2, _3, _4, _5)); - mModelPreview->setModelLoadedCallback(boost::bind(&LLFloaterModelWizard::modelLoadedCallback, this)); - mModelPreview->setModelUpdatedCallback(boost::bind(&LLFloaterModelWizard::modelChangedCallback, this)); - mModelPreview->mViewOption["show_textures"] = true; - - center(); - - setState(CHOOSE_FILE); - - childSetTextArg("import_dimensions", "[X]", LLStringUtil::null); - childSetTextArg("import_dimensions", "[Y]", LLStringUtil::null); - childSetTextArg("import_dimensions", "[Z]", LLStringUtil::null); - - initDecompControls(); - - requestAgentUploadPermissions(); - - return TRUE; -} - - -void LLFloaterModelWizard::setDetails(F32 x, F32 y, F32 z, F32 streaming_cost, F32 physics_cost) -{ - // iterate through all the panels, setting the dimensions - for(size_t t=0; t(stateNames[t]+"_panel"); - if (panel) - { - panel->childSetText("dimension_x", llformat("%.1f", x)); - panel->childSetText("dimension_y", llformat("%.1f", y)); - panel->childSetText("dimension_z", llformat("%.1f", z)); - } - } - - childSetTextArg("review_prim_equiv", "[EQUIV]", llformat("%d", mModelPreview->mResourceCost)); -} - -void LLFloaterModelWizard::modelLoadedCallback() -{ - mLastEnabledState = CHOOSE_FILE; - updateButtons(); -} - -void LLFloaterModelWizard::modelChangedCallback() -{ - // Don't allow to proceed to the "Review" step if the model has changed - // but the new upload fee hasn't been calculated yet. - if (mLastEnabledState > PHYSICS) - { - mLastEnabledState = PHYSICS; - } - - getChildView("upload")->setEnabled(false); - - updateButtons(); -} - -void LLFloaterModelWizard::onUpload() -{ - mModelPreview->rebuildUploadData(); - - gMeshRepo.uploadModel(mModelPreview->mUploadData, mModelPreview->mPreviewScale, - true, false, false, mUploadModelUrl, true, - LLHandle(), getWholeModelUploadObserverHandle()); -} - -void LLFloaterModelWizard::onPreviewLODCommit(LLUICtrl* ctrl) -{ - if (!mModelPreview) - { - return; - } - - S32 which_mode = 0; - - LLComboBox* combo = (LLComboBox*) ctrl; - - which_mode = (NUM_LOD-1)-combo->getFirstSelectedIndex(); // combo box list of lods is in reverse order - - mModelPreview->setPreviewLOD(which_mode); -} - -void LLFloaterModelWizard::refresh() -{ - if (mState == CHOOSE_FILE) - { - bool model_loaded = false; - - if (mModelPreview && mModelPreview->getLoadState() == LLModelLoader::DONE) - { - model_loaded = true; - } - - getChildView("next")->setEnabled(model_loaded); - } -} - -void LLFloaterModelWizard::draw() -{ - refresh(); - - LLFloater::draw(); - - if (mModelPreview && mState < REVIEW) - { - mModelPreview->update(); - - gGL.color3f(1.f, 1.f, 1.f); - - gGL.getTexUnit(0)->bind(mModelPreview); - - gGL.begin( LLRender::QUADS ); - { - gGL.texCoord2f(0.f, 1.f); - gGL.vertex2i(mPreviewRect.mLeft, mPreviewRect.mTop); - gGL.texCoord2f(0.f, 0.f); - gGL.vertex2i(mPreviewRect.mLeft, mPreviewRect.mBottom); - gGL.texCoord2f(1.f, 0.f); - gGL.vertex2i(mPreviewRect.mRight, mPreviewRect.mBottom); - gGL.texCoord2f(1.f, 1.f); - gGL.vertex2i(mPreviewRect.mRight, mPreviewRect.mTop); - } - gGL.end(); - - gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE); - } -} - -// static -void swap_controls(LLUICtrl* first_ctrl, LLUICtrl* second_ctrl, bool first_ctr_visible) -{ - first_ctrl->setVisible(first_ctr_visible); - second_ctrl->setVisible(!first_ctr_visible); -} diff --git a/indra/newview/llfloatermodelwizard.h b/indra/newview/llfloatermodelwizard.h deleted file mode 100644 index db9b605777..0000000000 --- a/indra/newview/llfloatermodelwizard.h +++ /dev/null @@ -1,140 +0,0 @@ -/** - * @file llfloatermodelwizard.h - * - * $LicenseInfo:firstyear=2009&license=viewerlgpl$ - * Second Life Viewer Source Code - * Copyright (C) 2010, Linden Research, Inc. - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; - * version 2.1 of the License only. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * - * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA - * $/LicenseInfo$ - */ - -#ifndef LLFLOATERMODELWIZARD_H -#define LLFLOATERMODELWIZARD_H - - -#include "llmeshrepository.h" -#include "llmodel.h" -#include "llthread.h" -#include "llfloatermodeluploadbase.h" - - -class LLModelPreview; - - -class LLFloaterModelWizard : public LLFloaterModelUploadBase -{ -public: - - class DecompRequest : public LLPhysicsDecomp::Request - { - public: - S32 mContinue; - LLPointer mModel; - - DecompRequest(const std::string& stage, LLModel* mdl); - virtual S32 statusCallback(const char* status, S32 p1, S32 p2); - virtual void completed(); - - }; - - static LLFloaterModelWizard* sInstance; - - LLFloaterModelWizard(const LLSD& key); - virtual ~LLFloaterModelWizard(); - /*virtual*/ BOOL postBuild(); - void draw(); - void refresh(); - - BOOL handleMouseDown(S32 x, S32 y, MASK mask); - BOOL handleMouseUp(S32 x, S32 y, MASK mask); - BOOL handleHover(S32 x, S32 y, MASK mask); - BOOL handleScrollWheel(S32 x, S32 y, S32 clicks); - - void setDetails(F32 x, F32 y, F32 z, F32 streaming_cost, F32 physics_cost); - void modelLoadedCallback(); - void modelChangedCallback(); - void initDecompControls(); - - // shows warning message if agent has no permissions to upload model - /*virtual*/ void onPermissionsReceived(const LLSD& result); - - // called when error occurs during permissions request - /*virtual*/ void setPermissonsErrorStatus(U32 status, const std::string& reason); - - /*virtual*/ void onModelPhysicsFeeReceived(const LLSD& result, std::string upload_url); - - /*virtual*/ void setModelPhysicsFeeErrorStatus(U32 status, const std::string& reason); - - /*virtual*/ void onModelUploadSuccess(); - - /*virtual*/ void onModelUploadFailure(); - - const LLRect& getPreviewRect() const { return mPreviewRect; } - - LLPhysicsDecomp::decomp_params mDecompParams; - std::set > mCurRequest; - std::string mStatusMessage; - static void executePhysicsStage(std::string stage_name); - -private: - enum EWizardState - { - CHOOSE_FILE = 0, - OPTIMIZE, - PHYSICS, - REVIEW, - UPLOAD - }; - - void setState(int state); - void updateButtons(); - void onClickSwitchToAdvanced(); - void onClickRecalculateGeometry(); - void onClickRecalculatePhysics(); - void onClickCalculateUploadFee(); - void onClickCancel(); - void onClickBack(); - void onClickNext(); - bool onEnableNext(); - bool onEnableBack(); - void loadModel(); - void onPreviewLODCommit(LLUICtrl*); - void onUpload(); - - LLModelPreview* mModelPreview; - LLRect mPreviewRect; - int mState; - - S32 mLastMouseX; - S32 mLastMouseY; - - U32 mLastEnabledState; - - LLButton* mRecalculateGeometryBtn; - LLButton* mRecalculatePhysicsBtn; - LLButton* mRecalculatingPhysicsBtn; - LLButton* mCalculateWeightsBtn; - LLButton* mCalculatingWeightsBtn; - - LLView* mChooseFilePreviewPanel; - LLView* mOptimizePreviewPanel; - LLView* mPhysicsPreviewPanel; -}; - - -#endif diff --git a/indra/newview/llviewerfloaterreg.cpp b/indra/newview/llviewerfloaterreg.cpp index 7fdaac68c8..17d8256de8 100644 --- a/indra/newview/llviewerfloaterreg.cpp +++ b/indra/newview/llviewerfloaterreg.cpp @@ -78,7 +78,6 @@ #include "llfloaterlandholdings.h" #include "llfloatermap.h" #include "llfloatermemleak.h" -#include "llfloatermodelwizard.h" #include "llfloaternamedesc.h" #include "llfloaternotificationsconsole.h" #include "llfloaterobjectweights.h" @@ -298,7 +297,6 @@ void LLViewerFloaterReg::registerFloaters() LLFloaterReg::add("upload_anim_anim", "floater_animation_anim_preview.xml", (LLFloaterBuildFunc)&LLFloaterReg::build, "upload"); LLFloaterReg::add("upload_image", "floater_image_preview.xml", (LLFloaterBuildFunc)&LLFloaterReg::build, "upload"); LLFloaterReg::add("upload_model", "floater_model_preview.xml", (LLFloaterBuildFunc)&LLFloaterReg::build, "upload"); - LLFloaterReg::add("upload_model_wizard", "floater_model_wizard.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("upload_script", "floater_script_preview.xml", (LLFloaterBuildFunc)&LLFloaterReg::build, "upload"); LLFloaterReg::add("upload_sound", "floater_sound_preview.xml", (LLFloaterBuildFunc)&LLFloaterReg::build, "upload"); diff --git a/indra/newview/skins/default/xui/da/floater_model_wizard.xml b/indra/newview/skins/default/xui/da/floater_model_wizard.xml deleted file mode 100644 index 8ad443581a..0000000000 --- a/indra/newview/skins/default/xui/da/floater_model_wizard.xml +++ /dev/null @@ -1,241 +0,0 @@ - - - - - - - - - - - Choose model file - - - - - Advanced users: If you are familiar with 3D content creation tools you may wish to use the Advanced Uploader. - - - - Choose model file to upload - - - - - Second Life supports COLLADA (.dae) files - - - - - - Dimensions (meters): - - - X Y Z - - - - - - WARNING: - - - You will not be able to complete the final step of uploading this model to the Second Life servers. [secondlife:///app/floater/learn_more Find out how] to set up your account for mesh model uploads. - - - - - - - - - Optimize model - - - - We have optimized the model for performance. Adjust it further if you wish. - - - Generating Level of Detail - - - Generate Level of Detail: High - - Generate Level of Detail: Medium - - Generate Level of Detail: Low - - Generate Level of Detail: Lowest - - - Performance - Faster rendering -Less detail -Lower prim weight - Accuracy - Slower rendering -More detail -Higher prim weight - - - ' - - ' - - ' - - - - Geometry preview - - - - - - High detail - - - Medium detail - - - Low detail - - - Lowest detail - - - - - - - - - Adjust physics - - - - We will create a shape for the outer hull of the model. Adjust the shape's detail level as needed for the intended purpose of your model. - - - Performance - Faster rendering -Less detail -Lower prim weight - Accuracy - Slower rendering -More detail -Higher prim weight - - - Examples: -Moving objects -Flying objects -Vehicles - Examples: -Small static objects -Less detailed objects -Simple furniture - Examples: -Static objects -Detailed objects -Buildings - - - - Physics preview - - - - - - High detail - - - Medium detail - - - Low detail - - - Lowest detail - - - - - - - - - Review - - - - Impact to parcel/region: [EQUIV] prim equivalents - - Your account will be charged an upload fee of L$ [FEE]. - - By clicking the upload button, you confirm that you have the appropriate rights to the material contained in the model. - - - - - - - - - - - Upload complete - - - - Your model has been uploaded. - - - You will find it in the Objects folder in your inventory. - - Your account has been charged L$ [FEE]. - - - - - - + + + + + \ No newline at end of file diff --git a/indra/newview/skins/default/xui/en/panel_preferences_spellcheck.xml b/indra/newview/skins/default/xui/en/panel_preferences_spellcheck.xml deleted file mode 100644 index f1b16c5d0d..0000000000 --- a/indra/newview/skins/default/xui/en/panel_preferences_spellcheck.xml +++ /dev/null @@ -1,136 +0,0 @@ - - - - - Main dictionary : - - - - - Additional dictionaries : - - - Available - - - Active - - - - - - - -- cgit v1.3 From 5e5dbd718e65dc30365bf435a7a865e7f95096cc Mon Sep 17 00:00:00 2001 From: Oz Linden Date: Thu, 31 May 2012 16:12:52 -0400 Subject: fix spell checker floater registration --- indra/newview/llfloaterspellchecksettings.h | 6 +++--- indra/newview/llviewerfloaterreg.cpp | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) (limited to 'indra/newview/llviewerfloaterreg.cpp') diff --git a/indra/newview/llfloaterspellchecksettings.h b/indra/newview/llfloaterspellchecksettings.h index 33c376fff6..2fbf47617a 100644 --- a/indra/newview/llfloaterspellchecksettings.h +++ b/indra/newview/llfloaterspellchecksettings.h @@ -24,8 +24,8 @@ * $/LicenseInfo$ */ -#ifndef LLFLOATERAUTOREPLACESETTINGS_H -#define LLFLOATERAUTOREPLACESETTINGS_H +#ifndef LLFLOATERSPELLCHECKERSETTINGS_H +#define LLFLOATERSPELLCHECKERSETTINGS_H #include "llfloater.h" @@ -45,4 +45,4 @@ protected: void refreshDictionaryLists(bool from_settings); }; -#endif // LLFLOATERAUTOREPLACESETTINGS_H +#endif // LLFLOATERSPELLCHECKERSETTINGS_H diff --git a/indra/newview/llviewerfloaterreg.cpp b/indra/newview/llviewerfloaterreg.cpp index d310e5a09a..4d84262a3a 100644 --- a/indra/newview/llviewerfloaterreg.cpp +++ b/indra/newview/llviewerfloaterreg.cpp @@ -249,8 +249,8 @@ void LLViewerFloaterReg::registerFloaters() LLFloaterReg::add("preferences", "floater_preferences.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("prefs_proxy", "floater_preferences_proxy.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("prefs_hardware_settings", "floater_hardware_settings.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); - LLFloaterReg::add("prefs_spellchecker", "floater_spellcheck.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("prefs_translation", "floater_translation_settings.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); + LLFloaterReg::add("prefs_spellchecker", "floater_spellcheck.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("prefs_autoreplace", "floater_autoreplace.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("perm_prefs", "floater_perm_prefs.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("picks", "floater_picks.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); -- cgit v1.3 From 20210455f5a350b3e8e24515ba7af71db0eece0b Mon Sep 17 00:00:00 2001 From: Kitty Barnett Date: Mon, 4 Jun 2012 16:10:32 +0200 Subject: STORM-276 Dictionary import functionality and floater --- indra/llui/llspellcheck.cpp | 45 +++++++- indra/llui/llspellcheck.h | 5 +- indra/newview/llfilepicker.cpp | 22 ++++ indra/newview/llfilepicker.h | 1 + indra/newview/llfloaterspellchecksettings.cpp | 127 +++++++++++++++++++-- indra/newview/llfloaterspellchecksettings.h | 25 +++- indra/newview/llviewerfloaterreg.cpp | 1 + .../skins/default/xui/en/floater_spellcheck.xml | 10 ++ .../default/xui/en/floater_spellcheck_import.xml | 116 +++++++++++++++++++ indra/newview/skins/default/xui/en/strings.xml | 1 + 10 files changed, 335 insertions(+), 18 deletions(-) create mode 100644 indra/newview/skins/default/xui/en/floater_spellcheck_import.xml (limited to 'indra/newview/llviewerfloaterreg.cpp') diff --git a/indra/llui/llspellcheck.cpp b/indra/llui/llspellcheck.cpp index bde3b56741..04c8a4fed0 100644 --- a/indra/llui/llspellcheck.cpp +++ b/indra/llui/llspellcheck.cpp @@ -88,17 +88,37 @@ S32 LLSpellChecker::getSuggestions(const std::string& word, std::vectorfileExists(tmp_user_path + DICT_CUSTOM_SUFFIX + ".dic")); sdDict["has_ignore"] = (!tmp_user_path.empty()) && (gDirUtilp->fileExists(tmp_user_path + DICT_IGNORE_SUFFIX + ".dic")); } + + sSettingsChangeSignal(); } void LLSpellChecker::addToCustomDictionary(const std::string& word) diff --git a/indra/llui/llspellcheck.h b/indra/llui/llspellcheck.h index d736a7f082..acb121dd19 100644 --- a/indra/llui/llspellcheck.h +++ b/indra/llui/llspellcheck.h @@ -59,12 +59,15 @@ public: static const std::string getDictionaryAppPath(); static const std::string getDictionaryUserPath(); - static const LLSD getDictionaryData(const std::string& dict_name); + static const LLSD getDictionaryData(const std::string& dict_language); static const LLSD& getDictionaryMap() { return sDictMap; } static bool getUseSpellCheck(); static void refreshDictionaryMap(); static void setUseSpellCheck(const std::string& dict_name); +protected: + static void setDictionaryData(const LLSD& dict_info); +public: typedef boost::signals2::signal settings_change_signal_t; static boost::signals2::connection setSettingsChangeCallback(const settings_change_signal_t::slot_type& cb); protected: diff --git a/indra/newview/llfilepicker.cpp b/indra/newview/llfilepicker.cpp index 8986a694f9..cbb5a40cfa 100644 --- a/indra/newview/llfilepicker.cpp +++ b/indra/newview/llfilepicker.cpp @@ -59,6 +59,7 @@ LLFilePicker LLFilePicker::sInstance; #define RAW_FILTER L"RAW files (*.raw)\0*.raw\0" #define MODEL_FILTER L"Model files (*.dae)\0*.dae\0" #define SCRIPT_FILTER L"Script files (*.lsl)\0*.lsl\0" +#define DICTIONARY_FILTER L"Dictionary files (*.dic)\0*.dic\0" #endif // @@ -218,6 +219,10 @@ BOOL LLFilePicker::setupFilter(ELoadFilter filter) mOFN.lpstrFilter = SCRIPT_FILTER \ L"\0"; break; + case FFLOAD_DICTIONARY: + mOFN.lpstrFilter = DICTIONARY_FILTER \ + L"\0"; + break; default: res = FALSE; break; @@ -643,6 +648,14 @@ Boolean LLFilePicker::navOpenFilterProc(AEDesc *theItem, void *info, void *callB result = false; } } + else if (filter == FFLOAD_DICTIONARY) + { + if (fileInfo.filetype != 'DIC ' && + (fileInfo.extension && (CFStringCompare(fileInfo.extension, CFSTR("dic"), kCFCompareCaseInsensitive) != kCFCompareEqualTo)) ) + { + result = false; + } + } if (fileInfo.extension) { @@ -1235,6 +1248,12 @@ static std::string add_script_filter_to_gtkchooser(GtkWindow *picker) LLTrans::getString("script_files") + " (*.lsl)"); } +static std::string add_dictionary_filter_to_gtkchooser(GtkWindow *picker) +{ + return add_simple_mime_filter_to_gtkchooser(picker, "text/plain", + LLTrans::getString("dictionary_files") + " (*.dic)"); +} + BOOL LLFilePicker::getSaveFile( ESaveFilter filter, const std::string& filename ) { BOOL rtn = FALSE; @@ -1371,6 +1390,9 @@ BOOL LLFilePicker::getOpenFile( ELoadFilter filter, bool blocking ) case FFLOAD_SCRIPT: filtername = add_script_filter_to_gtkchooser(picker); break; + case FFLOAD_DICTIONARY: + filtername = add_dictionary_filter_to_gtkchooser(picker); + break; default:; break; } diff --git a/indra/newview/llfilepicker.h b/indra/newview/llfilepicker.h index a4d5d68ff5..55c665b9c7 100644 --- a/indra/newview/llfilepicker.h +++ b/indra/newview/llfilepicker.h @@ -85,6 +85,7 @@ public: FFLOAD_MODEL = 9, FFLOAD_COLLADA = 10, FFLOAD_SCRIPT = 11, + FFLOAD_DICTIONARY = 12 }; enum ESaveFilter diff --git a/indra/newview/llfloaterspellchecksettings.cpp b/indra/newview/llfloaterspellchecksettings.cpp index ff5afc8169..8bf480c4df 100644 --- a/indra/newview/llfloaterspellchecksettings.cpp +++ b/indra/newview/llfloaterspellchecksettings.cpp @@ -27,13 +27,19 @@ #include "llviewerprecompiledheaders.h" #include "llcombobox.h" +#include "llfilepicker.h" +#include "llfloaterreg.h" #include "llfloaterspellchecksettings.h" #include "llscrolllistctrl.h" +#include "llsdserialize.h" #include "llspellcheck.h" #include "llviewercontrol.h" #include +///---------------------------------------------------------------------------- +/// Class LLFloaterSpellCheckerSettings +///---------------------------------------------------------------------------- LLFloaterSpellCheckerSettings::LLFloaterSpellCheckerSettings(const LLSD& key) : LLFloater(key) { @@ -42,21 +48,28 @@ LLFloaterSpellCheckerSettings::LLFloaterSpellCheckerSettings(const LLSD& key) BOOL LLFloaterSpellCheckerSettings::postBuild(void) { gSavedSettings.getControl("SpellCheck")->getSignal()->connect(boost::bind(&LLFloaterSpellCheckerSettings::refreshDictionaryLists, this, false)); + LLSpellChecker::setSettingsChangeCallback(boost::bind(&LLFloaterSpellCheckerSettings::onSpellCheckSettingsChange, this)); + getChild("spellcheck_import_btn")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerSettings::onBtnImport, this)); getChild("spellcheck_main_combo")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerSettings::refreshDictionaryLists, this, false)); - getChild("spellcheck_moveleft_btn")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerSettings::onClickDictMove, this, "spellcheck_active_list", "spellcheck_available_list")); - getChild("spellcheck_moveright_btn")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerSettings::onClickDictMove, this, "spellcheck_available_list", "spellcheck_active_list")); - getChild("spellcheck_ok")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerSettings::onOK, this)); - getChild("spellcheck_cancel")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerSettings::onCancel, this)); + getChild("spellcheck_moveleft_btn")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerSettings::onBtnMove, this, "spellcheck_active_list", "spellcheck_available_list")); + getChild("spellcheck_moveright_btn")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerSettings::onBtnMove, this, "spellcheck_available_list", "spellcheck_active_list")); + getChild("spellcheck_ok")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerSettings::onBtnOK, this)); + getChild("spellcheck_cancel")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerSettings::onBtnCancel, this)); return true; } -void LLFloaterSpellCheckerSettings::onCancel() +void LLFloaterSpellCheckerSettings::onBtnCancel() { closeFloater(false); } -void LLFloaterSpellCheckerSettings::onClickDictMove(const std::string& from, const std::string& to) +void LLFloaterSpellCheckerSettings::onBtnImport() +{ + LLFloaterReg::showInstance("prefs_spellchecker_import"); +} + +void LLFloaterSpellCheckerSettings::onBtnMove(const std::string& from, const std::string& to) { LLScrollListCtrl* from_ctrl = findChild(from); LLScrollListCtrl* to_ctrl = findChild(to); @@ -75,7 +88,7 @@ void LLFloaterSpellCheckerSettings::onClickDictMove(const std::string& from, con from_ctrl->deleteSelectedItems(); } -void LLFloaterSpellCheckerSettings::onOK() +void LLFloaterSpellCheckerSettings::onBtnOK() { std::list list_dict; @@ -100,6 +113,11 @@ void LLFloaterSpellCheckerSettings::onOpen(const LLSD& key) refreshDictionaryLists(true); } +void LLFloaterSpellCheckerSettings::onSpellCheckSettingsChange() +{ + refreshDictionaryLists(true); +} + void LLFloaterSpellCheckerSettings::refreshDictionaryLists(bool from_settings) { bool enabled = gSavedSettings.getBOOL("SpellCheck"); @@ -177,3 +195,98 @@ void LLFloaterSpellCheckerSettings::refreshDictionaryLists(bool from_settings) } } } + +///---------------------------------------------------------------------------- +/// Class LLFloaterSpellCheckerImport +///---------------------------------------------------------------------------- +LLFloaterSpellCheckerImport::LLFloaterSpellCheckerImport(const LLSD& key) + : LLFloater(key) +{ +} + +BOOL LLFloaterSpellCheckerImport::postBuild(void) +{ + getChild("dictionary_path_browse")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerImport::onBtnBrowse, this)); + getChild("ok_btn")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerImport::onBtnOK, this)); + getChild("cancel_btn")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerImport::onBtnCancel, this)); + + return true; +} + +void LLFloaterSpellCheckerImport::onBtnBrowse() +{ + LLFilePicker& file_picker = LLFilePicker::instance(); + if (!file_picker.getOpenFile(LLFilePicker::FFLOAD_DICTIONARY)) + { + return; + } + + const std::string filepath = file_picker.getFirstFile(); + getChild("dictionary_path")->setValue(filepath); + + mDictionaryDir = gDirUtilp->getDirName(filepath); + mDictionaryBasename = gDirUtilp->getBaseFileName(filepath, true); + getChild("dictionary_name")->setValue(mDictionaryBasename); +} + +void LLFloaterSpellCheckerImport::onBtnCancel() +{ + closeFloater(false); +} + +void LLFloaterSpellCheckerImport::onBtnOK() +{ + const std::string dict_dic = mDictionaryDir + gDirUtilp->getDirDelimiter() + mDictionaryBasename + ".dic"; + const std::string dict_aff = mDictionaryDir + gDirUtilp->getDirDelimiter() + mDictionaryBasename + ".aff"; + std::string dict_language = getChild("dictionary_language")->getValue().asString(); + LLStringUtil::trim(dict_language); + if ( (dict_language.empty()) || (!gDirUtilp->fileExists(dict_dic)) || + (mDictionaryDir.empty()) || (mDictionaryBasename.empty()) ) + { + return; + } + + LLSD custom_dict_info; + custom_dict_info["is_primary"] = (bool)gDirUtilp->fileExists(dict_aff); + custom_dict_info["name"] = mDictionaryBasename; + custom_dict_info["language"] = dict_language; + + LLSD custom_dict_map; + llifstream custom_file_in(LLSpellChecker::getDictionaryUserPath() + "user_dictionaries.xml"); + if (custom_file_in.is_open()) + { + LLSDSerialize::fromXMLDocument(custom_dict_map, custom_file_in); + custom_file_in.close(); + } + + LLSD::array_iterator it = custom_dict_map.beginArray(); + for (; it != custom_dict_map.endArray(); ++it) + { + LLSD& dict_info = *it; + if (dict_info["name"].asString() == mDictionaryBasename) + { + dict_info = custom_dict_info; + break; + } + } + if (custom_dict_map.endArray() == it) + { + custom_dict_map.append(custom_dict_info); + } + + llofstream custom_file_out(LLSpellChecker::getDictionaryUserPath() + "user_dictionaries.xml", std::ios::trunc); + if (custom_file_out.is_open()) + { + LLSDSerialize::toPrettyXML(custom_dict_map, custom_file_out); + custom_file_out.close(); + } + + LLFile::rename(dict_dic, LLSpellChecker::getDictionaryUserPath() + mDictionaryBasename + ".dic"); + if (gDirUtilp->fileExists(dict_aff)) + { + LLFile::rename(dict_aff, LLSpellChecker::getDictionaryUserPath() + mDictionaryBasename + ".aff"); + } + LLSpellChecker::refreshDictionaryMap(); + + closeFloater(false); +} diff --git a/indra/newview/llfloaterspellchecksettings.h b/indra/newview/llfloaterspellchecksettings.h index 33c376fff6..521b586835 100644 --- a/indra/newview/llfloaterspellchecksettings.h +++ b/indra/newview/llfloaterspellchecksettings.h @@ -38,11 +38,28 @@ public: /*virtual*/ void onOpen(const LLSD& key); protected: - void onCancel(); - void onClickDictMove(const std::string& from, const std::string& to); - void onOK(); - void onSave(); + void onBtnCancel(); + void onBtnImport(); + void onBtnMove(const std::string& from, const std::string& to); + void onBtnOK(); + void onSpellCheckSettingsChange(); void refreshDictionaryLists(bool from_settings); }; +class LLFloaterSpellCheckerImport : public LLFloater +{ +public: + LLFloaterSpellCheckerImport(const LLSD& key); + + /*virtual*/ BOOL postBuild(); + +protected: + void onBtnBrowse(); + void onBtnCancel(); + void onBtnOK(); + + std::string mDictionaryDir; + std::string mDictionaryBasename; +}; + #endif // LLFLOATERAUTOREPLACESETTINGS_H diff --git a/indra/newview/llviewerfloaterreg.cpp b/indra/newview/llviewerfloaterreg.cpp index e9ce04fd3f..9c27e19255 100644 --- a/indra/newview/llviewerfloaterreg.cpp +++ b/indra/newview/llviewerfloaterreg.cpp @@ -250,6 +250,7 @@ void LLViewerFloaterReg::registerFloaters() LLFloaterReg::add("prefs_proxy", "floater_preferences_proxy.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("prefs_hardware_settings", "floater_hardware_settings.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("prefs_spellchecker", "floater_spellcheck.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); + LLFloaterReg::add("prefs_spellchecker_import", "floater_spellcheck_import.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("prefs_translation", "floater_translation_settings.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("perm_prefs", "floater_perm_prefs.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); LLFloaterReg::add("picks", "floater_picks.xml", (LLFloaterBuildFunc)&LLFloaterReg::build); diff --git a/indra/newview/skins/default/xui/en/floater_spellcheck.xml b/indra/newview/skins/default/xui/en/floater_spellcheck.xml index bd3f60cf4a..91639ed0da 100644 --- a/indra/newview/skins/default/xui/en/floater_spellcheck.xml +++ b/indra/newview/skins/default/xui/en/floater_spellcheck.xml @@ -53,6 +53,16 @@ top_pad="-15" width="175" /> +