Games-Axmud
view release on metacpan or search on metacpan
lib/Games/Axmud/Win/Internal.pm view on Meta::CPAN
# Create the Gtk3::Window
my $winWidget = Gtk3::Window->new('toplevel');
if (! $winWidget) {
return undef;
} else {
# Store the IV now, as subsequent code needs it
$self->ivPoke('winWidget', $winWidget);
$self->ivPoke('winBox', $winWidget);
}
# Set up ->signal_connects (other ->signal_connects are set up in the call to
# $self->winEnable() )
$self->setDeleteEvent(); # 'delete-event'
$self->setKeyPressEvent(); # 'key-press-event'
$self->setKeyReleaseEvent(); # 'key-release-event'
# Set up ->signal_connects specified by the calling function, if any
if ($listRef) {
foreach my $func (@$listRef) {
$self->$func();
}
}
# Set the window title. If $title wasn't specified, use a suitable default title
if (! $title) {
if ($self->winType eq 'main') {
$title = $axmud::SCRIPT;
} elsif ($self->winName) {
$title = $self->winName;
} else {
# Emergency fallback - $self->winName should be set
$title = 'Untitled window';
}
}
$winWidget->set_title($title);
# Set the window's default size and position (this will almost certainly be changed before
# the call to $self->winEnable() )
if ($self->winType eq 'main') {
$winWidget->set_default_size(
$axmud::CLIENT->customMainWinWidth,
$axmud::CLIENT->customMainWinHeight,
);
$winWidget->set_border_width($axmud::CLIENT->constMainBorderPixels);
# When workspace grids are disabled, 'main' windows should appear in the middle of the
# desktop
if (! $self->workspaceObj->gridEnableFlag) {
$winWidget->set_position('center');
}
} else {
$winWidget->set_default_size(
$axmud::CLIENT->customGridWinWidth,
$axmud::CLIENT->customGridWinHeight,
);
$winWidget->set_border_width($axmud::CLIENT->constGridBorderPixels);
}
# Set the icon list for this window
$iv = $self->winType . 'WinIconList';
$winWidget->set_icon_list($axmud::CLIENT->desktopObj->{$iv});
# Draw the widgets used by this window
if (! $self->drawWidgets()) {
return undef;
}
# The calling function can now move the window into position, before calling
# $self->winEnable to make it visible, and to set up any more ->signal_connects()
return 1;
}
sub winEnable {
# Called by GA::Obj::Workspace->createGridWin or ->createSimpleGridWin
# After the Gtk3::Window has been setup and moved into position, makes it visible and calls
# any further ->signal_connects that must be not be setup until the window is visible
#
# Expected arguments
# (none besides $self)
#
# Optional arguments
# $listRef - Reference to a list of functions to call, just after the Gtk3::Window is
# created (can be used to set up further ->signal_connects, if this
# window needs them)
#
# Return values
# 'undef' on improper arguments
# 1 on success
my ($self, $listRef, $check) = @_;
# Check for improper arguments
if (defined $check) {
return $axmud::CLIENT->writeImproper($self->_objClass . '->winEnable', @_);
}
# Make the window appear on the desktop
$self->winShowAll($self->_objClass . '->winEnable');
$self->ivPoke('enabledFlag', TRUE);
# # For windows about to be placed on a grid, briefly minimise the window so it doesn't
# # appear in the centre of the desktop before being moved to its correct workspace, size
# # and position
# if ($self->workspaceGridObj && $self->winWidget eq $self->winBox) {
#
# $self->minimise();
# }
# Set up ->signal_connects that must not be set up until the window is visible
$self->setConfigureEvent(); # 'configure-event'
$self->setWindowStateEvent(); # 'window-state-event'
$self->setFocusInEvent(); # 'focus-in-event'
$self->setFocusOutEvent(); # 'focus-out-event'
# Set up ->signal_connects specified by the calling function, if any
if ($listRef) {
foreach my $func (@$listRef) {
$self->$func();
}
}
return 1;
}
sub winDestroy {
# Called by GA::Obj::WorkspaceGrid->stop or by any other function
# Informs the window's strip objects of their imminent demise, informs the parent workspace
# grid (if this 'grid' window is on a workspace grid) and the desktop object, and then
# destroys the Gtk3::Window (if it is open)
#
# Expected arguments
# (none besides $self)
#
# Return values
# 'undef' on improper arguments, if the window can't be destroyed or if it has already
# been destroyed
# 1 on success
my ($self, $check) = @_;
# Check for improper arguments
if (defined $check) {
return $axmud::CLIENT->writeImproper($self->_objClass . '->winDestroy', @_);
}
if (! $self->winBox) {
# Window already destroyed in a previous call to this function
return undef;
}
# Inform this window's strip objects of their imminent demise (in the order in which they
# were created
foreach my $stripObj (sort {$a->number <=> $b->number} ($self->ivValues('stripHash'))) {
$stripObj->objDestroy();
}
# Close any 'free' windows for which this window is a parent
foreach my $winObj ($self->ivValues('childFreeWinHash')) {
$winObj->winDestroy();
}
# Inform the parent workspace grid object (if any)
if ($self->workspaceGridObj) {
$self->workspaceGridObj->del_gridWin($self);
}
# Inform the desktop object
$axmud::CLIENT->desktopObj->del_gridWin($self);
# Destroy the Gtk3::Window
eval { $self->winBox->destroy(); };
if ($@) {
# Window can't be destroyed
return undef;
} else {
$self->ivUndef('winWidget');
$self->ivUndef('winBox');
}
# Inform the ->owner, if there is one
if ($self->owner) {
$self->owner->del_winObj($self);
}
return 1;
}
sub winDisengage {
# Called by GA::Obj::Desktop->removeSessionWindows and GA::Obj::WorkspaceGrid->stop
# Removes this window object from its workspace grid, but does not close the window
# Should not be called, in general
#
# Expected arguments
# (none besides $self)
#
# Optional arguments
# $session - When called by the functions listed above, the GA::Session which is
# closing; otherwise 'undef'
#
# Return values
# 'undef' on improper arguments or if the window can't be disengaged
# 1 on success
my ($self, $session, $check) = @_;
# Check for improper arguments
if (defined $check) {
return $axmud::CLIENT->writeImproper($self->_objClass . '->winDisengage', @_);
}
# Close any 'free' windows for which this window is a parent (but not when a session is
# closing; in that case, only close 'free' windows connected to that session)
foreach my $winObj ($self->ivValues('childFreeWinHash')) {
if (! $session || ($winObj->session && $winObj->session eq $session)) {
$winObj->winDestroy();
}
}
# Inform the parent workspace grid object (if any)
if ($self->workspaceGridObj) {
lib/Games/Axmud/Win/Internal.pm view on Meta::CPAN
}
# Get a list of existing strips that are actually visible
foreach my $stripObj ($self->stripList) {
if ($stripObj->visibleFlag) {
push (@modList, $stripObj);
}
}
# Re-pack all visible strips, leaving a gap between strips that aren't at the beginning or
# end of the list
if (@modList) {
for (my $count = 0; $count < (scalar @modList); $count++) {
my ($stripObj, $spacing);
$stripObj = $modList[$count];
if (! $stripObj->spacingFlag || $count == 0 || $count == (scalar @modList - 1)) {
$spacing = 0;
} else {
$spacing = $self->stripSpacingPixels;
}
if (
$winmapObj->orientation eq 'top'
|| $winmapObj->orientation eq 'left'
) {
$self->packingBox->pack_start(
$stripObj->packingBox,
$stripObj->expandFlag,
$stripObj->fillFlag,
$spacing,
);
} else {
$self->packingBox->pack_end(
$stripObj->packingBox,
$stripObj->expandFlag,
$stripObj->fillFlag,
$spacing,
);
}
}
}
# Sensitise/desensitise widgets according to current conditions
$self->restrictMenuBars();
$self->restrictToolbars();
# Any Gtk3::TextViews will now be using the colours of the most recently-created
# Gtk3::TextView, not the colours that we want them to use. Update colours for all pane
# objects (GA::Table::Pane) before the forthcoming call to ->winShowAll
$self->updateColourScheme(undef, TRUE);
# Make everything visible
$self->winShowAll($self->_objClass . '->redrawWidgets');
$axmud::CLIENT->desktopObj->updateWidgets($self->_objClass . '->redrawWidgets');
# Adding/removing widgets upsets the position of the scrollbar in each tab's textview.
# Make sure all the textviews are scrolled to the bottom
$self->rescrollTextViews();
# Redraw any visible gauges, otherwise the gauge box will be visible, but the gauges
# themselves will have disappeared
$gaugeStripObj = $self->ivShow('firstStripHash', 'Games::Axmud::Strip::GaugeBox');
if ($gaugeStripObj && $gaugeStripObj->visibleFlag) {
$gaugeStripObj->updateGauges();
# (Need to call this a second time, or the re-draw doesn't work...)
$axmud::CLIENT->desktopObj->updateWidgets($self->_objClass . '->redrawWidgets');
}
return 1;
}
# ->signal_connects
sub setDeleteEvent {
# Called by $self->winSetup
# Set up a ->signal_connect to watch out for the user manually closing the 'internal' window
# If it's a 'main' window and there are no 'main' windows left, halt the client
#
# Expected arguments
# (none besides $self)
#
# Return values
# 'undef' on improper arguments
# 1 otherwise
my ($self, $check) = @_;
# Check for improper arguments
if (defined $check) {
return $axmud::CLIENT->writeImproper($self->_objClass . '->setDeleteEvent', @_);
}
if ($self->winType eq 'main' && $axmud::CLIENT->shareMainWinFlag) {
$self->winBox->signal_connect('delete-event' => sub {
# Prompt the user for confirmation, if required
if (! $self->checkConnectedSessions()) {
# Don't close the 'main' window
return 1;
}
# Inform this window's strip objects of their imminent demise (in the order in which
# they were created
foreach my $stripObj (
sort {$a->number <=> $b->number} ($self->ivValues('stripHash'))
) {
$stripObj->objDestroy();
}
# Close any 'free' windows for which this window is a parent
foreach my $winObj ($self->ivValues('childFreeWinHash')) {
$winObj->winDestroy();
}
# Inform the parent workspace grid object (if any)
if ($self->workspaceGridObj) {
$self->workspaceGridObj->del_gridWin($self);
}
# Inform the desktop object
$axmud::CLIENT->desktopObj->del_gridWin($self);
# Halt the client
$axmud::CLIENT->stop();
# Allow Gtk3 to close the window directly
return undef;
});
} else {
$self->winBox->signal_connect('delete-event' => sub {
# Prompt the user for confirmation, if required
if ($self->winType eq 'main' && ! $self->checkConnectedSessions()) {
# Don't close the 'main' window
return 1;
}
# Prevent Gtk3 from taking action directly. Instead redirect the request to
# $self->winDestroy, which does things like resetting a portion of the workspace
# grid, as well as actually destroying the window
return $self->winDestroy();
});
}
return 1;
}
sub setKeyPressEvent {
# Called by $self->winSetup
# Set up a ->signal_connect to watch out for certain key presses
#
# Expected arguments
# (none besides $self)
#
# Return values
# 'undef' on improper arguments or if the ->signal_connect doesn't interfere with the key
# press
# 1 if the ->signal_connect does interfere with the key press, or when the
# ->signal_connect is first set up
my ($self, $check) = @_;
# Check for improper arguments
if (defined $check) {
return $axmud::CLIENT->writeImproper($self->_objClass . '->setKeyPressEvent', @_);
}
$self->winBox->signal_connect('key-press-event' => sub {
my ($widget, $event) = @_;
# Local variables
my (
$keycode, $standard, $string, $directFlag, $stripObj, $paneObj, $tabObj,
$splitScreenMode, $textView, $slice, $clipboard, $vAdjust, $high, $length,
$modValue, $entryText, $bufferObj, $startIter, $endIter,
lib/Games/Axmud/Win/Internal.pm view on Meta::CPAN
} elsif ($standard eq 'shift') {
$self->ivPoke('shiftKeyFlag', FALSE);
} elsif ($standard eq 'alt') {
$self->ivPoke('altKeyFlag', FALSE);
} elsif ($standard eq 'alt_gr') {
$self->ivPoke('altGrKeyFlag', FALSE);
}
if (
! $self->ctrlKeyFlag
&& ! $self->shiftKeyFlag
&& ! $self->altKeyFlag
&& ! $self->altGrKeyFlag
) {
$self->ivPoke('modifierKeyFlag', FALSE);
}
# Return 'undef' to show that we haven't interfered with this keypress
return undef;
});
return 1;
}
sub setConfigureEvent {
# Called by $self->winEnable
# Set up a ->signal_connect to watch out for changes in the window size and position
#
# Expected arguments
# (none besides $self)
#
# Return values
# 'undef' on improper arguments
# 1 otherwise
my ($self, $check) = @_;
# Check for improper arguments
if (defined $check) {
return $axmud::CLIENT->writeImproper($self->_objClass . '->setConfigureEvent', @_);
}
$self->winBox->signal_connect('configure-event' => sub {
my ($widget, $event) = @_;
# Has the window size actually changed, or just its position?
if (
! defined $self->actualWinWidth # Windows size checked for the first time
|| $event->width != $self->actualWinWidth
|| $event->height != $self->actualWinHeight
) {
$self->ivPoke('actualWinWidth', $event->width);
$self->ivPoke('actualWinHeight', $event->height);
}
# Every textview object (GA::Obj::TextView) in this window must update its size IVs,
# which informs the GA::Session (so it can send NAWS data to the world)
foreach my $textViewObj ($axmud::CLIENT->desktopObj->ivValues('textViewHash')) {
if ($textViewObj->winObj eq $self) {
# Update the IVs once the changes have been rendered
$textViewObj->set_sizeUpdateFlag();
}
}
# Let the GA::Client store the most recent size and position for a window of this
# ->winName, if it needs to
if ($self->winWidget) {
$axmud::CLIENT->add_storeGridPosn(
$self,
$self->winWidget->get_position(),
$self->winWidget->get_size(),
);
}
# Without returning 'undef', the window's strip/table objects aren't resized along with
# the window
return undef;
});
return 1;
}
sub setWindowStateEvent {
# Called by $self->winEnable
# Set up a ->signal_connect to watch out for when the window is maximised and unmaximised
#
# Expected arguments
# (none besides $self)
#
# Return values
# 'undef' on improper arguments
# 1 otherwise
my ($self, $check) = @_;
# Check for improper arguments
if (defined $check) {
return $axmud::CLIENT->writeImproper($self->_objClass . '->setWindowStateEvent', @_);
}
$self->winBox->signal_connect('window-state-event' => sub {
# When the window is maximised and unmaximised, gauges in the gauge box (if visible) are
# not redrawn properly. This block of code fixes that problem (but I don't know why it
# works)
my ($widget, $event) = @_;
if ($event->changed_mask() =~ m/maximized/) {
# This code makes sure textview(s) in pane object(s) are scrolled to the bottom
# after un-maximising a window (otherwise, the scrollbar position moves
# confusingly)
lib/Games/Axmud/Win/Internal.pm view on Meta::CPAN
return undef;
}
foreach my $tableObj ($self->tableStripObj->ivValues('tableObjHash')) {
if ($tableObj->type eq 'pane') {
$tableObj->applyColourScheme(
undef, # Apply to all tabs in the pane object
$colourScheme,
);
}
}
return 1;
}
sub rescrollTextViews {
# Can be called by anyting
# After a change in position of any window widgets, make sure any textview(s) in pane
# object(s) are scrolled to the bottom (this saves a lot of user frustration)
#
# Expected arguments
# (none besides $self)
#
# Return values
# 'undef' on improper arguments or if this isn't the 'main' window
# 1 otherwise
my ($self, $check) = @_;
# Local variables
my $stripObj;
# Check for improper arguments
if (defined $check) {
return $axmud::CLIENT->writeImproper($self->_objClass . '->rescrollTextViews', @_);
}
foreach my $tableObj ($self->tableStripObj->ivValues('tableObjHash')) {
if ($tableObj->type eq 'pane') {
foreach my $tabObj ($tableObj->ivValues('tabObjHash')) {
$tabObj->textViewObj->scrollToBottom();
}
}
}
# After drawing gauges or unmaximising the window, the focus is lost from the command entry
# box, so restore it
$stripObj = $self->ivShow('firstStripHash', 'Games::Axmud::Strip::Entry');
if ($stripObj && $stripObj->entry) {
$stripObj->entry->grab_focus();
}
$axmud::CLIENT->desktopObj->updateWidgets($self->_objClass . '->rescrollTextViews');
return 1;
}
sub findTableObj {
# Can be called by anything
# Finds the first table object of a particular type created in the compulsory table strip
# object, if there is one
#
# Expected arguments
# $type - The type of table object; matches the table object's type (e.g. 'pane' for
# pane objects)
#
# Return values
# 'undef' on improper arguments or if there is no table object of the specified type in
# the Gtk3::Grid
# Otherwise returns the table object of the specified type with the lowest ->number
my ($self, $type, $check) = @_;
# Local variables
my @tableObjList;
# Check for improper arguments
if (! defined $type || defined $check) {
return $axmud::CLIENT->writeImproper($self->_objClass . '->findFirstTableObj', @_);
}
@tableObjList = sort {$a->number <=> $b->number}
($self->tableStripObj->ivValues('tableObjHash'));
foreach my $tableObj (@tableObjList) {
if ($tableObj->type eq $type) {
return $tableObj;
}
}
# No table object of the right $type found
return undef;
}
sub setVisibleSession {
# Called by GA::Table::Pane->respondVisibleTab, when a session's default tab becomes the
# visible tab in that pane. Only called when this window is a 'main' window
# Should not be called by anything else - call GA::Table::Pane->setVisibleTab instead
#
# Sets $self->visibleSession and performs a number of housekeeping duties
#
# Expected arguments
# (none besides $self)
#
# Optional arguments
# $session - The GA::Session that is the new visible session. If 'undef', there is no
# visible session in this window
#
# Return values
# 'undef' on improper arguments
# 1 otherwise
my ($self, $session, $check) = @_;
# Local variables
my ($tabObj, $paneObj, $visibleTabObj);
# Check for improper arguments
if (defined $check) {
return $axmud::CLIENT->writeImproper($self->_objClass . '->setVisibleSession', @_);
}
# This function shouldn't be called unless this is a 'main' window
if ($self->winType ne 'main') {
return $self->writeError(
'Cannot set a visible session outside a \'main\' window',
$self->_objClass . '->setVisibleSession',
);
}
# Cease navigating through instruction/world command buffers in all windows (if the user has
# been doing that using the 'up'/'down' arrow keys in any window)
$axmud::CLIENT->set_instructBufferPosn();
$axmud::CLIENT->set_cmdBufferPosn();
foreach my $otherSession ($axmud::CLIENT->listSessions()) {
$otherSession->set_instructBufferPosn();
$otherSession->set_cmdBufferPosn();
}
# No visible session
if (! $session) {
# Update certain strip objects in any 'internal' window used by the old visible session
# (if any; the TRUE flag means 'return 'internal' windows only)
foreach my $winObj (
$axmud::CLIENT->desktopObj->listSessionGridWins($self->visibleSession, TRUE)
) {
# Update information stored in the window's connection info strip, if visible
$winObj->setHostLabel('');
$winObj->setTimeLabel('');
# Reset the window's entry box and blinkers, if visible
$winObj->resetEntry();
$winObj->resetBlinkers();
}
# Update the GA::Client's IVs
if (
$axmud::CLIENT->currentSession
&& $self->visibleSession
&& $axmud::CLIENT->currentSession eq $self->visibleSession
) {
$axmud::CLIENT->setCurrentSession();
}
# Update this window's IVs
$self->ivUndef('visibleSession');
if ($self->winType eq 'main') {
$self->ivUndef('workspaceGridObj');
}
# New visible session
} else {
# If this window is a 'main' window shared by all sessions...
if (
$axmud::CLIENT->shareMainWinFlag
&& $self->visibleSession
&& $self->visibleSession ne $session
) {
# ...need to hide windows on the former visible session's workspace grids (though
# obviously not the shared 'main' window)
$axmud::CLIENT->desktopObj->hideGridWins($self->visibleSession);
# The new visible session's windows, on the other hand, need to be un-hidden
$axmud::CLIENT->desktopObj->revealGridWins($session);
# Fire any hooks that are using the 'not_visible' hook event
$self->visibleSession->checkHooks('not_visible', $session->number);
}
# Update the GA::Client's IVs
# ->currentSession is modified only when a 'main' window that's in focus changes its
# ->visibleSession (exception - if the IV isn't set at all, set it regardless of
# whether this window has the focus, or not)
if (! $axmud::CLIENT->currentSession || $self->focusFlag) {
$axmud::CLIENT->setCurrentSession($session);
}
# Update this window's IVs
$self->ivPoke('visibleSession', $session);
# For 'main' windows only, find the workspace grid used by this session (might be a
# shared grid), and update the IV
if ($self->winType eq 'main' && $self->workspaceObj) {
# (In case the grid can't be found, use a default 'undef' value)
$self->ivUndef('workspaceGridObj');
OUTER: foreach my $gridObj (
sort {$a->number <=> $b->number}
($self->workspaceObj->ivValues('gridHash'))
) {
if (
! defined $gridObj->owner # Shared workspace grid
|| $gridObj->owner eq $session
) {
$self->ivPoke('workspaceGridObj', $gridObj);
last OUTER;
}
}
}
# In case the change of visible session isn't the result of the user clicking a
# session's default tab, make the new visible session's default tab the visible one.
# If that default tab is a simple tab, then there's nothing to do
# ($session->defaultTabObj won't be set yet, if $session->start is still executing)
if ($session->defaultTabObj) {
$paneObj = $session->defaultTabObj->paneObj;
$tabObj = $paneObj->findSession($session);
$visibleTabObj = $paneObj->getVisibleTab();
if ($paneObj->notebook && $tabObj && $visibleTabObj && $tabObj ne $visibleTabObj) {
$paneObj->setVisibleTab($tabObj);
}
}
# If the session's tab label is in a different colour, meaning that text had been
# received from the world but hadn't been viewed by the user yet, reset the flag to
# show that the text is now visible to the user
$session->reset_showNewTextFlag();
# Update information stored in the 'main' window's connection info strip, if visible
$self->setHostLabel($session->getHostLabelText());
$self->setTimeLabel($session->getTimeLabelText());
# Update certain strip objects in any 'internal' window used by the new visible session
# (if any; the TRUE flag means 'return 'internal' windows only)
foreach my $winObj ($axmud::CLIENT->desktopObj->listSessionGridWins($session, TRUE)) {
# Reset the 'internal' window's entry box and blinkers, if any
$winObj->resetEntry();
$winObj->resetBlinkers();
}
# Fire any hooks that are using the 'visible_session' hook event
$session->checkHooks('visible_session', undef);
# Fire any hooks that are using the 'change_visible' hook event
foreach my $otherSession ($axmud::CLIENT->listSessions()) {
if ($otherSession ne $session) {
$otherSession->checkHooks('change_visible', $session->number);
}
}
}
# Update all 'internal' windows
foreach my $winObj ($axmud::CLIENT->desktopObj->listGridWins()) {
if (
$winObj->winType eq 'main'
|| $winObj->winType eq 'protocol'
|| $winObj->winType eq 'custom'
) {
# Sensitise/desensitise menu items in 'internal' windows, as appropriate
$winObj->restrictMenuBars();
$winObj->restrictToolbars();
# Update the gauge box, if visible
$winObj->updateGauges();
# Sensitise or desensitise widgets, as appropriate
$winObj->setWidgetsIfSession();
# Update widgets, as appropriate
$winObj->setWidgetsChangeSession();
# Make any changes visible
$winObj->winShowAll($self->_objClass . '->setVisibleSession');
}
}
return 1;
}
sub checkConnectedSessions {
# Called by $self->setDeleteEvent
# If the user tries to manually close a 'main' window, counts the number of connected
# sessions (not including disconencted or 'connect offline' mode sessions) using this
# window as their 'main' window
# If any are found, prompts the user for confirmation (if the GA::Client flag requires us
# to do that)
#
# Expected arguments
# (none besides $self)
#
# Return values
# 'undef' on improper arguments or if the window should not be closed
# 1 if the window can be closed
my ($self, $check) = @_;
# Local variables
my ($count, $choice, $msg);
# Check for improper arguments
if (defined $check) {
return $axmud::CLIENT->writeImproper(
$self->_objClass . '->checkConnectedSessions',
@_,
);
}
if (! $axmud::CLIENT->confirmCloseMainWinFlag) {
# The window can be closed - no confirmation required
return 1;
}
lib/Games/Axmud/Win/Internal.pm view on Meta::CPAN
return $axmud::CLIENT->writeImproper($self->_objClass . '->setWinTitle', @_);
}
if ($self->enabledFlag && $self->winType ne 'main' && $self->winWidget eq $self->winBox) {
$self->winWidget->set_title($text);
}
return 1;
}
sub restrictMenuBars {
# Called by GA::Obj::Desktop->restrictWidgets
# Sensitise or desensitise the menu bar in this 'internal' window, depending on current
# conditions. (Don't do anything if this window doesn't use a strip object for a menu bar)
#
# Expected arguments
# (none besides $self)
#
# Return values
# 'undef' on improper arguments or if this window doesn't use a strip object for a menu
# bar
# 1 otherwise
my ($self, $check) = @_;
# Local variables
my (
$stripObj, $openFlag, $setupFlag,
@list, @sensitiseList, @desensitiseList,
);
# Check for improper arguments
if (defined $check) {
return $axmud::CLIENT->writeImproper($self->_objClass . '->restrictMenuBars', @_);
}
# Get the strip object
$stripObj = $self->ivShow('firstStripHash', 'Games::Axmud::Strip::MenuBar');
if (! $stripObj) {
# Nothing to sensitise/desensitise
return undef;
}
# Test whether this is a 'main' window with a visible session whose status is 'connected' or
# 'offline' (for the sake of efficiency)
if (
$self->visibleSession
&& (
$self->visibleSession->status eq 'connected'
|| $self->visibleSession->status eq 'offline'
)
) {
$openFlag = TRUE;
}
# Test whether the setup wizwin is open (in which case, almost everything is desensitised)
OUTER: foreach my $winObj ($axmud::CLIENT->desktopObj->ivValues('freeWinHash')) {
if ($winObj->isa('Games::Axmud::WizWin::Setup')) {
$setupFlag = TRUE;
# In addition, the following menu items are desensitised
push (@desensitiseList,
# 'World' column
'connect', 'stop_client',
# 'Edit' column
'test_pattern',
# 'Help' column
'help', 'about', 'credits', 'license',
);
last OUTER;
}
}
# Menu bar items that require a 'main' window with a visible session
@list = (
# 'World' column
'reconnect', 'reconnect_offline',
'xconnect', 'xconnect_offline',
'quit_all',
'exit_all',
'stop_session',
# 'File' column
'test_file',
'show_files', 'show_file_meta',
# 'Axbasic' column
'check_script', 'edit_script',
# 'Plugins' column
'load_plugin', 'show_plugin',
);
if (! $setupFlag && $self->visibleSession) {
push (@sensitiseList, @list);
} else {
push (@desensitiseList, @list);
}
# Menu bar items that require a 'main' window with a visible session whose status is
# 'connected' or 'offline'
@list = (
# 'World' column
'login',
'quit', 'qquit',
'exit', 'xxit',
# 'File' column
'load_all', 'load_file',
'save_all', 'save', 'save_options',
'import_files',
# 'export_all_files', 'export_file',
'export_file',
'import_data',
'export_data',
'backup_restore_data',
'disable_world_save', 'disable_save_load',
# 'Edit' column
lib/Games/Axmud/Win/Internal.pm view on Meta::CPAN
# Sensitise/desensitise menu bar items
$stripObj->sensitiseWidgets(@sensitiseList);
$stripObj->desensitiseWidgets(@desensitiseList);
# All menu items added by plugins require a 'main' window with a visible session, and the
# plugin itself must be must be enabled
foreach my $plugin ($stripObj->ivKeys('pluginMenuItemHash')) {
my ($widget, $pluginObj);
$widget = $stripObj->ivShow('pluginMenuItemHash', $plugin);
$pluginObj = $axmud::CLIENT->ivShow('pluginHash', $plugin);
if (! $setupFlag && $self->visibleSession && $pluginObj->enabledFlag) {
$widget->set_sensitive(TRUE);
} else {
$widget->set_sensitive(FALSE);
}
}
return 1;
}
sub restrictToolbars {
# Called by GA::Obj::Desktop->restrictWidgets
# Sensitise or desensitise the toolbar in this 'internal' window, depending on current
# conditions. (Don't do anything if this window doesn't use a strip object for a toolbar)
#
# Expected arguments
# (none besides $self)
#
# Return values
# 'undef' on improper arguments or if this window doesn't use a strip object for a toolbar
# 1 otherwise
my ($self, $check) = @_;
# Local variables
my (
$stripObj,
@list, @sensitiseList, @desensitiseList,
);
# Check for improper arguments
if (defined $check) {
return $axmud::CLIENT->writeImproper($self->_objClass . '->restrictToolbars', @_);
}
# Get the strip object
$stripObj = $self->ivShow('firstStripHash', 'Games::Axmud::Strip::Toolbar');
if (! $stripObj) {
# Nothing to sensitise/desensitise
return undef;
}
# Test whether the setup wizwin is open (in which case, everything is desensitised)
OUTER: foreach my $winObj ($axmud::CLIENT->desktopObj->ivValues('freeWinHash')) {
if ($winObj->isa('Games::Axmud::WizWin::Setup')) {
foreach my $widget ($stripObj->toolbarWidgetList) {
$widget->set_sensitive(FALSE);
}
return 1;
}
}
# Toolbar buttons that require a 'main' window with a visible session
@list = $stripObj->ivKeys('requireSessionHash');
if ($self->visibleSession) {
push (@sensitiseList, @list);
} else {
push (@desensitiseList, @list);
}
# Toolbar buttons that require a 'main' window with a visible session whose status is
# 'connected' or 'offline'
@list = $stripObj->ivKeys('requireConnectHash');
if (
$self->visibleSession
&& (
$self->visibleSession->status eq 'connected'
|| $self->visibleSession->status eq 'offline'
)
) {
push (@sensitiseList, @list);
} else {
push (@desensitiseList, @list);
}
# Sensitise/desensitise toolbar items
$stripObj->sensitiseWidgets(@sensitiseList);
$stripObj->desensitiseWidgets(@desensitiseList);
return 1;
}
sub setWidgetsIfSession {
# Called by $self->setVisibleSession
# Calls each strip object (and, for GA::Strip::Table, any child table objects) so they can
# sensitise or desensitise their widgets, depending on whether this window has a
# ->visibleSession, or not
#
# Expected arguments
# (none besides $self)
#
# Return values
# 'undef' on improper arguments
# 1 otherwise
my ($self, $check) = @_;
lib/Games/Axmud/Win/Internal.pm view on Meta::CPAN
if (defined $check) {
return $axmud::CLIENT->writeImproper(
$self->_objClass . '->setWidgetsChangeSession',
@_,
);
}
foreach my $stripObj ($self->ivValues('stripHash')) {
$stripObj->setWidgetsChangeSession();
}
return 1;
}
# Strip object functions
sub resetWinmap {
# Returns the window to its initial state by removing all table objects and strip objects,
# and applying the specified winmap (which might be the same as the previous one)
# Useful for 'main' windows when the 'main_wait' winmap should be applied, or replaced
# after being replied
# Probably not useful for other 'internal' windows, though if code needs to apply the
# equivalent 'internal_wait' winmap and, at some later time, replace it with something
# else, it can
#
# Expected arguments
# $winmapName - The name of the new winmap
#
# Return values
# 'undef' on improper arguments or if the specified winmap doesn't exist
# 1 otherwise
my ($self, $winmapName, $check) = @_;
# Local variables
my $winmapObj;
# Check for improper arguments
if (defined $check) {
return $axmud::CLIENT->writeImproper($self->_objClass . '->resetWinmap', @_);
}
# Check the specified winmap exists
$winmapObj = $axmud::CLIENT->ivShow('winmapHash', $winmapName);
if (! $winmapObj) {
return undef;
}
# Remove all strip objects (table objects in the compulsory Gtk3::Grid are also destroyed)
foreach my $stripObj ($self->ivValues('stripHash')) {
$stripObj->objDestroy();
if ($stripObj->visibleFlag) {
$axmud::CLIENT->desktopObj->removeWidget($self->packingBox, $stripObj->packingBox);
}
}
# Remove the Gtk3::HBox or Gtk3::VBox into which everything is packed
$axmud::CLIENT->desktopObj->removeWidget($self->winBox, $self->packingBox);
# Update IVs
$self->ivUndef('packingBox');
$self->ivEmpty('stripHash');
$self->ivEmpty('firstStripHash');
$self->ivPoke('stripCount', 0);
$self->ivEmpty('stripList');
$self->ivUndef('tableStripObj');
$self->ivPoke('winmap', $winmapObj->name);
# Set up the window with its strip objects and table objects as if the window had just been
# created
$self->drawWidgets();
$self->winShowAll($self->_objClass . '->resetWinmap');
# This should already be set
$self->ivPoke('enabledFlag', TRUE);
return 1;
}
sub getWinmap {
# Called by $self->addStripObj and ->revealStripObj
# If $self->winmap is set (to the name of a winmap object), returns the winmap object
# (GA::Obj::Winmap) itself
# Otherwise returns an appropirate default winmap object
#
# Expected arguments
# (none besides $self)
#
# Return values
# 'undef' on improper arguments
# Otherwise returns a winmap object (GA::Obj::Winmap)
my ($self, $check) = @_;
# Local variables
my $winmapObj;
# Check for improper arguments
if (defined $check) {
return $axmud::CLIENT->writeImproper($self->_objClass . '->getWinmap', @_);
}
$winmapObj = $axmud::CLIENT->ivShow('winmapHash', $self->winmap);
if (! $winmapObj) {
if ($self->winType eq 'main') {
if ($axmud::CLIENT->activateGridFlag) {
$winmapObj = $axmud::CLIENT->ivShow(
'winmapHash',
$axmud::CLIENT->defaultEnabledWinmap,
);
} else {
lib/Games/Axmud/Win/Internal.pm view on Meta::CPAN
} else {
$spacing = $self->stripSpacingPixels;
}
if ($index > -1) {
$self->packingBox->pack_start(
$stripObj->packingBox,
$stripObj->expandFlag,
$stripObj->fillFlag,
$spacing,
);
if ($index > 0) {
$self->packingBox->reorder_child($stripObj->packingBox, $posn);
}
} else {
$self->packingBox->pack_end(
$stripObj->packingBox,
$stripObj->expandFlag,
$stripObj->fillFlag,
$spacing,
);
}
}
# Update IVs
$self->ivAdd('stripHash', $stripObj->number, $stripObj);
if (! $self->ivExists('firstStripHash', $packageName)) {
$self->ivAdd('firstStripHash', $packageName, $stripObj);
}
$self->ivIncrement('stripCount');
$self->ivSplice('stripList', $index, 0, $stripObj);
if ($packageName eq 'Games::Axmud::Strip::Table') {
$self->ivPoke('tableStripObj', $stripObj);
}
# Notify all other strip objects of the new strip object's birth
foreach my $otherStripObj (
sort {$a->number <=> $b->number} ($self->ivValues('stripHash'))
) {
if ($otherStripObj ne $stripObj) {
$otherStripObj->notify_addStripObj($stripObj);
}
}
# Sensitise/desensitise widgets according to current conditions
$self->restrictMenuBars();
$self->restrictToolbars();
# Make everything visible
$self->winShowAll($self->_objClass . '->addStripObj');
$axmud::CLIENT->desktopObj->updateWidgets($self->_objClass . '->addStripObj');
# Adding/removing widgets upsets the position of the scrollbar in each tab's textview.
# Make sure all the textviews are scrolled to the bottom
$self->rescrollTextViews();
# Redraw any visible gauges, otherwise the gauge box will be visible, but the gauges
# themselves will have disappeared
$gaugeStripObj = $self->ivShow('firstStripHash', 'Games::Axmud::Strip::GaugeBox');
if ($gaugeStripObj && $gaugeStripObj->visibleFlag) {
$gaugeStripObj->updateGauges();
# (Need to call this a second time, or the re-draw doesn't work...)
$axmud::CLIENT->desktopObj->updateWidgets($self->_objClass . '->addStripObj');
}
return $stripObj;
}
sub removeStripObj {
# Can be called by anything
# Removes a strip object (inheriting from GA::Generic::Strip) from the list of strip objects
# that can be displayed in this window (whether the Gtk widget was actually drawn, or not,
# depends on the value of the strip object's ->visibleFlag)
# Can't be used to remove the compulsory GA::Strip::Table object
#
# Expected arguments
# $stripObj - The strip object to remove
#
# Return values
# 'undef' on improper arguments, if $stripObj is the compulsory GA::Strip::Table object
# or if the object doesn't exist
# 1 otherwise
my ($self, $stripObj, $check) = @_;
# Local variables
my (
$gaugeStripObj,
@stripList, @resetList,
);
# Check for improper arguments
if (! defined $stripObj || defined $check) {
return $axmud::CLIENT->writeImproper($self->_objClass . '->removeStripObj', @_);
}
# The GA::Strip::Table object is compulsory, also check that the strip object actually
# exists in the window
if (
$stripObj->_objClass eq 'Games::Axmud::Strip::Table'
|| ! $self->ivExists('stripHash', $stripObj->number)
) {
return undef
}
# Tell the strip object it's about to be removed, so it can do any necessary tidying up
$stripObj->objDestroy();
# Remove the Gtk3 widget that's contains the whole strip
$axmud::CLIENT->desktopObj->removeWidget($self->packingBox, $stripObj->packingBox);
# Remove the object by updating IVs
$self->ivDelete('stripHash', $stripObj->number);
foreach my $otherObj ($self->stripList) {
if ($otherObj ne $stripObj) {
push (@stripList, $otherObj);
}
}
$self->ivPoke('stripList', @stripList);
# $self->firstStripHash contains the earliest-created instance of this type of strip object.
# Update or reset it
$self->ivDelete('firstStripHash', $stripObj->_objClass);
@resetList = sort {$a->number <=> $b->number} ($self->ivValues('stripHash'));
OUTER: foreach my $otherObj (@resetList) {
if ($otherObj->_objClass eq $stripObj->_objClass) {
$self->ivAdd('firstStripHash', $otherObj->_objClass, $otherObj);
last OUTER;
}
}
# Notify all other strip objects of this strip object's demise
foreach my $otherStripObj (
sort {$a->number <=> $b->number} ($self->ivValues('stripHash'))
) {
if ($otherStripObj ne $stripObj) {
$otherStripObj->notify_removeStripObj($stripObj);
}
}
# Sensitise/desensitise widgets according to current conditions
$self->restrictMenuBars();
$self->restrictToolbars();
# Make everything visible
$self->winShowAll($self->_objClass . '->removeStripObj');
$axmud::CLIENT->desktopObj->updateWidgets($self->_objClass . '->removeStripObj');
# Hack to resolve a Gtk3 issue, in which a white area appears at the bottom of textviews
# when the gauge strip object is removed (and possibly in similar situations)
foreach my $tableObj ($self->tableStripObj->ivValues('tableObjHash')) {
if ($tableObj->type eq 'pane') {
foreach my $tabObj ($tableObj->ivValues('tabObjHash')) {
$tabObj->textViewObj->insertNewLine();
}
}
}
# Adding/removing widgets upsets the position of the scrollbar in each tab's textview.
# Make sure all the textviews are scrolled to the bottom
$self->rescrollTextViews();
# Redraw any visible gauges, otherwise the gauge box will be visible, but the gauges
# themselves will have disappeared
$gaugeStripObj = $self->ivShow('firstStripHash', 'Games::Axmud::Strip::GaugeBox');
if ($gaugeStripObj && $gaugeStripObj->visibleFlag) {
$gaugeStripObj->updateGauges();
# (Need to call this a second time, or the re-draw doesn't work...)
$axmud::CLIENT->desktopObj->updateWidgets($self->_objClass . '->removeStripObj');
}
return 1;
}
sub addStrip {
# Convenient shortcut to $self->addStripObj, which expects a package name like
# GA::Strip::GaugeBox as an argument
#
# This function accepts a string, which can be any of the following (case-insensitive):
# 'menu' / 'menubar' / 'menu_bar' - adds a GA::Strip::MenuBar
# 'tool' / 'toolbar' / 'tool_bar' - adds a GA::Strip::Toolbar
# 'gauge' / 'gaugebox' / 'gauge_box' - adds a GA::Strip::GaugeBox
# 'entry' - adds a GA::Strip::Entry
# 'connect' / 'info' / 'connectinfo' / 'connect_info'
# - adds a GA::Strip::ConnectInfo
#
# The string can also be a part of the package name itself. For example, if you create your
# own GA::Strip::MyObject (inheriting from GA::Strip::Custom), then this function expects
# the string 'MyObject' (case-sensitive)
# NB This function is not able to check that the package actually exists, although Axmud's
# built-in strip objects always exist
# NB This function can't be used to add the compulsory GA::Strip::Table which already
# exists
#
# Expected arguments
# $string - The string described above
#
# Optional arguments
# $index - The new strip object's position in the window. Strip objects are stored in
# $self->stripList, in the order in which they're drawn (which could be
# top to bottom, bottom to top, left to right or right to left). $index
# specifies the position in that list at which the new strip object is
# inserted. If $index is 0, the strip object is inserted at the beginning
# of the list. If $index is 1, it's inserted second, if $index is 2, it's
# inserted third, and so on. If $index is 'undef', or if its index is
# outside the list, the strip object is inserted at the beginning of the
# list
#
# Return values
# 'undef' on improper arguments or if the strip object can't be added
# Otherwise returns the strip object added
my ($self, $string, $index, $check) = @_;
# Local variables
my $packageName;
# Check for improper arguments
if (! defined $string || defined $check) {
return $axmud::CLIENT->writeImproper($self->_objClass . '->addStrip', @_);
}
# Convert $string into a package name
$packageName = $self->convertPackageName($string);
if (! $packageName || $packageName eq 'Games::Axmud::Strip::Table') {
return undef;
lib/Games/Axmud/Win/Internal.pm view on Meta::CPAN
return $axmud::CLIENT->writeImproper($self->_objClass . '->removeStrip', @_);
}
# Convert $string into a package name
$packageName = $self->convertPackageName($string);
if (! $packageName || $packageName eq 'Games::Axmud::Strip::Table') {
return undef;
}
# Find the earliest-created instance of that strip object
$stripObj = $self->ivShow('firstStripHash', $packageName);
if (! $stripObj) {
return undef;
} else {
return $self->removeStripObj($stripObj);
}
}
sub hideStripObj {
# Can be called by anything
# Hides a visible strip object; the strip object remains in the list of strip objects this
# window can display, but the Gtk widget itself is no longer drawn
# Can't be used to hide the compulsory GA::Strip::Table object
#
# Expected arguments
# $stripObj - The strip object to hide
#
# Return values
# 'undef' on improper arguments, if $stripObj is the compulsory GA::Strip::Table object,
# if the object doesn't exist or if it is already hidden
# 1 otherwise
my ($self, $stripObj, $check) = @_;
# Local variables
my $gaugeStripObj;
# Check for improper arguments
if (! defined $stripObj || defined $check) {
return $axmud::CLIENT->writeImproper($self->_objClass . '->hideStripObj', @_);
}
# The GA::Strip::Table object is compulsory, also check that the strip object actually
# exists in the window object's list of strip objects and is actually visible
if (
$stripObj->_objClass eq 'Games::Axmud::Strip::Table'
|| ! $self->ivExists('stripHash', $stripObj->number)
|| ! $stripObj->visibleFlag
) {
return undef
}
# Remove the Gtk3 widget that contains the whole strip
$axmud::CLIENT->desktopObj->removeWidget($self->packingBox, $stripObj->packingBox);
# Update IVs
$stripObj->set_visibleFlag(FALSE);
# Sensitise/desensitise widgets according to current conditions
$self->restrictMenuBars();
$self->restrictToolbars();
# Make everything visible
$self->winShowAll($self->_objClass . '->hideStripObj');
$axmud::CLIENT->desktopObj->updateWidgets($self->_objClass . '->hideStripObj');
# Hack to resolve a Gtk3 issue, in which a white area appears at the bottom of textviews
# when the gauge strip object is removed (and possibly in similar situations)
foreach my $tableObj ($self->tableStripObj->ivValues('tableObjHash')) {
if ($tableObj->type eq 'pane') {
foreach my $tabObj ($tableObj->ivValues('tabObjHash')) {
$tabObj->textViewObj->insertNewLine();
}
}
}
# Adding/removing widgets upsets the position of the scrollbar in each tab's textview.
# Make sure all the textviews are scrolled to the bottom
$self->rescrollTextViews();
# Redraw any visible gauges, otherwise the gauge box will be visible, but the gauges
# themselves will have disappeared
$gaugeStripObj = $self->ivShow('firstStripHash', 'Games::Axmud::Strip::GaugeBox');
if ($gaugeStripObj && $gaugeStripObj->visibleFlag) {
$gaugeStripObj->updateGauges();
# (Need to call this a second time, or the re-draw doesn't work...)
$axmud::CLIENT->desktopObj->updateWidgets($self->_objClass . '->hideStripObj');
}
return 1;
}
sub revealStripObj {
# Can be called by anything
# Reveals a hidden strip object; the strip object was still in the list of strip objects
# this window can display, but the Gtk widget itself was not drawn, so draw it and add it
# to the window
#
# Expected arguments
# $stripObj - The strip object to reveal
#
# Return values
# 'undef' on improper arguments, if the object doesn't exist, if it is already visible or
# if there's an error in revealing it
# 1 otherwise
my ($self, $stripObj, $check) = @_;
# Local variables
my ($winmapObj, $count, $posn, $spacing, $gaugeStripObj);
# Check for improper arguments
if (! defined $stripObj || defined $check) {
return $axmud::CLIENT->writeImproper($self->_objClass . '->revealStripObj', @_);
}
# Get the winmap object specified by $self->winmap, or a default winmap, if $self->winmap
# is 'undef'
$winmapObj = $self->getWinmap();
# Check that the strip object actually exists in the window object's list of strip objects
# and is actually hidden
if (! $self->ivExists('stripHash', $stripObj->number) || $stripObj->visibleFlag) {
return undef
}
# Find the strip object's position in the list of visible strip objects
$count = 0;
OUTER: foreach my $otherObj ($self->stripList) {
if ($otherObj eq $stripObj) {
$posn = $count;
last OUTER;
} elsif ($otherObj->visibleFlag) {
$count++;
}
}
if (! defined $posn) {
# Strip object is missing (for some unlikely reason)
return undef;
}
# Draw the strip object's widgets
if (! $stripObj->objEnable($winmapObj)) {
return undef;
}
# Pack the newly-visible strip, leaving a gap if it's not at the beginning or end of the
# list
if (! $count || $posn == ($count - 1)) {
$spacing = 0;
} else {
$spacing = $self->stripSpacingPixels;
}
$self->packingBox->pack_start(
$stripObj->packingBox,
$stripObj->expandFlag,
$stripObj->fillFlag,
$spacing,
);
if ($posn != 0) {
$self->packingBox->reorder_child($stripObj->packingBox, $posn);
}
# Update IVs
$stripObj->set_visibleFlag(TRUE);
# Sensitise/desensitise widgets according to current conditions
$self->restrictMenuBars();
$self->restrictToolbars();
# Make everything visible
$self->winShowAll($self->_objClass . '->revealStripObj');
$axmud::CLIENT->desktopObj->updateWidgets($self->_objClass . '->revealStripObj');
# Adding/removing widgets upsets the position of the scrollbar in each tab's textview.
# Make sure all the textviews are scrolled to the bottom
$self->rescrollTextViews();
# Redraw any visible gauges, otherwise the gauge box will be visible, but the gauges
# themselves will have disappeared
$gaugeStripObj = $self->ivShow('firstStripHash', 'Games::Axmud::Strip::GaugeBox');
if ($gaugeStripObj && $gaugeStripObj->visibleFlag) {
$gaugeStripObj->updateGauges();
# (Need to call this a second time, or the re-draw doesn't work...)
$axmud::CLIENT->desktopObj->updateWidgets($self->_objClass . '->revealStripObj');
}
return 1;
}
sub replaceStripObj {
# Can be called by anything
# If a strip object has been redrawn for any reason, replace the old Gtk widget with the
# new one. The strip object's ->packingBox IV must already have been set to the new Gtk
# widget before calling this function
#
# Expected arguments
# $stripObj - The strip object to replace
#
# Return values
# 'undef' on improper arguments, if the object doesn't exist or if it hidden
# 1 otherwise
my ($self, $stripObj, $check) = @_;
# Local variables
my ($count, $posn, $spacing, $gaugeStripObj);
# Check for improper arguments
if (! defined $stripObj || defined $check) {
return $axmud::CLIENT->writeImproper($self->_objClass . '->replaceStripObj', @_);
}
# Check that the strip object actually exists in the window object's list of strip objects
# and is actually visible
if (! $self->ivExists('stripHash', $stripObj->number) || ! $stripObj->visibleFlag) {
return undef
}
# Find the strip object's position in the list of visible strip objects
$count = 0;
OUTER: foreach my $otherObj ($self->stripList) {
if ($otherObj eq $stripObj) {
$posn = $count;
last OUTER;
} elsif ($otherObj->visibleFlag) {
$count++;
}
}
if (! defined $posn) {
# Strip object is missing (for some unlikely reason)
return undef;
}
# Remove the old Gtk3 widget that contains the whole strip
$axmud::CLIENT->desktopObj->removeWidget($self->packingBox, $stripObj->packingBox);
# Pack the newly-visible strip, leaving a gap if it's not at the beginning or end of the
# list
if (! $count || $posn == ($count - 1)) {
$spacing = 0;
} else {
$spacing = $self->stripSpacingPixels;
}
$self->packingBox->pack_start(
$stripObj->packingBox,
$stripObj->expandFlag,
$stripObj->fillFlag,
$spacing,
);
if ($posn != 0) {
$self->packingBox->reorder_child($stripObj->packingBox, $posn);
}
# Sensitise/desensitise widgets according to current conditions
$self->restrictMenuBars();
$self->restrictToolbars();
# Make everything visible
$self->winShowAll($self->_objClass . '->replaceStripObj');
$axmud::CLIENT->desktopObj->updateWidgets($self->_objClass . '->replaceStripObj');
# Redraw any visible gauges, otherwise the gauge box will be visible, but the gauges
# themselves will have disappeared
$gaugeStripObj = $self->ivShow('firstStripHash', 'Games::Axmud::Strip::GaugeBox');
if ($gaugeStripObj && $gaugeStripObj->visibleFlag) {
$gaugeStripObj->updateGauges();
# (Need to call this a second time, or the re-draw doesn't work...)
$axmud::CLIENT->desktopObj->updateWidgets($self->_objClass . '->replaceStripObj');
}
return 1;
}
sub getStrip {
# Convenient method for getting the blessed reference of the earliest-created instance of a
# type of strip object
#
# This function accepts a string, which can be any of the following (case-insensitive):
# 'menu' / 'menubar' / 'menu_bar' - converts to GA::Strip::MenuBar
# 'tool' / 'toolbar' / 'tool_bar' - converts to GA::Strip::Toolbar
# 'table' - converts to GA::Strip::Table
# 'gauge' / 'gaugebox' / 'gauge_box' - converts to GA::Strip::GaugeBox
# 'search' / 'searchbox' / 'search_box' - converts to GA::Strip::SearchBox
# 'entry' - converts to GA::Strip::Entry
# 'connect' / 'info' / 'connectinfo' / 'connect_info'
# - converts to GA::Strip::ConnectInfo
#
# The string can also be a part of the package name itself. For example, if you create your
# own GA::Strip::MyObject (inheriting from GA::Strip::Custom), then this function expects
# the string 'MyObject' (case-sensitive)
#
# Expected arguments
# $string - The string described above
#
# Return values
# 'undef' on improper arguments or if a strip object of that type doesn't exist in the
# window
# Otherwise returns the blessed reference to the earliest-created instance of the
# specified type of strip object
my ($self, $string, $check) = @_;
# Local variables
my $packageName;
# Check for improper arguments
if (! defined $string || defined $check) {
return $axmud::CLIENT->writeImproper($self->_objClass . '->getStrip', @_);
}
# Convert $string into a package name
$packageName = $self->convertPackageName($string);
if (! $packageName || $packageName eq 'Games::Axmud::Strip::Table') {
return undef;
}
# Return the earliest-created instance of that strip object (return 'undef' if none exists)
return $self->ivShow('firstStripHash', $packageName);
}
sub convertPackageName {
# Called by $self->addStrip, ->getStrip and $self->removeStrip
# Converts a simple string (e.g. 'menu' into the package name of a strip object (e.g.
# 'Games::Axmud::Strip::MenuBar'
( run in 1.797 second using v1.01-cache-2.11-cpan-f56aa216473 )