u8 pciehp_handle_presence_change(struct slot *p_slot)
{
u32 event_type;
u8 presence_save;
struct controller *ctrl = p_slot->ctrl;
/* Presence Change */
ctrl_dbg(ctrl, "Presence/Notify input change\n");
/* Switch is open, assume a presence change
* Save the presence state
*/
pciehp_get_adapter_status(p_slot, &presence_save);
if (presence_save) {
/*
* Card Present
*/
ctrl_info(ctrl, "Card present on Slot(%s)\n", slot_name(p_slot));
event_type = INT_PRESENCE_ON;
} else {
/*
* Not Present
*/
ctrl_info(ctrl, "Card not present on Slot(%s)\n",
slot_name(p_slot));
event_type = INT_PRESENCE_OFF;
}
queue_interrupt_event(p_slot, event_type);
return 1;
}
u8 shpchp_handle_power_fault(u8 hp_slot, struct controller *ctrl)
{
struct slot *p_slot;
u32 event_type;
/* Power fault */
ctrl_dbg(ctrl, "Power fault interrupt received\n");
p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
if ( !(p_slot->hpc_ops->query_power_fault(p_slot))) {
/*
* Power fault Cleared
*/
ctrl_info(ctrl, "Power fault cleared on Slot(%s)\n",
slot_name(p_slot));
p_slot->status = 0x00;
event_type = INT_POWER_FAULT_CLEAR;
} else {
/*
* Power fault
*/
ctrl_info(ctrl, "Power fault on Slot(%s)\n", slot_name(p_slot));
event_type = INT_POWER_FAULT;
/* set power fault status for this board */
p_slot->status = 0xFF;
ctrl_info(ctrl, "Power fault bit %x set\n", hp_slot);
}
queue_interrupt_event(p_slot, event_type);
return 1;
}
u8 pciehp_handle_switch_change(struct slot *p_slot)
{
u8 getstatus;
u32 event_type;
struct controller *ctrl = p_slot->ctrl;
/* Switch Change */
ctrl_dbg(ctrl, "Switch interrupt received\n");
pciehp_get_latch_status(p_slot, &getstatus);
if (getstatus) {
/*
* Switch opened
*/
ctrl_info(ctrl, "Latch open on Slot(%s)\n", slot_name(p_slot));
event_type = INT_SWITCH_OPEN;
} else {
/*
* Switch closed
*/
ctrl_info(ctrl, "Latch close on Slot(%s)\n", slot_name(p_slot));
event_type = INT_SWITCH_CLOSE;
}
queue_interrupt_event(p_slot, event_type);
return 1;
}
u8 pciehp_handle_power_fault(struct slot *p_slot)
{
u32 event_type;
struct controller *ctrl = p_slot->ctrl;
/* power fault */
ctrl_dbg(ctrl, "Power fault interrupt received\n");
if ( !(p_slot->hpc_ops->query_power_fault(p_slot))) {
/*
* power fault Cleared
*/
ctrl_info(ctrl, "Power fault cleared on Slot(%s)\n",
slot_name(p_slot));
event_type = INT_POWER_FAULT_CLEAR;
} else {
/*
* power fault
*/
ctrl_info(ctrl, "Power fault on Slot(%s)\n", slot_name(p_slot));
event_type = INT_POWER_FAULT;
ctrl_info(ctrl, "Power fault bit %x set\n", 0);
}
queue_interrupt_event(p_slot, event_type);
return 1;
}
u8 shpchp_handle_presence_change(u8 hp_slot, struct controller *ctrl)
{
struct slot *p_slot;
u32 event_type;
/* Presence Change */
ctrl_dbg(ctrl, "Presence/Notify input change\n");
p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
/*
* Save the presence state
*/
p_slot->hpc_ops->get_adapter_status(p_slot, &(p_slot->presence_save));
if (p_slot->presence_save) {
/*
* Card Present
*/
ctrl_info(ctrl, "Card present on Slot(%s)\n",
slot_name(p_slot));
event_type = INT_PRESENCE_ON;
} else {
/*
* Not Present
*/
ctrl_info(ctrl, "Card not present on Slot(%s)\n",
slot_name(p_slot));
event_type = INT_PRESENCE_OFF;
}
queue_interrupt_event(p_slot, event_type);
return 1;
}
bool item_t::decode_reforge()
{
is_reforged = false;
if ( encoded_reforge_str == "none" ) return true;
std::vector<token_t> tokens;
int num_tokens = parse_tokens( tokens, encoded_reforge_str );
if ( num_tokens <= 0 )
return true;
if ( num_tokens != 2 )
{
sim -> errorf( "Player %s has unknown 'reforge=' '%s' at slot %s\n", player -> name(), encoded_reforge_str.c_str(), slot_name() );
return false;
}
stat_type s1 = util_t::parse_reforge_type( tokens[ 0 ].name );
stat_type s2 = util_t::parse_reforge_type( tokens[ 1 ].name );
if ( ( s1 == STAT_NONE ) || ( s2 == STAT_NONE ) )
{
sim -> errorf( "Player %s has unknown 'reforge=' '%s' at slot %s\n",
player -> name(), encoded_reforge_str.c_str(), slot_name() );
return false;
}
if ( base_stats.get_stat( s1 ) <= 0.0 )
{
sim -> errorf( "Player %s with 'reforge=' '%s' at slot %s does not have source stat on item.\n",
player -> name(), encoded_reforge_str.c_str(), slot_name() );
return false;
}
if ( base_stats.get_stat( s2 ) > 0.0 )
{
sim -> errorf( "Player %s with 'reforge=' '%s' at slot %s already has target stat on item.\n",
player -> name(), encoded_reforge_str.c_str(), slot_name() );
return false;
}
reforged_from = s1;
reforged_to = s2;
double amount = floor( base_stats.get_stat( reforged_from ) * 0.4 );
stats.add_stat( reforged_from, -amount );
stats.add_stat( reforged_to, amount );
is_reforged = true;
return true;
}
blackbox
qt_window_widget_rep::query (slot s, int type_id) {
if (DEBUG_QT_WIDGETS)
debug_widgets << "qt_window_widget_rep::query " << slot_name(s) << LF;
switch (s) {
case SLOT_IDENTIFIER:
{
check_type_id<int> (type_id, s);
return close_box<int> (win_id);
}
case SLOT_POSITION:
{
check_type_id<coord2> (type_id, s);
QRect g;
// FIXME: dock widgets are embedded into qt_window_widget_reps as a temporary hack
// because of this the underlying widget is not always a top level window
if (qwid->isWindow()) g = qwid->frameGeometry();
else g = qwid->window()->frameGeometry();
//cout << "wpos: " << pt.x() << ", " << pt.y() << LF;
return close_box<coord2> (from_qpoint (QPoint (g.x(), g.y())));
}
case SLOT_SIZE:
{
check_type_id<coord2> (type_id, s);
QSize sz = qwid->frameSize();
return close_box<coord2> (from_qsize (sz));
}
default:
return qt_widget_rep::query (s, type_id);
}
}
void
qt_tm_embedded_widget_rep::write (slot s, blackbox index, widget w) {
if (DEBUG_QT_WIDGETS)
debug_widgets << "qt_tm_embedded_widget_rep::write " << slot_name (s) << LF;
switch (s) {
// Widget w is a qt_simple_widget_rep, with a QTMWidget as underlying
// widget. We must discard the current QTMWidget and display the new.
// see qt_tm_widget_rep::write()
case SLOT_SCROLLABLE:
{
check_type_void (index, s);
main_widget = w;
}
break;
/// FIXME: decide what to do with these for embedded widgets
case SLOT_MAIN_MENU:
case SLOT_MAIN_ICONS:
case SLOT_MODE_ICONS:
case SLOT_FOCUS_ICONS:
case SLOT_USER_ICONS:
case SLOT_SIDE_TOOLS:
case SLOT_BOTTOM_TOOLS:
case SLOT_INTERACTIVE_INPUT:
case SLOT_INTERACTIVE_PROMPT:
default:
qt_widget_rep::write (s, index, w);
}
}
void pciehp_handle_linkstate_change(struct slot *p_slot)
{
u32 event_type;
struct controller *ctrl = p_slot->ctrl;
/* Link Status Change */
ctrl_dbg(ctrl, "Data Link Layer State change\n");
if (pciehp_check_link_active(ctrl)) {
ctrl_info(ctrl, "slot(%s): Link Up event\n",
slot_name(p_slot));
event_type = INT_LINK_UP;
} else {
ctrl_info(ctrl, "slot(%s): Link Down event\n",
slot_name(p_slot));
event_type = INT_LINK_DOWN;
}
queue_interrupt_event(p_slot, event_type);
}
void
server_thread_init(void)
{
kern_return_t kr;
static int first_time = 1;
policy_rr_base_data_t rr_base;
policy_rr_limit_data_t rr_limit;
struct host_basic_info hbi;
mach_msg_type_number_t count;
if (first_time)
first_time = 0;
else
panic("server_thread_init called again");
/*
* Set the server's task scheduling to be POLICY_RR.
*/
rr_base.quantum = 10; /* XXX should be larger ? */
rr_base.base_priority = BASEPRI_SERVER;
rr_limit.max_priority = BASEPRI_SERVER;
kr = task_set_policy(mach_task_self(), default_processor_set,
POLICY_RR,
(policy_base_t) &rr_base, POLICY_RR_BASE_COUNT,
(policy_limit_t) &rr_limit, POLICY_RR_LIMIT_COUNT,
TRUE);
if (kr != KERN_SUCCESS) {
MACH3_DEBUG(3, kr, ("server_thread_init: task_set_policy"));
}
count = HOST_BASIC_INFO_COUNT;
kr = host_info(mach_host_self(), HOST_BASIC_INFO,
(host_info_t) &hbi, &count);
if (kr != KERN_SUCCESS) {
MACH3_DEBUG(1, kr, ("server_thread_init: host_info"));
host_cpus = 1;
} else {
host_cpus = hbi.avail_cpus;
}
cpu_type = hbi.cpu_type;
cpu_subtype = hbi.cpu_subtype;
slot_name(hbi.cpu_type, hbi.cpu_subtype, &cpu_name, &cpu_subname);
#if CONFIG_OSFMACH3_DEBUG
printk("Using %d processor%s (type \"%s\" subtype \"%s\").\n",
host_cpus, host_cpus > 1 ? "s" : "",
cpu_name, cpu_subname);
#endif /* CONFIG_OSFMACH3_DEBUG */
server_thread_set_kernel_limit();
}
u8 pciehp_handle_power_fault(struct slot *p_slot)
{
u32 event_type;
struct controller *ctrl = p_slot->ctrl;
/* power fault */
ctrl_dbg(ctrl, "Power fault interrupt received\n");
ctrl_err(ctrl, "Power fault on slot %s\n", slot_name(p_slot));
event_type = INT_POWER_FAULT;
ctrl_info(ctrl, "Power fault bit %x set\n", 0);
queue_interrupt_event(p_slot, event_type);
return 1;
}
u8 shpchp_handle_switch_change(u8 hp_slot, struct controller *ctrl)
{
struct slot *p_slot;
u8 getstatus;
u32 event_type;
/* Switch Change */
ctrl_dbg(ctrl, "Switch interrupt received\n");
p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
p_slot->hpc_ops->get_adapter_status(p_slot, &(p_slot->presence_save));
p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
ctrl_dbg(ctrl, "Card present %x Power status %x\n",
p_slot->presence_save, p_slot->pwr_save);
if (getstatus) {
/*
* Switch opened
*/
ctrl_info(ctrl, "Latch open on Slot(%s)\n", slot_name(p_slot));
event_type = INT_SWITCH_OPEN;
if (p_slot->pwr_save && p_slot->presence_save) {
event_type = INT_POWER_FAULT;
ctrl_err(ctrl, "Surprise Removal of card\n");
}
} else {
/*
* Switch closed
*/
ctrl_info(ctrl, "Latch close on Slot(%s)\n", slot_name(p_slot));
event_type = INT_SWITCH_CLOSE;
}
queue_interrupt_event(p_slot, event_type);
return 1;
}
widget
qt_window_widget_rep::read (slot s, blackbox index) {
if (DEBUG_QT_WIDGETS)
debug_widgets << "qt_window_widget_rep::read " << slot_name(s)
<< "\tWidget id: " << id << LF;
switch (s) {
case SLOT_WINDOW: // We use this in qt_gui_rep::show_help_balloon()
check_type_void (index, s);
return this;
default:
return qt_widget_rep::read (s, index);
}
}
/**
* board_added - Called after a board has been added to the system.
* @p_slot: &slot where board is added
*
* Turns power on for the board.
* Configures board.
*/
static int board_added(struct slot *p_slot)
{
int retval = 0;
struct controller *ctrl = p_slot->ctrl;
struct pci_bus *parent = ctrl->pcie->port->subordinate;
if (POWER_CTRL(ctrl)) {
/* Power on slot */
retval = pciehp_power_on_slot(p_slot);
if (retval)
return retval;
}
pciehp_green_led_blink(p_slot);
/* Check link training status */
pm_runtime_get_sync(&ctrl->pcie->port->dev);
retval = pciehp_check_link_status(ctrl);
if (retval) {
ctrl_err(ctrl, "Failed to check link status\n");
goto err_exit;
}
/* Check for a power fault */
if (ctrl->power_fault_detected || pciehp_query_power_fault(p_slot)) {
ctrl_err(ctrl, "Slot(%s): Power fault\n", slot_name(p_slot));
retval = -EIO;
goto err_exit;
}
retval = pciehp_configure_device(p_slot);
if (retval) {
ctrl_err(ctrl, "Cannot add device at %04x:%02x:00\n",
pci_domain_nr(parent), parent->number);
if (retval != -EEXIST)
goto err_exit;
}
pm_runtime_put(&ctrl->pcie->port->dev);
pciehp_green_led_on(p_slot);
pciehp_set_attention_status(p_slot, 0);
return 0;
err_exit:
pm_runtime_put(&ctrl->pcie->port->dev);
set_slot_off(ctrl, p_slot);
return retval;
}
void
qt_popup_widget_rep::send (slot s, blackbox val) {
switch (s) {
case SLOT_SIZE:
{
check_type<coord2>(val, s);
qwid->resize (to_qsize (open_box<coord2> (val)));
}
break;
case SLOT_POSITION:
{
check_type<coord2>(val, s);
qwid->move (to_qpoint (open_box<coord2> (val)));
}
break;
case SLOT_VISIBILITY:
{
check_type<bool> (val, s);
qwid->setVisible(open_box<bool> (val));
}
break;
//FIXME: what's this?
case SLOT_MOUSE_GRAB:
{
check_type<bool> (val, s);
bool flag = open_box<bool> (val); // true= get grab, false= release grab
qwid->hide();
if (flag) qwid->setWindowModality(Qt::WindowModal); //ok?
else qwid->setWindowModality(Qt::NonModal); //ok?
qwid->show();
}
break;
default:
qt_widget_rep::send(s, val);
}
if (DEBUG_QT_WIDGETS)
debug_widgets << "qt_popup_widget_rep: sent " << slot_name (s)
<< "\t\tto widget\t" << type_as_string() << LF;
}
void
qt_tm_embedded_widget_rep::send (slot s, blackbox val) {
switch (s) {
case SLOT_INVALIDATE:
case SLOT_INVALIDATE_ALL:
case SLOT_EXTENTS:
case SLOT_SCROLL_POSITION:
case SLOT_ZOOM_FACTOR:
case SLOT_MOUSE_GRAB:
main_widget->send(s, val);
return;
/// FIXME: decide what to do with these for embedded widgets
case SLOT_HEADER_VISIBILITY:
case SLOT_MAIN_ICONS_VISIBILITY:
case SLOT_MODE_ICONS_VISIBILITY:
case SLOT_FOCUS_ICONS_VISIBILITY:
case SLOT_USER_ICONS_VISIBILITY:
case SLOT_FOOTER_VISIBILITY:
case SLOT_SIDE_TOOLS_VISIBILITY:
case SLOT_BOTTOM_TOOLS_VISIBILITY:
case SLOT_LEFT_FOOTER:
case SLOT_RIGHT_FOOTER:
case SLOT_SCROLLBARS_VISIBILITY:
case SLOT_INTERACTIVE_MODE:
case SLOT_FILE:
break;
case SLOT_DESTROY:
{
ASSERT (is_nil (val), "type mismatch");
if (!is_nil (quit))
quit ();
the_gui->need_update ();
}
break;
default:
qt_widget_rep::send (s, val);
return;
}
if (DEBUG_QT_WIDGETS)
debug_widgets << "qt_tm_embedded_widget_rep: sent " << slot_name (s)
<< "\t\tto widget\t" << type_as_string() << LF;
}
u8 pciehp_handle_attention_button(struct slot *p_slot)
{
u32 event_type;
struct controller *ctrl = p_slot->ctrl;
/* Attention Button Change */
ctrl_dbg(ctrl, "Attention button interrupt received\n");
/*
* Button pressed - See if need to TAKE ACTION!!!
*/
ctrl_info(ctrl, "Button pressed on Slot(%s)\n", slot_name(p_slot));
event_type = INT_BUTTON_PRESS;
queue_interrupt_event(p_slot, event_type);
return 0;
}
widget
qt_tm_embedded_widget_rep::read (slot s, blackbox index) {
widget ret;
switch (s) {
case SLOT_CANVAS:
check_type_void (index, s);
ret = main_widget;
break;
default:
return qt_widget_rep::read(s, index);
}
if (DEBUG_QT_WIDGETS)
debug_widgets << "qt_tm_widget_rep::read " << slot_name (s)
<< "\t\tfor widget\t" << type_as_string() << LF;
return ret;
}
blackbox
qt_popup_widget_rep::query (slot s, int type_id) {
if (DEBUG_QT_WIDGETS)
debug_widgets << "qt_popup_widget_rep::query " << slot_name(s) << LF;
switch (s) {
case SLOT_POSITION:
{
check_type_id<coord2> (type_id, s);
return close_box<coord2> (from_qpoint (qwid->pos()));
}
case SLOT_SIZE:
{
check_type_id<coord2> (type_id, s);
return close_box<coord2> (from_qsize (qwid->size()));
}
default:
return qt_widget_rep::query (s, type_id);
}
}
char *platform_get_nextopenstep_runtime_cpu(void)
{
kern_return_t ret;
struct host_basic_info hi;
unsigned int count = HOST_BASIC_INFO_COUNT;
char *cpu_name = NULL;
char *cpu_subname = NULL;
if (!got_cpu) {
ret = host_info(host_self(), HOST_BASIC_INFO, (host_info_t)&hi, &count);
if (ret != KERN_SUCCESS) {
sprintf(cpu, "Unknown CPU");
} else {
slot_name(hi.cpu_type, hi.cpu_subtype, &cpu_name, &cpu_subname);
sprintf(cpu, "%s (%s)", cpu_name, cpu_subname);
}
got_cpu = 1;
}
return cpu;
}
blackbox
qt_tm_embedded_widget_rep::query (slot s, int type_id) {
if (DEBUG_QT_WIDGETS)
debug_widgets << "qt_tm_embedded_widget_rep::query " << slot_name (s) << LF;
switch (s) {
case SLOT_IDENTIFIER:
{
if (qwid) {
widget_rep* wid = qt_window_widget_rep::widget_from_qwidget(qwid);
if (wid) return wid->query (s, type_id);
}
return close_box<int>(0);
}
case SLOT_SCROLL_POSITION:
case SLOT_EXTENTS:
case SLOT_VISIBLE_PART:
case SLOT_ZOOM_FACTOR:
case SLOT_POSITION:
case SLOT_SIZE:
if (!is_nil (main_widget))
return main_widget->query (s, type_id);
else
return qt_widget_rep::query (s, type_id);
/// FIXME: decide what to do with these for embedded widgets
case SLOT_HEADER_VISIBILITY:
case SLOT_MAIN_ICONS_VISIBILITY:
case SLOT_MODE_ICONS_VISIBILITY:
case SLOT_FOCUS_ICONS_VISIBILITY:
case SLOT_USER_ICONS_VISIBILITY:
case SLOT_FOOTER_VISIBILITY:
case SLOT_SIDE_TOOLS_VISIBILITY:
case SLOT_BOTTOM_TOOLS_VISIBILITY:
check_type_id<bool> (type_id, s);
return close_box<bool> (false);
default:
return qt_widget_rep::query (s, type_id);
}
}
u8 shpchp_handle_attention_button(u8 hp_slot, struct controller *ctrl)
{
struct slot *p_slot;
u32 event_type;
/* Attention Button Change */
ctrl_dbg(ctrl, "Attention button interrupt received\n");
p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
p_slot->hpc_ops->get_adapter_status(p_slot, &(p_slot->presence_save));
/*
* Button pressed - See if need to TAKE ACTION!!!
*/
ctrl_info(ctrl, "Button pressed on Slot(%s)\n", slot_name(p_slot));
event_type = INT_BUTTON_PRESS;
queue_interrupt_event(p_slot, event_type);
return 0;
}
/*
* Make another Mach call and get the hardware information.
*/
void detectHardware(void)
{
kern_return_t kret;
struct host_basic_info kbi;
unsigned int count = HOST_BASIC_INFO_COUNT;
char *pCpuType, *pCpuSubtype;
kret = host_info(host_self(),
HOST_BASIC_INFO,
(host_info_t)&kbi,
&count);
if (kret != KERN_SUCCESS) {
mach_error("host_info() failed.", kret);
} else {
slot_name(kbi.cpu_type, /* Architecture */
kbi.cpu_subtype, /* Processor */
&pCpuType,
&pCpuSubtype);
bcopy(pCpuType, machine, 32);
bcopy(pCpuSubtype, processor, 32);
}
}
bool item_t::decode_gems()
{
if ( encoded_gems_str == "none" ) return true;
std::vector<token_t> tokens;
int num_tokens = parse_tokens( tokens, encoded_gems_str );
std::string meta_prefix, meta_suffix;
for ( int i=0; i < num_tokens; i++ )
{
token_t& t = tokens[ i ];
int s;
if ( ( s = util_t::parse_stat_type( t.name ) ) != STAT_NONE )
{
stats.add_stat( s, t.value );
}
else if ( is_meta_prefix( t.name ) )
{
meta_prefix = t.name;
}
else if ( is_meta_suffix( t.name ) )
{
meta_suffix = t.name;
}
else
{
sim -> errorf( "Player %s has unknown 'gems=' token '%s' at slot %s\n", player -> name(), t.full.c_str(), slot_name() );
//return false;
}
}
int meta_gem = parse_meta_gem( meta_prefix, meta_suffix );
if ( meta_gem != META_GEM_NONE )
{
player -> meta_gem = meta_gem;
}
return true;
}
void
qt_tm_widget_rep::write (slot s, blackbox index, widget w) {
if (DEBUG_QT_WIDGETS)
debug_widgets << "qt_tm_widget_rep::write " << slot_name (s) << LF;
switch (s) {
// Widget w is usually a qt_simple_widget_rep, with a QTMWidget as
// underlying widget. We must discard the current main_widget and
// display the new. But while switching buffers the widget w is a
// glue_widget, so we may not just use canvas() everywhere.
case SLOT_SCROLLABLE:
{
check_type_void (index, s);
QWidget* q = main_widget->qwid;
q->hide();
QLayout* l = centralwidget()->layout();
l->removeWidget(q);
q = concrete(w)->as_qwidget(); // force creation of the new QWidget
l->addWidget(q);
/* " When you use a layout, you do not need to pass a parent when
constructing the child widgets. The layout will automatically reparent
the widgets (using QWidget::setParent()) so that they are children of
the widget on which the layout is installed " */
main_widget = concrete (w);
// canvas() now returns the new QTMWidget (or 0)
if (scrollarea()) // Fix size to draw margins around.
scrollarea()->surface()->setSizePolicy (QSizePolicy::Fixed,
QSizePolicy::Fixed);
send_keyboard_focus (abstract (main_widget));
}
break;
case SLOT_MAIN_MENU:
check_type_void (index, s);
{
waiting_main_menu_widget = concrete (w);
if (menu_count <= 0)
install_main_menu();
else if (!contains (waiting_widgets, this))
// menu interaction ongoing, postpone new menu installation until done
waiting_widgets << this;
}
break;
case SLOT_MAIN_ICONS:
check_type_void (index, s);
{
main_icons_widget = concrete (w);
QMenu* m = main_icons_widget->get_qmenu();
if (m) {
replaceButtons (mainToolBar, m);
update_visibility();
}
}
break;
case SLOT_MODE_ICONS:
check_type_void (index, s);
{
mode_icons_widget = concrete (w);
QMenu* m = mode_icons_widget->get_qmenu();
if (m) {
replaceButtons (modeToolBar, m);
update_visibility();
}
}
break;
case SLOT_FOCUS_ICONS:
check_type_void (index, s);
{
focus_icons_widget = concrete (w);
QMenu* m = focus_icons_widget->get_qmenu();
if (m) {
replaceButtons (focusToolBar, m);
update_visibility();
}
}
break;
case SLOT_USER_ICONS:
check_type_void (index, s);
{
user_icons_widget = concrete (w);
QMenu* m = user_icons_widget->get_qmenu();
if (m) {
replaceButtons (userToolBar, m);
update_visibility();
}
}
break;
case SLOT_SIDE_TOOLS:
check_type_void (index, s);
{
side_tools_widget = concrete (w);
QWidget* new_qwidget = side_tools_widget->as_qwidget();
QWidget* old_qwidget = sideTools->widget();
if (old_qwidget) old_qwidget->deleteLater();
sideTools->setWidget (new_qwidget);
update_visibility();
new_qwidget->show();
}
break;
case SLOT_BOTTOM_TOOLS:
check_type_void (index, s);
{
bottom_tools_widget = concrete (w);
QWidget* new_qwidget = bottom_tools_widget->as_qwidget();
QWidget* old_qwidget = bottomTools->widget();
if (old_qwidget) old_qwidget->deleteLater();
bottomTools->setWidget (new_qwidget);
update_visibility();
new_qwidget->show();
}
break;
case SLOT_INTERACTIVE_PROMPT:
check_type_void (index, s);
int_prompt= concrete (w);
break;
case SLOT_INTERACTIVE_INPUT:
check_type_void (index, s);
int_input= concrete (w);
break;
default:
qt_window_widget_rep::write (s, index, w);
}
}
blackbox
qt_tm_widget_rep::query (slot s, int type_id) {
if (DEBUG_QT_WIDGETS)
debug_widgets << "qt_tm_widget_rep: queried " << slot_name(s)
<< "\t\tto widget\t" << type_as_string() << LF;
switch (s) {
case SLOT_SCROLL_POSITION:
case SLOT_EXTENTS:
case SLOT_VISIBLE_PART:
case SLOT_ZOOM_FACTOR:
return main_widget->query(s, type_id);
case SLOT_HEADER_VISIBILITY:
check_type_id<bool> (type_id, s);
return close_box<bool> (visibility[0]);
case SLOT_MAIN_ICONS_VISIBILITY:
check_type_id<bool> (type_id, s);
return close_box<bool> (visibility[1]);
case SLOT_MODE_ICONS_VISIBILITY:
check_type_id<bool> (type_id, s);
return close_box<bool> (visibility[2]);
case SLOT_FOCUS_ICONS_VISIBILITY:
check_type_id<bool> (type_id, s);
return close_box<bool> (visibility[3]);
case SLOT_USER_ICONS_VISIBILITY:
check_type_id<bool> (type_id, s);
return close_box<bool> (visibility[4]);
case SLOT_FOOTER_VISIBILITY:
check_type_id<bool> (type_id, s);
return close_box<bool> (visibility[5]);
case SLOT_SIDE_TOOLS_VISIBILITY:
check_type_id<bool> (type_id, s);
return close_box<bool> (visibility[6]);
case SLOT_BOTTOM_TOOLS_VISIBILITY:
check_type_id<bool> (type_id, s);
return close_box<bool> (visibility[7]);
case SLOT_INTERACTIVE_INPUT:
{
check_type_id<string> (type_id, s);
qt_input_text_widget_rep* w =
static_cast<qt_input_text_widget_rep*> (int_input.rep);
if (w->ok)
return close_box<string> (scm_quote (w->input));
else
return close_box<string> ("#f");
}
case SLOT_POSITION:
{
check_type_id<coord2> (type_id, s);
return close_box<coord2> (from_qpoint (mainwindow()->pos()));
}
case SLOT_SIZE:
{
check_type_id<coord2> (type_id, s);
return close_box<coord2> (from_qsize (mainwindow()->size()));
}
case SLOT_INTERACTIVE_MODE:
check_type_id<bool> (type_id, s);
return close_box<bool> (prompt && prompt->isActive());
default:
return qt_window_widget_rep::query (s, type_id);
}
}
void
qt_tm_widget_rep::send (slot s, blackbox val) {
switch (s) {
case SLOT_INVALIDATE:
case SLOT_INVALIDATE_ALL:
case SLOT_EXTENTS:
case SLOT_SCROLL_POSITION:
case SLOT_ZOOM_FACTOR:
case SLOT_MOUSE_GRAB:
main_widget->send(s, val);
return;
case SLOT_KEYBOARD_FOCUS:
{
check_type<bool> (val, s);
bool focus = open_box<bool> (val);
if (focus && canvas() && !canvas()->hasFocus())
canvas()->setFocus (Qt::OtherFocusReason);
}
break;
case SLOT_HEADER_VISIBILITY:
{
check_type<bool>(val, s);
visibility[0] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_MAIN_ICONS_VISIBILITY:
{
check_type<bool>(val, s);
visibility[1] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_MODE_ICONS_VISIBILITY:
{
check_type<bool>(val, s);
visibility[2] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_FOCUS_ICONS_VISIBILITY:
{
check_type<bool>(val, s);
visibility[3] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_USER_ICONS_VISIBILITY:
{
check_type<bool>(val, s);
visibility[4] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_FOOTER_VISIBILITY:
{
check_type<bool>(val, s);
visibility[5] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_SIDE_TOOLS_VISIBILITY:
{
check_type<bool>(val, s);
visibility[6] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_BOTTOM_TOOLS_VISIBILITY:
{
check_type<bool>(val, s);
visibility[7] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_LEFT_FOOTER:
{
check_type<string>(val, s);
string msg = open_box<string> (val);
leftLabel->setText (to_qstring (msg));
leftLabel->update ();
}
break;
case SLOT_RIGHT_FOOTER:
{
check_type<string>(val, s);
string msg= open_box<string> (val);
rightLabel->setText (to_qstring (msg));
rightLabel->update ();
}
break;
case SLOT_SCROLLBARS_VISIBILITY:
// ignore this: qt handles scrollbars independently
// send_int (THIS, "scrollbars", val);
break;
case SLOT_INTERACTIVE_MODE:
{
check_type<bool>(val, s);
if (open_box<bool> (val) == true) {
prompt = new QTMInteractivePrompt (int_prompt, int_input);
mainwindow()->statusBar()->removeWidget (leftLabel);
mainwindow()->statusBar()->removeWidget (rightLabel);
mainwindow()->statusBar()->addWidget (prompt, 1);
prompt->start();
} else {
if (prompt) prompt->end();
mainwindow()->statusBar()->removeWidget (prompt);
mainwindow()->statusBar()->addWidget (leftLabel);
mainwindow()->statusBar()->addPermanentWidget (rightLabel);
leftLabel->show();
rightLabel->show();
prompt->deleteLater();
prompt = NULL;
}
}
break;
case SLOT_FILE:
{
check_type<string>(val, s);
string file = open_box<string> (val);
if (DEBUG_QT_WIDGETS) debug_widgets << "\tFile: " << file << LF;
#if (QT_VERSION >= 0x040400)
mainwindow()->setWindowFilePath (utf8_to_qstring (file));
#endif
}
break;
case SLOT_POSITION:
{
check_type<coord2>(val, s);
coord2 p= open_box<coord2> (val);
mainwindow()->move (to_qpoint (p));
}
break;
case SLOT_SIZE:
{
check_type<coord2>(val, s);
coord2 p= open_box<coord2> (val);
mainwindow()->resize (to_qsize (p));
}
break;
case SLOT_DESTROY:
{
ASSERT (is_nil (val), "type mismatch");
if (!is_nil (quit))
quit ();
the_gui->need_update ();
}
break;
case SLOT_FULL_SCREEN:
{
check_type<bool> (val, s);
set_full_screen(open_box<bool> (val));
}
break;
default:
qt_window_widget_rep::send (s, val);
return;
}
if (DEBUG_QT_WIDGETS)
debug_widgets << "qt_tm_widget_rep: sent " << slot_name (s)
<< "\t\tto widget\t" << type_as_string() << LF;
}
bool item_t::decode_enchant()
{
if ( encoded_enchant_str == "none" ) return true;
if ( encoded_enchant_str == "berserking" ||
encoded_enchant_str == "executioner" ||
encoded_enchant_str == "mongoose" ||
encoded_enchant_str == "avalanche" ||
encoded_enchant_str == "elemental_slayer" ||
encoded_enchant_str == "hurricane" ||
encoded_enchant_str == "landslide" ||
encoded_enchant_str == "power_torrent" ||
encoded_enchant_str == "windwalk" ||
encoded_enchant_str == "spellsurge" ||
encoded_enchant_str == "synapse_springs" ||
encoded_enchant_str == "gnomish_xray" )
{
unique_enchant = true;
return true;
}
if ( encoded_enchant_str == "lightweave_embroidery" ||
encoded_enchant_str == "lightweave_embroidery_old" ||
encoded_enchant_str == "lightweave" ||
encoded_enchant_str == "lightweave_old" ||
encoded_enchant_str == "swordguard_embroidery" ||
encoded_enchant_str == "swordguard_embroidery_old" ||
encoded_enchant_str == "darkglow_embroidery" ||
encoded_enchant_str == "darkglow_embroidery_old" )
{
stats.add_stat( STAT_SPIRIT, 1 );
}
std::string use_str;
if ( unique_gear_t::get_use_encoding( use_str, encoded_enchant_str, heroic(), lfr(), player -> dbc.ptr ) )
{
unique_enchant = true;
use.name_str = encoded_enchant_str;
return decode_special( use, use_str );
}
std::string equip_str;
if ( unique_gear_t::get_equip_encoding( equip_str, encoded_enchant_str, heroic(), lfr(), player -> dbc.ptr ) )
{
unique_enchant = true;
enchant.name_str = encoded_enchant_str;
return decode_special( enchant, equip_str );
}
std::vector<token_t> tokens;
int num_tokens = parse_tokens( tokens, encoded_enchant_str );
for ( int i=0; i < num_tokens; i++ )
{
token_t& t = tokens[ i ];
int s;
if ( ( s = util_t::parse_stat_type( t.name ) ) != STAT_NONE )
{
stats.add_stat( s, t.value );
}
else
{
sim -> errorf( "Player %s has unknown 'enchant=' token '%s' at slot %s\n", player -> name(), t.full.c_str(), slot_name() );
continue;
}
}
return true;
}
bool item_t::decode_addon()
{
if ( encoded_addon_str == "none" ) return true;
if ( encoded_addon_str == "synapse_springs" )
{
unique_addon = true;
return true;
}
std::string use_str;
if ( unique_gear_t::get_use_encoding( use_str, encoded_addon_str, heroic(), lfr(), player -> dbc.ptr ) )
{
unique_addon = true;
use.name_str = encoded_addon_str;
return decode_special( use, use_str );
}
std::string equip_str;
if ( unique_gear_t::get_equip_encoding( equip_str, encoded_addon_str, heroic(), lfr(), player -> dbc.ptr ) )
{
unique_addon = true;
addon.name_str = encoded_addon_str;
return decode_special( addon, equip_str );
}
std::vector<token_t> tokens;
int num_tokens = parse_tokens( tokens, encoded_addon_str );
for ( int i=0; i < num_tokens; i++ )
{
token_t& t = tokens[ i ];
int s;
if ( ( s = util_t::parse_stat_type( t.name ) ) != STAT_NONE )
{
stats.add_stat( s, t.value );
}
else
{
sim -> errorf( "Player %s has unknown 'addon=' token '%s' at slot %s\n", player -> name(), t.full.c_str(), slot_name() );
return false;
}
}
return true;
}
bool item_t::decode_special( special_effect_t& effect,
const std::string& encoding )
{
if ( encoding == "custom" || encoding == "none" ) return true;
std::vector<token_t> tokens;
int num_tokens = parse_tokens( tokens, encoding );
for ( int i=0; i < num_tokens; i++ )
{
token_t& t = tokens[ i ];
int s;
school_type sc;
if ( ( s = util_t::parse_stat_type( t.name ) ) != STAT_NONE )
{
effect.stat = s;
effect.stat_amount = t.value;
}
else if ( ( sc = util_t::parse_school_type( t.name ) ) != SCHOOL_NONE )
{
effect.school = sc;
effect.discharge_amount = t.value;
std::vector<std::string> splits;
if ( 2 == util_t::string_split( splits, t.value_str, "+" ) )
{
effect.discharge_amount = atof( splits[ 0 ].c_str() );
effect.discharge_scaling = atof( splits[ 1 ].c_str() ) / 100.0;
}
}
else if ( t.name == "stacks" || t.name == "stack" )
{
effect.max_stacks = ( int ) t.value;
}
else if ( t.name == "%" )
{
effect.proc_chance = t.value / 100.0;
}
else if ( t.name == "ppm" )
{
effect.proc_chance = -( t.value );
}
else if ( t.name == "duration" || t.name == "dur" )
{
effect.duration = t.value;
}
else if ( t.name == "cooldown" || t.name == "cd" )
{
effect.cooldown = t.value;
}
else if ( t.name == "tick" )
{
effect.tick = t.value;
}
else if ( t.full == "reverse" )
{
effect.reverse = true;
}
else if ( t.full == "chance" )
{
effect.chance_to_discharge = true;
}
else if ( t.name == "costrd" )
{
effect.cost_reduction = true;
effect.no_refresh = true;
}
else if ( t.name == "nocrit" )
{
effect.no_crit = true;
}
else if ( t.name == "nobuffs" )
{
effect.no_player_benefits = true;
}
else if ( t.name == "nodebuffs" )
{
effect.no_player_benefits = true;
}
else if ( t.name == "norefresh" )
{
effect.no_refresh = true;
}
else if ( t.full == "ondamage" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_DAMAGE;
effect.trigger_mask = SCHOOL_ALL_MASK;
}
else if ( t.full == "onheal" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_HEAL;
effect.trigger_mask = SCHOOL_ALL_MASK;
}
else if ( t.full == "ontickdamage" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_TICK_DAMAGE;
effect.trigger_mask = SCHOOL_ALL_MASK;
}
else if ( t.full == "ondirectdamage" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_DIRECT_DAMAGE;
effect.trigger_mask = SCHOOL_ALL_MASK;
}
else if ( t.full == "onspelldamage" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_DAMAGE;
effect.trigger_mask = SCHOOL_SPELL_MASK;
}
else if ( t.full == "onspelltickdamage" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_TICK_DAMAGE;
effect.trigger_mask = SCHOOL_SPELL_MASK;
}
else if ( t.full == "onspelldirectdamage" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_DIRECT_DAMAGE;
effect.trigger_mask = SCHOOL_SPELL_MASK;
}
else if ( t.full == "onattackdamage" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_DAMAGE;
effect.trigger_mask = SCHOOL_ATTACK_MASK;
}
else if ( t.full == "onattacktickdamage" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_TICK_DAMAGE;
effect.trigger_mask = SCHOOL_ATTACK_MASK;
}
else if ( t.full == "onattackdirectdamage" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_DIRECT_DAMAGE;
effect.trigger_mask = SCHOOL_ATTACK_MASK;
}
else if ( t.full == "onarcanedamage" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_DAMAGE;
effect.trigger_mask = ( int64_t( 1 ) << SCHOOL_ARCANE );
}
else if ( t.full == "onbleeddamage" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_DAMAGE;
effect.trigger_mask = ( int64_t( 1 ) << SCHOOL_BLEED );
}
else if ( t.full == "onchaosdamage" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_DAMAGE;
effect.trigger_mask = ( int64_t( 1 ) << SCHOOL_CHAOS );
}
else if ( t.full == "onfiredamage" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_DAMAGE;
effect.trigger_mask = ( int64_t( 1 ) << SCHOOL_FIRE );
}
else if ( t.full == "onfrostdamage" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_DAMAGE;
effect.trigger_mask = ( int64_t( 1 ) << SCHOOL_FROST );
}
else if ( t.full == "onfrostfiredamage" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_DAMAGE;
effect.trigger_mask = ( int64_t( 1 ) << SCHOOL_FROSTFIRE );
}
else if ( t.full == "onholydamage" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_DAMAGE;
effect.trigger_mask = ( int64_t( 1 ) << SCHOOL_HOLY );
}
else if ( t.full == "onnaturedamage" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_DAMAGE;
effect.trigger_mask = ( int64_t( 1 ) << SCHOOL_NATURE );
}
else if ( t.full == "onphysicaldamage" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_DAMAGE;
effect.trigger_mask = ( int64_t( 1 ) << SCHOOL_PHYSICAL );
}
else if ( t.full == "onshadowdamage" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_DAMAGE;
effect.trigger_mask = ( int64_t( 1 ) << SCHOOL_SHADOW );
}
else if ( t.full == "ondraindamage" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_DAMAGE;
effect.trigger_mask = ( int64_t( 1 ) << SCHOOL_DRAIN );
}
else if ( t.full == "ontick" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_TICK;
effect.trigger_mask = RESULT_ALL_MASK;
}
else if ( t.full == "ontickhit" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_TICK;
effect.trigger_mask = RESULT_HIT_MASK;
}
else if ( t.full == "ontickcrit" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_TICK;
effect.trigger_mask = RESULT_CRIT_MASK;
}
else if ( t.full == "onspellcast" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_SPELL;
effect.trigger_mask = RESULT_NONE_MASK;
}
else if ( t.full == "onspellhit" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_SPELL;
effect.trigger_mask = RESULT_HIT_MASK;
}
else if ( t.full == "onspellcrit" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_SPELL_AND_TICK;
effect.trigger_mask = RESULT_CRIT_MASK;
}
else if ( t.full == "onspelltickcrit" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_TICK;
effect.trigger_mask = RESULT_CRIT_MASK;
}
else if ( t.full == "onspelldirectcrit" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_SPELL;
effect.trigger_mask = RESULT_CRIT_MASK;
}
else if ( t.full == "onspellmiss" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_SPELL;
effect.trigger_mask = RESULT_MISS_MASK;
}
else if ( t.full == "onharmfulspellcast" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_HARMFUL_SPELL;
effect.trigger_mask = RESULT_NONE_MASK;
}
else if ( t.full == "onharmfulspellhit" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_HARMFUL_SPELL;
effect.trigger_mask = RESULT_HIT_MASK;
}
else if ( t.full == "onharmfulspellcrit" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_HARMFUL_SPELL;
effect.trigger_mask = RESULT_CRIT_MASK;
}
else if ( t.full == "onharmfulspellmiss" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_HARMFUL_SPELL;
effect.trigger_mask = RESULT_MISS_MASK;
}
else if ( t.full == "onhealcast" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_HEAL_SPELL;
effect.trigger_mask = RESULT_NONE_MASK;
}
else if ( t.full == "onhealhit" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_HEAL_SPELL;
effect.trigger_mask = RESULT_HIT_MASK;
}
else if ( t.full == "onhealdirectcrit" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_HEAL_SPELL;
effect.trigger_mask = RESULT_CRIT_MASK;
}
else if ( t.full == "onhealmiss" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_HEAL_SPELL;
effect.trigger_mask = RESULT_MISS_MASK;
}
else if ( t.full == "onattack" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_ATTACK;
effect.trigger_mask = RESULT_ALL_MASK;
}
else if ( t.full == "onattackhit" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_ATTACK;
effect.trigger_mask = RESULT_HIT_MASK;
}
else if ( t.full == "onattackcrit" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_ATTACK;
effect.trigger_mask = RESULT_CRIT_MASK;
}
else if ( t.full == "onattackmiss" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_ATTACK;
effect.trigger_mask = RESULT_MISS_MASK;
}
else if ( t.full == "onspelldamageheal" )
{
effect.trigger_str = t.full;
effect.trigger_type = PROC_DAMAGE_HEAL;
effect.trigger_mask = SCHOOL_SPELL_MASK;
}
else
{
sim -> errorf( "Player %s has unknown 'use/equip=' token '%s' at slot %s\n", player -> name(), t.full.c_str(), slot_name() );
return false;
}
}
return true;
}
