void DragContainer::onMouseMove(MouseEventArgs& e)
{
Window::onMouseMove(e);
// get position of mouse as co-ordinates local to this window.
Point localMousePos = (getMetricsMode() == Relative) ?
relativeToAbsolute(screenToWindow(e.position)) :
screenToWindow(e.position);
// handle dragging
if (d_dragging)
{
doDragging(localMousePos);
}
// not dragging
else
{
// if mouse button is down (but we're not yet being dragged)
if (d_leftMouseDown)
{
if (isDraggingThresholdExceeded(localMousePos))
{
// Trigger the event
WindowEventArgs args(this);
onDragStarted(args);
}
}
}
}
// Checks if relativeIndex is draining. If not, returns the corresponding
// absolute index. Otherwise, attempt to duplicate. If duplication is
// successful, and vulnerable references are allowed, return absolute index of
// the duplicate. If duplication is unsuccessful, or vulnerable references are
// not allowed, return 0.
std::pair<bool, uint32_t> QPACKHeaderTable::maybeDuplicate(
uint32_t relativeIndex,
bool allowVulnerable) {
if (relativeIndex == UNACKED) {
return {false, 0};
}
DCHECK(isValid(relativeIndex));
uint32_t absIndex = relativeToAbsolute(relativeIndex);
DCHECK(!isVulnerable(absIndex) || allowVulnerable);
if (absIndex < minUsable_) {
// draining
const HPACKHeader& header = getHeader(relativeIndex);
if (canIndex(header)) {
CHECK(add(header.copy()));
if (allowVulnerable) {
return {true, insertCount_};
} else {
return {true, 0};
}
} else {
return {false, 0};
}
}
return {false, absIndex};
}
void FalagardDragTitle::onMouseButtonDown(MouseEventArgs& e)
{
// Base class processing
Window::onMouseButtonDown(e);
if (e.button == LeftButton)
{
if (d_dragTarget != NULL)
{
// we want all mouse inputs from now on
if (captureInput())
{
// initialise the dragging state
d_dragging = true;
d_dragPoint = screenToWindow(e.position);
if (getMetricsMode() == Relative)
{
d_dragPoint = relativeToAbsolute(d_dragPoint);
}
}
}
}
e.handled = true;
}
void FalagardActionButton::onMouseMove(MouseEventArgs& e)
{
FalagardButton::onMouseMove(e);
if(isDraggingEnabled() && !d_dragging && !isEmpty())
{
// get position of mouse as co-ordinates local to this window.
Point localMousePos = (getMetricsMode() == Relative) ?
relativeToAbsolute(screenToWindow(e.position)) :
screenToWindow(e.position);
// if mouse button is down (but we're not yet being dragged)
if (d_leftMouseDown)
{
if (isDraggingThresholdExceeded(localMousePos))
{
// Trigger the event
WindowEventArgs args(this);
d_dragging = true;
releaseInput();
fireEvent(EventDragStarted, e, EventNamespace);
}
}
}
}
/*************************************************************************
Handler for when mouse button is pressed
*************************************************************************/
void Listbox::onMouseButtonDown(MouseEventArgs& e)
{
// base class processing
Window::onMouseButtonDown(e);
if (e.button == LeftButton)
{
bool modified = false;
// clear old selections if no control key is pressed or if multi-select is off
if (!(e.sysKeys & Control) || !d_multiselect)
{
modified = clearAllSelections_impl();
}
Point localPos(screenToWindow(e.position));
if (getMetricsMode() == Relative)
{
localPos = relativeToAbsolute(localPos);
}
ListboxItem* item = getItemAtPoint(localPos);
if (item != NULL)
{
modified = true;
// select range or item, depending upon keys and last selected item
if (((e.sysKeys & Shift) && (d_lastSelected != NULL)) && d_multiselect)
{
selectRange(getItemIndex(item), getItemIndex(d_lastSelected));
}
else
{
item->setSelected(item->isSelected() ^ true);
}
// update last selected item
d_lastSelected = item->isSelected() ? item : NULL;
}
// fire event if needed
if (modified)
{
WindowEventArgs args(this);
onSelectionChanged(args);
}
e.handled = true;
}
}
/*************************************************************************
Handler for mouse button press events
*************************************************************************/
void Titlebar::onMouseButtonDown(MouseEventArgs& e)
{
// Base class processing
Window::onMouseButtonDown(e);
if (e.button == LeftButton)
{
if ((d_parent != NULL) && d_dragEnabled)
{
// we want all mouse inputs from now on
if (captureInput())
{
// initialise the dragging state
d_dragging = true;
d_dragPoint = screenToWindow(e.position);
if (getMetricsMode() == Relative)
{
d_dragPoint = relativeToAbsolute(d_dragPoint);
}
// store old constraint area
d_oldCursorArea = MouseCursor::getSingleton().getConstraintArea();
// setup new constraint area to be the intersection of the old area and our grand-parent's clipped inner-area
Rect constrainArea;
if ((d_parent == NULL) || (d_parent->getParent() == NULL))
{
constrainArea = System::getSingleton().getRenderer()->getRect().getIntersection(d_oldCursorArea);
}
else
{
constrainArea = d_parent->getParent()->getInnerRect().getIntersection(d_oldCursorArea);
}
MouseCursor::getSingleton().setConstraintArea(&constrainArea);
}
}
e.handled = true;
}
}
void FalagardActionButton::onMouseButtonDown(MouseEventArgs& e)
{
// FalagardButton::onMouseButtonDown(e);下面就是pushbutton中的部分
// default processing
Window::onMouseButtonDown(e);
if (e.button == LeftButton || e.button == RightButton)
{
if (captureInput())
{
d_pushed = true;
updateInternalState(e.position);
requestRedraw();
}
// event was handled by us.
e.handled = true;
}
/////////////////////////////////////////////////////////
if (e.button == LeftButton && isDraggingEnabled())
{
if(!d_dragging)
{
// get position of mouse as co-ordinates local to this window.
Point localPos = (getMetricsMode() == Relative) ?
relativeToAbsolute(screenToWindow(e.position)) :
screenToWindow(e.position);
// store drag point for possible sizing or moving operation.
d_dragPoint = localPos;
d_leftMouseDown = true;
}
e.handled = true;
}
if (e.button == RightButton && isDraggingEnabled())
{
e.handled = true;
}
}
/*************************************************************************
Return the text code point index that is rendered closest to screen
position 'pt'.
*************************************************************************/
size_t MultiLineEditbox::getTextIndexFromPosition(const Point& pt) const
{
//
// calculate final window position to be checked
//
Point wndPt = screenToWindow(pt);
if (getMetricsMode() == Relative)
{
wndPt = relativeToAbsolute(wndPt);
}
Rect textArea(getTextRenderArea());
wndPt.d_x -= textArea.d_left;
wndPt.d_y -= textArea.d_top;
// factor in scroll bar values
if( d_horzScrollbar )
wndPt.d_x += d_horzScrollbar->getScrollPosition();
if( d_vertScrollbar )
wndPt.d_y += d_vertScrollbar->getScrollPosition();
size_t lineNumber = static_cast<size_t>(wndPt.d_y / getFont()->getLineSpacing());
if (lineNumber >= d_lines.size())
{
lineNumber = d_lines.size() - 1;
}
String lineText(d_text.substr(d_lines[lineNumber].d_startIdx, d_lines[lineNumber].d_length));
size_t lineIdx = getFont()->getCharAtPixel(lineText, wndPt.d_x);
if (lineIdx >= lineText.length() - 1)
{
lineIdx = lineText.length() - 1;
}
return d_lines[lineNumber].d_startIdx + lineIdx;
}
void FalagardDragTitle::onMouseMove(MouseEventArgs& e)
{
// Base class processing.
Window::onMouseMove(e);
if (d_dragging && (d_dragTarget != NULL))
{
Vector2 delta(screenToWindow(e.position));
if (getMetricsMode() == Relative)
{
delta = relativeToAbsolute(delta);
}
// calculate amount that window has been moved
delta -= d_dragPoint;
// move the window. *** Again: Titlebar objects should only be attached to FrameWindow derived classes. ***
((FalagardBoundWindow*)d_dragTarget)->offsetPixelPosition(delta);
e.handled = true;
}
}
void DragContainer::onMouseButtonDown(MouseEventArgs& e)
{
Window::onMouseButtonDown(e);
if (e.button == LeftButton)
{
// ensure all inputs come to us for now
if (captureInput())
{
// get position of mouse as co-ordinates local to this window.
Point localPos = (getMetricsMode() == Relative) ?
relativeToAbsolute(screenToWindow(e.position)) :
screenToWindow(e.position);
// store drag point for possible sizing or moving operation.
d_dragPoint = localPos;
d_leftMouseDown = true;
}
e.handled = true;
}
}
/*************************************************************************
Handler for mouse button down events
*************************************************************************/
void Thumb::onMouseButtonDown(MouseEventArgs& e)
{
// default processing
PushButton::onMouseButtonDown(e);
if (e.button == LeftButton)
{
// initialise the dragging state
d_beingDragged = true;
d_dragPoint = screenToWindow(e.position);
if (getMetricsMode() == Relative)
{
d_dragPoint = relativeToAbsolute(d_dragPoint);
}
// trigger tracking started event
WindowEventArgs args(this);
onThumbTrackStarted(args);
e.handled = true;
}
}
/*************************************************************************
Handler for mouse movement
*************************************************************************/
void Listbox::onMouseMove(MouseEventArgs& e)
{
if (d_itemTooltips)
{
static ListboxItem* lastItem = NULL;
Point posi = relativeToAbsolute(screenToWindow(e.position));
ListboxItem* item = getItemAtPoint(posi);
if (item != lastItem)
{
if (item != NULL)
{
setTooltipText(item->getTooltipText());
}
else
{
setTooltipText("");
}
lastItem = item;
}
// must check the result from getTooltip(), as the tooltip object could
// be 0 at any time for various reasons.
Tooltip* tooltip = getTooltip();
if (tooltip)
{
if (tooltip->getTargetWindow() != this)
tooltip->setTargetWindow(this);
else
tooltip->positionSelf();
}
}
Window::onMouseMove(e);
}
// Converts an array index in [0..table_.size() - 1] to an absolute
// external index
uint32_t QPACKHeaderTable::internalToAbsolute(
uint32_t internalIndex) const {
return relativeToAbsolute(toExternal(internalIndex));
}
bool Mineserver::init()
{
// expand '~', '~user' in next vars
bool error = false;
const char* const vars[] =
{
"system.path.data",
"system.path.plugins",
"system.path.home",
"system.pid_file",
};
for (size_t i = 0; i < sizeof(vars) / sizeof(vars[0]); i++)
{
ConfigNode::Ptr node = config()->mData(vars[i]);
if (!node)
{
LOG2(ERROR, std::string("Variable is missing: ") + vars[i]);
error = true;
continue;
}
if (node->type() != CONFIG_NODE_STRING)
{
LOG2(ERROR, std::string("Variable is not string: ") + vars[i]);
error = true;
continue;
}
const std::string newvalue = relativeToAbsolute(node->sData());
node->setData(newvalue);
LOG2(INFO, std::string(vars[i]) + " = \"" + newvalue + "\"");
}
if (error)
{
return false;
}
const std::string str = config()->sData("system.path.home");
#ifdef WIN32
if (_chdir(str.c_str()) != 0)
#else
if (chdir(str.c_str()) != 0)
#endif
{
LOG2(ERROR, "Failed to change working directory to: " + str);
return false;
}
// Write PID to file
std::ofstream pid_out((config()->sData("system.pid_file")).c_str());
if (!pid_out.fail())
{
#ifdef WIN32
pid_out << _getpid();
#else
pid_out << getpid();
#endif
}
pid_out.close();
// screen::init() needs m_plugin
m_plugin = new Plugin;
init_plugin_api();
if (config()->bData("system.interface.use_cli"))
{
// Init our Screen
screen()->init(VERSION);
}
LOG2(INFO, "Welcome to Mineserver v" + VERSION);
MapGen* mapgen = new MapGen;
MapGen* nethergen = new NetherGen;
MapGen* heavengen = new HeavenGen;
MapGen* biomegen = new BiomeGen;
MapGen* eximgen = new EximGen;
m_mapGenNames.push_back(mapgen);
m_mapGenNames.push_back(nethergen);
m_mapGenNames.push_back(heavengen);
m_mapGenNames.push_back(biomegen);
m_mapGenNames.push_back(eximgen);
m_saveInterval = m_config->iData("map.save_interval");
m_only_helmets = m_config->bData("system.armour.helmet_strict");
m_pvp_enabled = m_config->bData("system.pvp.enabled");
m_damage_enabled = m_config->bData("system.damage.enabled");
const char* key = "map.storage.nbt.directories"; // Prefix for worlds config
if (m_config->has(key) && (m_config->type(key) == CONFIG_NODE_LIST))
{
std::list<std::string> tmp = m_config->mData(key)->keys();
int n = 0;
for (std::list<std::string>::const_iterator it = tmp.begin(); it != tmp.end(); ++it)
{
m_map.push_back(new Map());
Physics* phy = new Physics;
phy->map = n;
m_physics.push_back(phy);
int k = m_config->iData((std::string(key) + ".") + (*it));
if ((uint32_t)k >= m_mapGenNames.size())
{
std::ostringstream s;
s << "Error! Mapgen number " << k << " in config. " << m_mapGenNames.size() << " Mapgens known";
LOG2(INFO, s.str());
}
// WARNING: if k is too big this will be an access error! -- louisdx
MapGen* m = m_mapGenNames[k];
m_mapGen.push_back(m);
n++;
}
}
else
{
LOG2(WARNING, "Cannot find map.storage.nbt.directories.*");
}
if (m_map.size() == 0)
{
LOG2(ERROR, "No worlds in Config!");
return false;
}
m_chat = new Chat;
m_furnaceManager = new FurnaceManager;
m_packetHandler = new PacketHandler;
m_inventory = new Inventory(m_config->sData("system.path.data") + '/' + "recipes", ".recipe", "ENABLED_RECIPES.cfg");
m_mobs = new Mobs;
return true;
}
bool ConfigParser::parse(std::istream& data, ConfigNode::Ptr ptr)
{
ConfigScanner scanner;
ConfigLexer lexer(scanner);
ConfigNode::Ptr root = ptr;
data.seekg(0, std::ios::end);
const size_t data_size = size_t(data.tellg());
data.seekg(0, std::ios::beg);
char* buf = new char[data_size];
data.read(buf, data_size);
std::string data_str(buf, data_size);
delete[] buf;
if (!scanner.read(data_str))
{
std::cerr << "Couldn't read data!\n";
return false;
}
int token_type;
std::string token_data;
std::string token_label;
std::stack<ConfigNode::Ptr> nodeStack;
ConfigNode::Ptr currentNode = root;
nodeStack.push(currentNode);
while (lexer.get_token(token_type, token_data))
{
if (!token_type)
{
std::cerr << "Unrecognised data!\n";
return false;
}
// Include other files only if we're in the root node
if (token_type == CONFIG_TOKEN_ENTITY && token_data == "include" && currentNode == root)
{
int tmp_type;
std::string tmp_data;
lexer.get_token(tmp_type, tmp_data);
if (tmp_type == CONFIG_TOKEN_STRING)
{
if (m_includes >= MAX_INCLUDES)
{
std::cerr << "reached maximum number of include directives: " << m_includes << "\n";
return false;
}
// allow only filename without path
if ((tmp_data.find('/') != std::string::npos)
|| (tmp_data.find('\\') != std::string::npos))
{
std::cerr << "include directive accepts only filename: " << tmp_data << "\n";
return false;
}
// prepend home path
const std::string var = "system.path.home";
const ConfigNode::Ptr node = root->get(var, false);
std::string home;
if (!node || (home = node->sData()).empty())
{
std::cerr << "include directive is not allowed before: " << var << "\n";
return false;
}
tmp_data = relativeToAbsolute(home) + PATH_SEPARATOR + tmp_data;
if (!parse(tmp_data, root))
{
return false;
}
m_includes++;
continue;
}
else
{
lexer.put_token(tmp_type, tmp_data);
}
}
if (token_type == CONFIG_TOKEN_ENTITY || token_type == CONFIG_TOKEN_LABEL)
{
token_label = token_data;
}
else if (token_type == CONFIG_TOKEN_OPERATOR_ASSIGN)
{
if (currentNode != root)
{
currentNode->clear();
}
}
else if (token_type == CONFIG_TOKEN_BOOLEAN)
{
ConfigNode::Ptr newNode(!token_label.empty() && currentNode->has(token_label) ? currentNode->get(token_label) : ConfigNode::Ptr(new ConfigNode));
newNode->setData(token_data == "true");
if (!token_label.empty())
{
currentNode->set(token_label, newNode, true);
token_label.clear();
}
else
{
currentNode->add(newNode);
}
}
else if (token_type == CONFIG_TOKEN_STRING)
{
ConfigNode::Ptr newNode(!token_label.empty() && currentNode->has(token_label) ? currentNode->get(token_label) : ConfigNode::Ptr(new ConfigNode));
newNode->setData(token_data);
if (!token_label.empty())
{
currentNode->set(token_label, newNode, true);
token_label.clear();
}
else
{
currentNode->add(newNode);
}
}
else if (token_type == CONFIG_TOKEN_NUMBER)
{
ConfigNode::Ptr newNode(token_label.size() && currentNode->has(token_label) ? currentNode->get(token_label) : ConfigNode::Ptr(new ConfigNode));
newNode->setData((double)::atof(token_data.c_str()));
if (!token_label.empty())
{
currentNode->set(token_label, newNode, true);
token_label.clear();
}
else
{
currentNode->add(newNode);
}
}
else if (token_type == CONFIG_TOKEN_LIST_OPEN)
{
ConfigNode::Ptr newNode(token_label.size() && currentNode->has(token_label) ? currentNode->get(token_label) : ConfigNode::Ptr(new ConfigNode));
newNode->setType(CONFIG_NODE_LIST);
if (!token_label.empty())
{
currentNode->set(token_label, newNode, true);
newNode = currentNode->get(token_label, true);
token_label.clear();
}
else
{
currentNode->add(newNode);
}
nodeStack.push(currentNode);
currentNode = newNode;
}
else if (token_type == CONFIG_TOKEN_LIST_CLOSE)
{
currentNode = nodeStack.top();
nodeStack.pop();
}
}
return true;
}
/*************************************************************************
Handler for mouse movement events
*************************************************************************/
void Thumb::onMouseMove(MouseEventArgs& e)
{
// default processing
PushButton::onMouseMove(e);
// only react if we are being dragged
if (d_beingDragged)
{
Vector2 delta;
float hmin, hmax, vmin, vmax;
// get some values as absolute pixel offsets
if (getMetricsMode() == Relative)
{
delta = relativeToAbsolute(screenToWindow(e.position));
hmax = relativeToAbsoluteX_impl(d_parent, d_horzMax);
hmin = relativeToAbsoluteX_impl(d_parent, d_horzMin);
vmax = relativeToAbsoluteY_impl(d_parent, d_vertMax);
vmin = relativeToAbsoluteY_impl(d_parent, d_vertMin);
}
else
{
delta = screenToWindow(e.position);
hmin = d_horzMin;
hmax = d_horzMax;
vmin = d_vertMin;
vmax = d_vertMax;
}
// calculate amount of movement in pixels
delta -= d_dragPoint;
//
// Calculate new (pixel) position for thumb
//
Point newPos(getAbsolutePosition());
if (d_horzFree)
{
newPos.d_x += delta.d_x;
// limit value to within currently set range
newPos.d_x = (newPos.d_x < hmin) ? hmin : (newPos.d_x > hmax) ? hmax : newPos.d_x;
}
if (d_vertFree)
{
newPos.d_y += delta.d_y;
// limit new position to within currently set range
newPos.d_y = (newPos.d_y < vmin) ? vmin : (newPos.d_y > vmax) ? vmax : newPos.d_y;
}
// update thumb position if needed
if (newPos != getAbsolutePosition())
{
if (getMetricsMode() == Relative)
{
newPos = absoluteToRelative_impl(d_parent, newPos);
}
setPosition(newPos);
// send notification as required
if (d_hotTrack)
{
WindowEventArgs args(this);
onThumbPositionChanged(args);
}
}
}
e.handled = true;
}
