// Starts the Attach Listener thread
void AttachListener::init() {
EXCEPTION_MARK;
Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK);
instanceKlassHandle klass (THREAD, k);
instanceHandle thread_oop = klass->allocate_instance_handle(CHECK);
const char thread_name[] = "Attach Listener";
Handle string = java_lang_String::create_from_str(thread_name, CHECK);
// Initialize thread_oop to put it into the system threadGroup
Handle thread_group (THREAD, Universe::system_thread_group());
JavaValue result(T_VOID);
JavaCalls::call_special(&result, thread_oop,
klass,
vmSymbols::object_initializer_name(),
vmSymbols::threadgroup_string_void_signature(),
thread_group,
string,
THREAD);
if (HAS_PENDING_EXCEPTION) {
tty->print_cr("Exception in VM (AttachListener::init) : ");
java_lang_Throwable::print(PENDING_EXCEPTION, tty);
tty->cr();
CLEAR_PENDING_EXCEPTION;
return;
}
KlassHandle group(THREAD, SystemDictionary::ThreadGroup_klass());
JavaCalls::call_special(&result,
thread_group,
group,
vmSymbols::add_method_name(),
vmSymbols::thread_void_signature(),
thread_oop, // ARG 1
THREAD);
if (HAS_PENDING_EXCEPTION) {
tty->print_cr("Exception in VM (AttachListener::init) : ");
java_lang_Throwable::print(PENDING_EXCEPTION, tty);
tty->cr();
CLEAR_PENDING_EXCEPTION;
return;
}
{ MutexLocker mu(Threads_lock);
JavaThread* listener_thread = new JavaThread(&attach_listener_thread_entry);
// Check that thread and osthread were created
if (listener_thread == NULL || listener_thread->osthread() == NULL) {
vm_exit_during_initialization("java.lang.OutOfMemoryError",
"unable to create new native thread");
}
java_lang_Thread::set_thread(thread_oop(), listener_thread);
java_lang_Thread::set_daemon(thread_oop());
listener_thread->set_threadObj(thread_oop());
Threads::add(listener_thread);
Thread::start(listener_thread);
}
}
QString KFileItem::getToolTipText(int maxcount)
{
// we can return QString::null if no tool tip should be shown
QString tip;
KFileMetaInfo info = metaInfo();
// the font tags are a workaround for the fact that the tool tip gets
// screwed if the color scheme uses white as default text color
const char* start = "<tr><td><nobr><font color=\"black\">";
const char* mid = "</font></nobr></td><td><nobr><font color=\"black\">";
const char* end = "</font></nobr></td></tr>";
tip = "<table cellspacing=0 cellpadding=0>";
tip += start + i18n("Name:") + mid + text() + end;
tip += start + i18n("Type:") + mid;
QString type = QStyleSheet::escape(mimeComment());
if ( m_bLink ) {
tip += i18n("Link to %1 (%2)").arg(linkDest(), type) + end;
} else
tip += type + end;
if ( !S_ISDIR ( m_fileMode ) ) {
bool hasSize;
KIO::filesize_t sizeValue = size(hasSize);
if(hasSize)
tip += start + i18n("Size:") + mid +
KIO::convertSizeWithBytes(sizeValue) + end;
}
QString timeStr = timeString( KIO::UDS_MODIFICATION_TIME);
if(!timeStr.isEmpty())
tip += start + i18n("Modified:") + mid +
timeStr + end;
#ifndef Q_WS_WIN //TODO: show win32-specific permissions
QString userStr = user();
QString groupStr = group();
if(!userStr.isEmpty() || !groupStr.isEmpty())
tip += start + i18n("Owner:") + mid + userStr + " - " + groupStr + end +
start + i18n("Permissions:") + mid +
parsePermissions(m_permissions) + end;
#endif
if (info.isValid() && !info.isEmpty() )
{
tip += "<tr><td colspan=2><center><s> </s></center></td></tr>";
QStringList keys = info.preferredKeys();
// now the rest
QStringList::Iterator it = keys.begin();
for (int count = 0; count<maxcount && it!=keys.end() ; ++it)
{
KFileMetaInfoItem item = info.item( *it );
if ( item.isValid() )
{
QString s = item.string();
if ( ( item.attributes() & KFileMimeTypeInfo::SqueezeText )
&& s.length() > 50) {
s.truncate(47);
s.append("...");
}
if ( !s.isEmpty() )
{
count++;
tip += start +
QStyleSheet::escape( item.translatedKey() ) + ":" +
mid +
QStyleSheet::escape( s ) +
end;
}
}
}
}
tip += "</table>";
//kdDebug() << "making this the tool tip rich text:\n";
//kdDebug() << tip << endl;
return tip;
}
int main(int argc, char **argv)
{
ros::init (argc, argv, "right_arm_pick_place");
ros::AsyncSpinner spinner(1);
spinner.start();
ros::NodeHandle nh;
ros::Publisher pub_co = nh.advertise<moveit_msgs::CollisionObject>("collision_object", 10);
ros::WallDuration(1.0).sleep();
moveit::planning_interface::MoveGroup group("right_arm");
group.setPlanningTime(45.0);
moveit_msgs::CollisionObject co;
co.header.stamp = ros::Time::now();
co.header.frame_id = "base_footprint";
// remove pole
co.id = "pole";
co.operation = moveit_msgs::CollisionObject::REMOVE;
pub_co.publish(co);
// add pole
co.operation = moveit_msgs::CollisionObject::ADD;
co.primitives.resize(1);
co.primitives[0].type = shape_msgs::SolidPrimitive::BOX;
co.primitives[0].dimensions.resize(shape_tools::SolidPrimitiveDimCount<shape_msgs::SolidPrimitive::BOX>::value);
co.primitives[0].dimensions[shape_msgs::SolidPrimitive::BOX_X] = 0.3;
co.primitives[0].dimensions[shape_msgs::SolidPrimitive::BOX_Y] = 0.1;
co.primitives[0].dimensions[shape_msgs::SolidPrimitive::BOX_Z] = 1.0;
co.primitive_poses.resize(1);
co.primitive_poses[0].position.x = 0.7;
co.primitive_poses[0].position.y = -0.4;
co.primitive_poses[0].position.z = 0.85;
co.primitive_poses[0].orientation.w = 1.0;
pub_co.publish(co);
// remove table
co.id = "table";
co.operation = moveit_msgs::CollisionObject::REMOVE;
pub_co.publish(co);
// add table
co.operation = moveit_msgs::CollisionObject::ADD;
co.primitives[0].dimensions[shape_msgs::SolidPrimitive::BOX_X] = 0.5;
co.primitives[0].dimensions[shape_msgs::SolidPrimitive::BOX_Y] = 1.5;
co.primitives[0].dimensions[shape_msgs::SolidPrimitive::BOX_Z] = 0.35;
co.primitive_poses[0].position.x = 0.7;
co.primitive_poses[0].position.y = -0.2;
co.primitive_poses[0].position.z = 0.175;
pub_co.publish(co);
co.id = "part";
co.operation = moveit_msgs::CollisionObject::REMOVE;
pub_co.publish(co);
co.operation = moveit_msgs::CollisionObject::ADD;
co.primitives[0].dimensions[shape_msgs::SolidPrimitive::BOX_X] = 0.15;
co.primitives[0].dimensions[shape_msgs::SolidPrimitive::BOX_Y] = 0.1;
co.primitives[0].dimensions[shape_msgs::SolidPrimitive::BOX_Z] = 0.3;
co.primitive_poses[0].position.x = 0.6;
co.primitive_poses[0].position.y = -0.7;
co.primitive_poses[0].position.z = 0.5;
pub_co.publish(co);
// wait a bit for ros things to initialize
ros::WallDuration(1.0).sleep();
pick(group);
ros::WallDuration(1.0).sleep();
place(group);
ros::waitForShutdown();
return 0;
}
void KbPerf::load(CkbSettings& settings){
pushedDpis.clear();
runningPushIdx = 1;
_needsSave = false;
bool readIndicators = true;
if(!settings.containsGroup("Performance/Indicators")){
// Read old indicator settings from the lighting group, if present
// (ckb <= v0.2.0)
SGroup group(settings, "Lighting");
if(settings.contains("InactiveIndicators")){
bool inOk = false;
int inactive = settings.value("InactiveIndicators").toInt(&inOk);
if(!inOk || inactive > 2)
inactive = 2;
if(inactive == 1)
_iOpacity = 0.75f;
else if(inactive == 0)
_iOpacity = 0.5f;
else if(inactive < 0){
// Indicators disabled
iEnable[MODE] = iEnable[MACRO] = iEnable[LIGHT] = iEnable[LOCK] = iEnable[MUTE] = false;
}
bool showMute = (settings.value("ShowMute").toInt(&inOk) != 0);
if(inOk && !showMute)
iEnable[MUTE] = false;
readIndicators = false;
}
}
SGroup group(settings, "Performance");
// Read DPI settings
{
SGroup group(settings, "DPI");
for(int i = 0; i < DPI_COUNT; i++){
QString iStr = QString::number(i);
QPoint value = settings.value(iStr).toPoint();
if(value.isNull())
continue;
dpiX[i] = value.x(); dpiY[i] = value.y();
QColor color = settings.value(iStr + "RGB").toString();
if(color.isValid())
dpiClr[i] = color;
if(i != 0)
dpiOn[i] = !settings.value(iStr + "Disabled").toBool();
}
QColor color = settings.value("6RGB").toString();
if(color.isValid())
dpiClr[OTHER] = color;
if(settings.contains("LastIdx")){
dpiLastIdx = settings.value("LastIdx").toInt();
if(dpiLastIdx >= DPI_COUNT || dpiLastIdx < 0)
dpiLastIdx = 1;
}
QPoint value = settings.value("Current").toPoint();
if(!value.isNull())
curDpi(value);
}
// Read misc. mouse settings
_liftHeight = (height)settings.value("LiftHeight").toInt();
if(_liftHeight < LOW || _liftHeight > HIGH)
_liftHeight = MEDIUM;
_angleSnap = settings.value("AngleSnap").toBool();
if(settings.contains("NoIndicator")){
// ckb <= v0.2.0
_dpiIndicator = !settings.value("NoIndicator").toBool();
} else {
_dpiIndicator = settings.value("Indicators/DPI", true).toBool();
}
// Read indicator settings
if(readIndicators){
SGroup group(settings, "Indicators");
_iOpacity = settings.value("Opacity", 100).toInt() / 100.f;
for(int i = 0; i < I_COUNT; i++){
SGroup group(settings, QString::number(i));
QColor color = settings.value("RGB0").toString();
if(color.isValid())
iColor[i][0] = color;
color = settings.value("RGB1").toString();
if(color.isValid())
iColor[i][1] = color;
if(i == LIGHT){
color = settings.value("RGB2").toString();
if(color.isValid())
light100Color = color;
} else if(i == MUTE){
color = settings.value("RGB2").toString();
if(color.isValid())
muteNAColor = color;
}
if(i <= HW_IMAX){
iEnable[i] = settings.value("Enable", false).toBool();
hwIType[i] = (i_hw)settings.value("Hardware", (int)NORMAL).toInt();
} else {
iEnable[i] = settings.value("Enable", true).toBool();
}
}
}
emit didLoad();
}
void ExtensionManager::migrateMenubar()
{
// lame, lame, lame.
// the menubar applet was just plunked into kicker and not much
// thought was put into how it should be used. great idea, but no
// integration. >:-(
// so now we have to check to see if we HAVE another extension that
// will have a menubar in it, and if so, abort creating one of our
// own.
//
// the reason i didn't do this as a kconfig_update script is that
// most people don't use this feature, so no reason to penalize
// everyone, and moreover the user may added this to their main
// panel, meaning kickerrc itself would have to be vastly modified
// with lots of complications. not work it IMHO.
KConfigGroup config(KGlobal::config(), "General");
if (config.readEntry("CheckedForMenubar", false))
{
return;
}
if (!KStandardDirs::locate("config", "kicker_menubarpanelrc").isEmpty())
{
// don't overwrite/override something that's already there
return;
}
QStringList elist = config.readEntry("Extensions2", QStringList() );
foreach (QString extensionId, elist)
{
if (extensionId.indexOf("Extension") == -1)
{
continue;
}
config.changeGroup(extensionId);
// is there a config group for this extension?
if (!config.exists() )
{
continue;
}
QString extension = config.readPathEntry("ConfigFile", false);
KConfig extensionConfig(KStandardDirs::locate("config", extension));
KConfigGroup eg (&extensionConfig, "General");
if (eg.hasKey("Applets2"))
{
QStringList containers = eg.readEntry("Applets2", QStringList() );
foreach (QString appletId, containers)
{
// is there a config group for this applet?
if (!extensionConfig.hasGroup(appletId))
{
continue;
}
KConfigGroup group(&extensionConfig, appletId);
QString appletType = appletId.left(appletId.lastIndexOf('_'));
if (appletType == "Applet")
{
QString appletFile = group.readPathEntry("DesktopFile", false);
if (appletFile.indexOf("menuapplet.desktop") != -1)
{
QString menubarConfig = KStandardDirs::locate("config", extension);
KIO::NetAccess::file_copy(menubarConfig,
KStandardDirs::locateLocal("config",
"kicker_menubarpanelrc"), 0);
elist.removeAll(appletId);
config.changeGroup("General");
config.writeEntry("Extensions2", elist);
config.writeEntry("CheckedForMenubar", true);
config.sync();
return;
}
}
}
}
}
bool KQuickConfig::isEditable(const QString &key)
{
return !m_config->group(group()).isEntryImmutable(key);
}
bool KviConfigurationFile::save()
{
static unsigned char encode_table[256]=
{
// 000 001 002 003 004 005 006 007 008 009 010 011 012 013 014 015
// NUL SOH STX ETX EOT ENQ ACK BEL BS HT LF VT FF CR SO SI
1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,
// 016 017 018 019 020 021 022 023 024 025 026 027 028 029 030 031
// DLE DC1 DC2 DC3 DC4 NAK SYN ETB CAN EM SUB ESC FS GS RS US
1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,
// 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047
// ! " # $ % & ' ( ) * + , - . /
1 ,0 ,0 ,1 ,0 ,1 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,
// 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063
// 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,1 ,0 ,0 ,
// 064 065 066 067 068 069 070 071 072 073 074 075 076 077 078 079
// @ A B C D E F G H I J K L M N O
0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,
// 080 081 082 083 084 085 086 087 088 089 090 091 092 093 094 095
// P Q R S T U V W X Y Z [ \ ] ^ _
0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,1 ,0 ,1 ,0 ,0 ,
// 096 097 098 099 100 101 102 103 104 105 106 107 108 109 110 111
// ` a b c d e f g h i j k l m n o
0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,
// 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
// p q r s t u v w x y z { | } ~
0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,
// 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
//
0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,
// 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159
//
0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,
// 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
//
0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,
// 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
//
0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,
// 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
// � � � � � � � � � � � � � � � �
0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,
// 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
// � � � � � � � � � � � � � � � �
0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,
// 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
// � � � � � � � � � � � � � � � �
0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,
// 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
// � � � � � � � �
0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0
};
if(m_bReadOnly) return false;
KviFile f(m_szFileName);
if(!f.open(QFile::WriteOnly | QFile::Truncate)) return false;
if(f.write("# KVIrc configuration file\n",27) != 27) return false;
KviPointerHashTableIterator<QString,KviConfigurationFileGroup> it(*m_pDict);
while (it.current())
{
if((it.current()->count() != 0) || (m_bPreserveEmptyGroups))
{
KviCString group(m_bLocal8Bit ? it.currentKey().toLocal8Bit() : it.currentKey().toUtf8());
group.hexEncodeWithTable(encode_table);
if(!f.putChar('['))return false;
if(f.write(group.ptr(),group.len()) < (unsigned int) group.len())return false;
if(f.write("]\n",2) < 2)return false;
KviConfigurationFileGroup * dict = (KviConfigurationFileGroup *)it.current();
KviConfigurationFileGroupIterator it2(*dict);
KviCString szName,szValue;
while(QString * p_str = it2.current())
{
szName = m_bLocal8Bit ? it2.currentKey().toLocal8Bit() : it2.currentKey().toUtf8();
szValue = m_bLocal8Bit ? (*p_str).toLocal8Bit() : (*p_str).toUtf8();
szName.hexEncodeWithTable(encode_table);
szValue.hexEncodeWhiteSpace();
if(f.write(szName.ptr(),szName.len()) < (unsigned int) szName.len())return false;
if(!f.putChar('='))return false;
if(f.write(szValue.ptr(),szValue.len()) < (unsigned int) szValue.len())return false;
if(!f.putChar('\n'))return false;
++it2;
}
}
++it;
}
f.close();
m_bDirty = false;
return true;
}
void UMLEditor::layout(){
mainPanel = new QWidget;
mainLayout = new QHBoxLayout;
btnGroup = new QButtonGroup(this);
btnGroup->setExclusive(true);
SelectButton *btn = new SelectButton(canvas);
ClassBoxButton *btn2 = new ClassBoxButton(canvas);
btnGroup->addButton(btn);
btnGroup->addButton(btn2);
buttons.push_back(new SelectButton(canvas));
buttons.push_back(new ClassBoxButton(canvas));
buttons.push_back(new UseCaseButton(canvas));
buttons.push_back(new AssLineButton(canvas));
buttons.push_back(new GenLineButton(canvas));
buttons.push_back(new ComLineButton(canvas));
buttons[0]->pressed();
for(std::vector<Button*>::size_type i = 0; i != buttons.size(); i++) {
btnGroup->addButton(buttons[i]);
}
toolPanel = new QWidget;
toolPanelLayout = new QGridLayout;
toolPanelLayout->setAlignment(Qt::AlignTop);
for(std::vector<QToolButton*>::size_type i = 0; i != buttons.size(); i++) {
toolPanelLayout->addWidget(buttons[i], i, 0, Qt::AlignHCenter);
}
toolPanel->setLayout(toolPanelLayout);
toolPanel->setMinimumWidth(100);
menubar = new QMenuBar;
file = menubar->addMenu(tr("&File"));
edit = menubar->addMenu(tr("&Edit"));
exit = new QAction(tr("Exit"), mainPanel);
this->connect(exit, SIGNAL(triggered()), this, SLOT(close()));
group = new QAction(tr("Group"), mainPanel);
this->connect(group, SIGNAL(triggered()), canvas, SLOT(group()));
ungroup = new QAction(tr("UnGroup"), mainPanel);
this->connect(ungroup, SIGNAL(triggered()), canvas, SLOT(ungroup()));
named = new QAction(tr("Change Object Name"), mainPanel);
this->connect(named, SIGNAL(triggered()), canvas, SLOT(named()));
file->addAction(exit);
edit->addAction(group);
edit->addAction(ungroup);
edit->addAction(named);
canvas->setSceneRect(QRectF(-200,-200,400,400));
//view->setDragMode(QGraphicsView::RubberBandDrag);
view->setScene(canvas);
view->resize(400,400);
mainLayout->addWidget(toolPanel,0);
mainLayout->setAlignment(toolPanel,Qt::AlignTop);
mainLayout->addWidget(view,1);
mainLayout->setMenuBar(menubar);
mainPanel->setLayout(mainLayout);
setCentralWidget(mainPanel);
}
ConfigureDialog::~ConfigureDialog()
{
KConfigGroup group(KSharedConfig::openConfig("print-manager"), "ConfigureDialog");
KWindowConfig::saveWindowSize(windowHandle(), group);
}
void
Layer3::Run (pth_sem_t * stop1)
{
pth_event_t stop = pth_event (PTH_EVENT_SEM, stop1);
unsigned i;
running = true;
for (i = 0; i < layer2 (); i++)
layer2[i].Start ();
TRACEPRINTF (t, 3, this, "L3 started");
while (pth_event_status (stop) != PTH_STATUS_OCCURRED)
{
pth_event_t bufev = pth_event (PTH_EVENT_SEM, &bufsem);
pth_event_concat (bufev, stop, NULL);
pth_wait (bufev);
pth_event_isolate (bufev);
if (pth_event_status (bufev) != PTH_STATUS_OCCURRED)
{
pth_event_free (bufev, PTH_FREE_THIS);
continue;
}
pth_event_free (bufev, PTH_FREE_THIS);
pth_sem_dec (&bufsem);
LPDU *l = buf.get ();
if (!l)
continue;
if (l->getType () == L_Busmonitor)
{
L_Busmonitor_PDU *l1, *l2;
l1 = (L_Busmonitor_PDU *) l;
TRACEPRINTF (t, 3, this, "Recv %s", l1->Decode ()());
for (i = 0; i < busmonitor (); i++)
{
l2 = new L_Busmonitor_PDU (*l1);
busmonitor[i].cb->Send_L_Busmonitor (l2);
}
for (i = 0; i < vbusmonitor (); i++)
{
l2 = new L_Busmonitor_PDU (*l1);
vbusmonitor[i].cb->Send_L_Busmonitor (l2);
}
}
if (l->getType () == L_Data)
{
L_Data_PDU *l1;
l1 = (L_Data_PDU *) l;
if (l1->repeated)
{
CArray d1 = l1->ToPacket ();
for (i = 0; i < ignore (); i++)
if (d1 == ignore[i].data)
{
TRACEPRINTF (t, 3, this, "Repeated discareded");
goto wt;
}
}
l1->repeated = 1;
ignore.resize (ignore () + 1);
ignore[ignore () - 1].data = l1->ToPacket ();
ignore[ignore () - 1].end = getTime () + 1000000;
l1->repeated = 0;
if (l1->AddrType == IndividualAddress
&& l1->dest == defaultAddr)
l1->dest = 0;
TRACEPRINTF (t, 3, this, "Recv %s", l1->Decode ()());
if (l1->AddrType == GroupAddress && l1->dest == 0)
{
for (i = 0; i < broadcast (); i++)
broadcast[i].cb->Send_L_Data (new L_Data_PDU (*l1));
}
if (l1->AddrType == GroupAddress && l1->dest != 0)
{
for (i = 0; i < group (); i++)
{
Group_Info &grp = group[i];
if (grp.dest == l1->dest || grp.dest == 0)
grp.cb->Send_L_Data (new L_Data_PDU (*l1));
}
}
if (l1->AddrType == IndividualAddress)
{
for (i = 0; i < individual (); i++)
{
Individual_Info &indiv = individual[i];
if (indiv.dest == l1->dest || indiv.dest == 0)
if (indiv.src == l1->source || indiv.src == 0)
indiv.cb->Send_L_Data (new L_Data_PDU (*l1));
}
}
// finally, send to all (other(?)) L2 interfaces
// TODO: filter by addresses
send_L_Data(l1);
}
// ignore[] is ordered, any timed-out items are at the front
for (i = 0; i < ignore (); i++)
if (ignore[i].end >= getTime ())
break;
if (i)
ignore.deletepart (0, i);
wt:
delete l;
}
TRACEPRINTF (t, 3, this, "L3 stopping");
running = false;
for (i = 0; i < layer2 (); i++)
layer2[i].Stop ();
pth_event_free (stop, PTH_FREE_THIS);
}
KrViewer::KrViewer(QWidget *parent) :
KParts::MainWindow(parent, (Qt::WindowFlags)KDE_DEFAULT_WINDOWFLAGS), manager(this, this), tabBar(this),
reservedKeys(), reservedKeyActions(), sizeX(-1), sizeY(-1)
{
//setWFlags(Qt::WType_TopLevel | WDestructiveClose);
setXMLFile("krviewer.rc"); // kpart-related xml file
setHelpMenuEnabled(false);
connect(&manager, SIGNAL(activePartChanged(KParts::Part*)),
this, SLOT(createGUI(KParts::Part*)));
connect(&tabBar, &QTabWidget::currentChanged, this, &KrViewer::tabChanged);
connect(&tabBar, SIGNAL(tabCloseRequested(int)), this, SLOT(tabCloseRequest(int)));
tabBar.setDocumentMode(true);
tabBar.setMovable(true);
setCentralWidget(&tabBar);
printAction = KStandardAction::print(this, SLOT(print()), 0);
copyAction = KStandardAction::copy(this, SLOT(copy()), 0);
viewerMenu = new QMenu(this);
QAction *tempAction;
KActionCollection *ac = actionCollection();
#define addCustomMenuAction(name, text, slot, shortcut)\
tempAction = ac->addAction(name, this, slot);\
tempAction->setText(text);\
ac->setDefaultShortcut(tempAction, shortcut);\
viewerMenu->addAction(tempAction);
addCustomMenuAction("genericViewer", i18n("&Generic Viewer"), SLOT(viewGeneric()), Qt::CTRL + Qt::SHIFT + Qt::Key_G);
addCustomMenuAction("textViewer", i18n("&Text Viewer"), SLOT(viewText()), Qt::CTRL + Qt::SHIFT + Qt::Key_T);
addCustomMenuAction("hexViewer", i18n("&Hex Viewer"), SLOT(viewHex()), Qt::CTRL + Qt::SHIFT + Qt::Key_H);
addCustomMenuAction("lister", i18n("&Lister"), SLOT(viewLister()), Qt::CTRL + Qt::SHIFT + Qt::Key_L);
viewerMenu->addSeparator();
addCustomMenuAction("textEditor", i18n("Text &Editor"), SLOT(editText()), Qt::CTRL + Qt::SHIFT + Qt::Key_E);
viewerMenu->addSeparator();
QList<QAction *> actList = menuBar()->actions();
bool hasPrint = false, hasCopy = false;
foreach(QAction *a, actList) {
if (a->shortcut().matches(printAction->shortcut()) != QKeySequence::NoMatch)
hasPrint = true;
if (a->shortcut().matches(copyAction->shortcut()) != QKeySequence::NoMatch)
hasCopy = true;
}
QAction *printAct = viewerMenu->addAction(printAction->icon(), printAction->text(), this, SLOT(print()));
if (hasPrint)
printAct->setShortcut(printAction->shortcut());
QAction *copyAct = viewerMenu->addAction(copyAction->icon(), copyAction->text(), this, SLOT(copy()));
if (hasCopy)
copyAct->setShortcut(copyAction->shortcut());
viewerMenu->addSeparator();
configKeysAction = ac->addAction(KStandardAction::KeyBindings, this, SLOT(configureShortcuts()));
viewerMenu->addAction(configKeysAction);
viewerMenu->addSeparator();
detachAction = ac->addAction("detachTab", this, SLOT(detachTab()));
detachAction->setText(i18n("&Detach Tab"));
//no point in detaching only one tab..
detachAction->setEnabled(false);
ac->setDefaultShortcut(detachAction, Qt::META + Qt::Key_D);
viewerMenu->addAction(detachAction);
quitAction = ac->addAction(KStandardAction::Quit, this, SLOT(close()));
viewerMenu->addAction(quitAction);
tabCloseAction = ac->addAction("closeTab", this, SLOT(tabCloseRequest()));
tabCloseAction->setText(i18n("&Close Current Tab"));
QList<QKeySequence> shortcuts = KStandardShortcut::close();
shortcuts.append(Qt::Key_Escape);
ac->setDefaultShortcuts(tabCloseAction, shortcuts);
tabNextAction = ac->addAction("nextTab", this, SLOT(nextTab()));
tabNextAction->setText(i18n("&Next Tab"));
ac->setDefaultShortcuts(tabNextAction, KStandardShortcut::tabNext());
tabPrevAction = ac->addAction("prevTab", this, SLOT(prevTab()));
tabPrevAction->setText(i18n("&Previous Tab"));
ac->setDefaultShortcuts(tabPrevAction, KStandardShortcut::tabPrev());
tabBar.setTabsClosable(true);
checkModified();
KConfigGroup group(krConfig, "KrViewerWindow");
int sx = group.readEntry("Window Width", -1);
int sy = group.readEntry("Window Height", -1);
if (sx != -1 && sy != -1)
resize(sx, sy);
else
resize(900, 700);
if (group.readEntry("Window Maximized", false)) {
setWindowState(windowState() | Qt::WindowMaximized);
}
// filtering out the key events
menuBar() ->installEventFilter(this);
}
osg::ref_ptr<osg::Node> TerrainGrid::buildTerrain (osg::Group* parent, float chunkSize, const osg::Vec2f& chunkCenter)
{
if (chunkSize * mNumSplits > 1.f)
{
// keep splitting
osg::ref_ptr<osg::Group> group (new osg::Group);
if (parent)
parent->addChild(group);
float newChunkSize = chunkSize/2.f;
buildTerrain(group, newChunkSize, chunkCenter + osg::Vec2f(newChunkSize/2.f, newChunkSize/2.f));
buildTerrain(group, newChunkSize, chunkCenter + osg::Vec2f(newChunkSize/2.f, -newChunkSize/2.f));
buildTerrain(group, newChunkSize, chunkCenter + osg::Vec2f(-newChunkSize/2.f, newChunkSize/2.f));
buildTerrain(group, newChunkSize, chunkCenter + osg::Vec2f(-newChunkSize/2.f, -newChunkSize/2.f));
return group;
}
else
{
float minH, maxH;
if (!mStorage->getMinMaxHeights(chunkSize, chunkCenter, minH, maxH))
return NULL; // no terrain defined
osg::Vec2f worldCenter = chunkCenter*mStorage->getCellWorldSize();
osg::ref_ptr<SceneUtil::PositionAttitudeTransform> transform (new SceneUtil::PositionAttitudeTransform);
transform->setPosition(osg::Vec3f(worldCenter.x(), worldCenter.y(), 0.f));
if (parent)
parent->addChild(transform);
osg::ref_ptr<osg::Vec3Array> positions (new osg::Vec3Array);
osg::ref_ptr<osg::Vec3Array> normals (new osg::Vec3Array);
osg::ref_ptr<osg::Vec4Array> colors (new osg::Vec4Array);
osg::ref_ptr<osg::VertexBufferObject> vbo (new osg::VertexBufferObject);
positions->setVertexBufferObject(vbo);
normals->setVertexBufferObject(vbo);
colors->setVertexBufferObject(vbo);
mStorage->fillVertexBuffers(0, chunkSize, chunkCenter, positions, normals, colors);
osg::ref_ptr<osg::Geometry> geometry (new osg::Geometry);
geometry->setVertexArray(positions);
geometry->setNormalArray(normals, osg::Array::BIND_PER_VERTEX);
geometry->setColorArray(colors, osg::Array::BIND_PER_VERTEX);
geometry->setUseDisplayList(false);
geometry->setUseVertexBufferObjects(true);
geometry->addPrimitiveSet(mCache.getIndexBuffer(0));
// we already know the bounding box, so no need to let OSG compute it.
osg::Vec3f min(-0.5f*mStorage->getCellWorldSize()*chunkSize,
-0.5f*mStorage->getCellWorldSize()*chunkSize,
minH);
osg::Vec3f max (0.5f*mStorage->getCellWorldSize()*chunkSize,
0.5f*mStorage->getCellWorldSize()*chunkSize,
maxH);
osg::BoundingBox bounds(min, max);
geometry->setComputeBoundingBoxCallback(new StaticBoundingBoxCallback(bounds));
std::vector<LayerInfo> layerList;
std::vector<osg::ref_ptr<osg::Image> > blendmaps;
mStorage->getBlendmaps(chunkSize, chunkCenter, false, blendmaps, layerList);
// For compiling textures, I don't think the osgFX::Effect does it correctly
osg::ref_ptr<osg::Node> textureCompileDummy (new osg::Node);
unsigned int dummyTextureCounter = 0;
bool useShaders = mResourceSystem->getSceneManager()->getForceShaders();
if (!mResourceSystem->getSceneManager()->getClampLighting())
useShaders = true; // always use shaders when lighting is unclamped, this is to avoid lighting seams between a terrain chunk with normal maps and one without normal maps
std::vector<TextureLayer> layers;
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(mTextureCacheMutex);
for (std::vector<LayerInfo>::const_iterator it = layerList.begin(); it != layerList.end(); ++it)
{
TextureLayer textureLayer;
textureLayer.mParallax = it->mParallax;
textureLayer.mSpecular = it->mSpecular;
osg::ref_ptr<osg::Texture2D> texture = mTextureCache[it->mDiffuseMap];
if (!texture)
{
texture = new osg::Texture2D(mResourceSystem->getImageManager()->getImage(it->mDiffuseMap));
texture->setWrap(osg::Texture::WRAP_S, osg::Texture::REPEAT);
texture->setWrap(osg::Texture::WRAP_T, osg::Texture::REPEAT);
mResourceSystem->getSceneManager()->applyFilterSettings(texture);
mTextureCache[it->mDiffuseMap] = texture;
}
textureLayer.mDiffuseMap = texture;
textureCompileDummy->getOrCreateStateSet()->setTextureAttributeAndModes(dummyTextureCounter++, texture);
if (!it->mNormalMap.empty())
{
texture = mTextureCache[it->mNormalMap];
if (!texture)
{
texture = new osg::Texture2D(mResourceSystem->getImageManager()->getImage(it->mNormalMap));
texture->setWrap(osg::Texture::WRAP_S, osg::Texture::REPEAT);
texture->setWrap(osg::Texture::WRAP_T, osg::Texture::REPEAT);
mResourceSystem->getSceneManager()->applyFilterSettings(texture);
mTextureCache[it->mNormalMap] = texture;
}
textureCompileDummy->getOrCreateStateSet()->setTextureAttributeAndModes(dummyTextureCounter++, texture);
textureLayer.mNormalMap = texture;
}
if (it->requiresShaders())
useShaders = true;
layers.push_back(textureLayer);
}
}
std::vector<osg::ref_ptr<osg::Texture2D> > blendmapTextures;
for (std::vector<osg::ref_ptr<osg::Image> >::const_iterator it = blendmaps.begin(); it != blendmaps.end(); ++it)
{
osg::ref_ptr<osg::Texture2D> texture (new osg::Texture2D);
texture->setImage(*it);
texture->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE);
texture->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE);
texture->setResizeNonPowerOfTwoHint(false);
blendmapTextures.push_back(texture);
textureCompileDummy->getOrCreateStateSet()->setTextureAttributeAndModes(dummyTextureCounter++, blendmapTextures.back());
}
// use texture coordinates for both texture units, the layer texture and blend texture
for (unsigned int i=0; i<2; ++i)
geometry->setTexCoordArray(i, mCache.getUVBuffer());
float blendmapScale = ESM::Land::LAND_TEXTURE_SIZE*chunkSize;
osg::ref_ptr<osgFX::Effect> effect (new Terrain::Effect(mShaderManager ? useShaders : false, mResourceSystem->getSceneManager()->getForcePerPixelLighting(), mResourceSystem->getSceneManager()->getClampLighting(),
mShaderManager, layers, blendmapTextures, blendmapScale, blendmapScale));
effect->addCullCallback(new SceneUtil::LightListCallback);
transform->addChild(effect);
osg::Node* toAttach = geometry.get();
effect->addChild(toAttach);
if (mIncrementalCompileOperation)
{
mIncrementalCompileOperation->add(toAttach);
mIncrementalCompileOperation->add(textureCompileDummy);
}
return transform;
}
}
// returns true if plugin was loaded successfully
bool KDecorationPlugins::loadPlugin(QString nameStr)
{
KConfigGroup group(config, QString("Style"));
if (nameStr.isEmpty()) {
nameStr = group.readEntry("PluginLib", defaultPlugin);
}
// Check if this library is not already loaded.
if (pluginStr == nameStr)
return true;
KLibrary *oldLibrary = library;
KDecorationFactory* oldFactory = fact;
if (!canLoad(nameStr, &library)) {
// If that fails, fall back to the default plugin
nameStr = defaultPlugin;
if (!canLoad(nameStr, &library)) {
// big time trouble!
// -> exit kwin with an error message
error(i18n("The default decoration plugin is corrupt and could not be loaded."));
return false;
}
}
// guarded by "canLoad"
KLibrary::void_function_ptr create_func = library->resolveFunction("create_factory");
if (create_func)
create_ptr = (KDecorationFactory * (*)())create_func;
if (!create_ptr) { // this means someone probably attempted to load "some" kwin plugin/lib as deco
// and thus cheated on the "isLoaded" shortcut -> try the default and yell a warning
if (nameStr != defaultPlugin) {
kWarning(1212) << i18n("The library %1 was attempted to be loaded as a decoration plugin but it is NOT", nameStr);
return loadPlugin(defaultPlugin);
} else {
// big time trouble!
// -> exit kwin with an error message
error(i18n("The default decoration plugin is corrupt and could not be loaded."));
return false;
}
}
fact = create_ptr();
fact->checkRequirements(this); // let it check what is supported
pluginStr = nameStr;
// For clients in kdeartwork
QString catalog = nameStr;
catalog.replace("kwin3_", "kwin_");
KGlobal::locale()->insertCatalog(catalog);
// For KCommonDecoration based clients
KGlobal::locale()->insertCatalog("libkdecorations");
// For clients in kdebase
KGlobal::locale()->insertCatalog("kwin_clients");
// For clients in kdeartwork
KGlobal::locale()->insertCatalog("kwin_art_clients");
old_library = oldLibrary; // save for delayed destroying
old_fact = oldFactory;
return true;
}
// tests whether the plugin can be loaded
bool KDecorationPlugins::canLoad(QString nameStr, KLibrary **loadedLib)
{
if (nameStr.isEmpty())
return false; // we can't load that
// Check if this library is not already loaded.
if (pluginStr == nameStr) {
if (loadedLib) {
*loadedLib = library;
}
return true;
}
KConfigGroup group(config, QString("Style"));
if (group.readEntry<bool>("NoPlugin", false)) {
error(i18n("Loading of window decoration plugin library disabled in configuration."));
return false;
}
KLibrary libToFind(nameStr);
QString path = libToFind.fileName();
kDebug(1212) << "kwin : path " << path << " for " << nameStr;
if (path.isEmpty()) {
return false;
}
// Try loading the requested plugin
KLibrary *lib = new KLibrary(path);
if (!lib)
return false;
// TODO this would be a nice shortcut, but for "some" reason QtCurve with wrong ABI slips through
// TODO figure where it's loaded w/o being unloaded and check whether that can be fixed.
#if 0
if (lib->isLoaded()) {
if (loadedLib) {
*loadedLib = lib;
}
return true;
}
#endif
// so we check whether this lib was loaded before and don't unload it in case
bool wasLoaded = lib->isLoaded();
KDecorationFactory*(*cptr)() = NULL;
int (*vptr)() = NULL;
int deco_version = 0;
KLibrary::void_function_ptr version_func = lib->resolveFunction("decoration_version");
if (version_func) {
vptr = (int(*)())version_func;
deco_version = vptr();
} else {
// block some decos known to link the unstable API but (for now) let through other legacy stuff
const bool isLegacyStableABI = !(nameStr.contains("qtcurve", Qt::CaseInsensitive) ||
nameStr.contains("crystal", Qt::CaseInsensitive) ||
nameStr.contains("oxygen", Qt::CaseInsensitive));
if (isLegacyStableABI) {
// it's an old build of a legacy decoration that very likely uses the stable API
// so we just set the API version to the current one
// TODO: remove for 4.9.x or 4.10 - this is just to cover recompiles
deco_version = KWIN_DECORATION_API_VERSION;
}
kWarning(1212) << QString("****** The library %1 has no API version ******").arg(path);
kWarning(1212) << "****** Please use the KWIN_DECORATION macro in extern \"C\" to get this decoration loaded in future versions of kwin";
}
if (deco_version != KWIN_DECORATION_API_VERSION) {
if (version_func)
kWarning(1212) << i18n("The library %1 has wrong API version %2", path, deco_version);
lib->unload();
delete lib;
return false;
}
KLibrary::void_function_ptr create_func = lib->resolveFunction("create_factory");
if (create_func)
cptr = (KDecorationFactory * (*)())create_func;
if (!cptr) {
kDebug(1212) << i18n("The library %1 is not a KWin plugin.", path);
lib->unload();
delete lib;
return false;
}
if (loadedLib) {
*loadedLib = lib;
} else {
if (!wasLoaded)
lib->unload();
delete lib;
}
return true;
}
void StubCodeDesc::print_on(outputStream* st) const {
st->print(group());
st->print("::");
st->print(name());
st->print(" [" INTPTR_FORMAT ", " INTPTR_FORMAT "[ (%d bytes)", begin(), end(), size_in_bytes());
}
ConfigureDialog::ConfigureDialog(const QString &destName, bool isClass, QWidget *parent) :
KPageDialog(parent)
{
setFaceType(List);
setModal(false);
setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel | QDialogButtonBox::Apply);
setWindowTitle(destName);
setWindowIcon(QIcon::fromTheme("configure"));
enableButtonApply(false);
// Needed so we have our dialog size saved
setAttribute(Qt::WA_DeleteOnClose);
QStringList attr;
KPageWidgetItem *page;
modifyPrinter = new ModifyPrinter(destName, isClass, this);
PrinterBehavior *printerBehavior = new PrinterBehavior(destName, isClass, this);
attr << modifyPrinter->neededValues();
attr << printerBehavior->neededValues();
attr << KCUPS_PRINTER_TYPE; // needed to know if it's a remote printer
attr << KCUPS_PRINTER_MAKE_AND_MODEL;
KCupsPrinter printer;
QPointer<KCupsRequest> request = new KCupsRequest;
request->getPrinterAttributes(destName, isClass, attr);
request->waitTillFinished();
if (!request) {
return;
}
if (!request->hasError() && !request->printers().isEmpty()){
printer = request->printers().first();
}
// qCDebug(PM_CONFIGURE_PRINTER) << "VALUES" << printer.a rgument();
// qCDebug(PM_CONFIGURE_PRINTER) << "marker" << values["marker-levels"].value<QList<int> >();
request->deleteLater();
// qCDebug(PM_CONFIGURE_PRINTER) << values;
if (printer.type() & CUPS_PRINTER_LOCAL) {
qCDebug(PM_CONFIGURE_PRINTER) << "CUPS_PRINTER_LOCAL";
}
isClass = printer.isClass();
bool isRemote = false;
if (printer.type() & CUPS_PRINTER_REMOTE) {
qCDebug(PM_CONFIGURE_PRINTER) << "CUPS_PRINTER_REMOTE";
isRemote = true;
}
if (printer.type() & CUPS_PRINTER_BW) {
qCDebug(PM_CONFIGURE_PRINTER) << "CUPS_PRINTER_BW";
}
if (printer.type() & CUPS_PRINTER_COLOR) {
qCDebug(PM_CONFIGURE_PRINTER) << "CUPS_PRINTER_COLOR";
}
if (printer.type() & CUPS_PRINTER_MFP) {
qCDebug(PM_CONFIGURE_PRINTER) << "CUPS_PRINTER_MFP";
}
modifyPrinter->setRemote(isRemote);
modifyPrinter->setValues(printer);
page = new KPageWidgetItem(modifyPrinter, i18n("Modify Printer"));
page->setHeader(i18n("Configure"));
page->setIcon(QIcon::fromTheme("dialog-information"));
// CONNECT this signal ONLY to the first Page
connect(modifyPrinter, SIGNAL(changed(bool)), this, SLOT(enableButtonApply(bool)));
addPage(page);
if (!isClass) {
// At least on localhost:631 modify printer does not show printer options
// for classes
printerOptions = new PrinterOptions(destName, isClass, isRemote, this);
page = new KPageWidgetItem(printerOptions, i18n("Printer Options"));
page->setHeader(i18n("Set the Default Printer Options"));
page->setIcon(QIcon::fromTheme("view-pim-tasks"));
addPage(page);
connect(modifyPrinter, SIGNAL(ppdChanged()), this, SLOT(ppdChanged()));
modifyPrinter->setCurrentMake(printerOptions->currentMake());
modifyPrinter->setCurrentMakeAndModel(printerOptions->currentMakeAndModel());
}
printerBehavior->setRemote(isRemote);
printerBehavior->setValues(printer);
page = new KPageWidgetItem(printerBehavior, i18n("Banners, Policies and Allowed Users"));
page->setHeader(i18n("Banners, Policies and Allowed Users"));
page->setIcon(QIcon::fromTheme("feed-subscribe"));
addPage(page);
// connect this after ALL pages were added, otherwise the slot will be called
connect(this, SIGNAL(currentPageChanged(KPageWidgetItem*,KPageWidgetItem*)),
SLOT(currentPageChanged(KPageWidgetItem*,KPageWidgetItem*)));
KConfigGroup group(KSharedConfig::openConfig("print-manager"), "ConfigureDialog");
KWindowConfig::restoreWindowSize(windowHandle(), group);
connect(buttonBox(), SIGNAL(clicked(QAbstractButton*)), this, SLOT(slotButtonClicked(QAbstractButton*)));
}
QVariant KQuickConfig::getConfigEntry(const QString &key)
{
return m_config->group(group()).readEntry(key, defaults().value(key));
}
void HgPluginSettingsWidget::saveConfig()
{
KConfigGroup group(m_config, QLatin1String("diff"));
group.writeEntry(QLatin1String("exec"), m_diffProg->text());
group.config()->sync();
}
std::string FieldTrial::group_name()
{
group(); // call group() to make sure group assignment was done.
DCHECK(!group_name_.empty());
return group_name_;
}
bool run(const string& dbname, BSONObj& jsobj, int, string& errmsg, BSONObjBuilder& result, bool fromRepl ) {
if ( !globalScriptEngine ) {
errmsg = "server-side JavaScript execution is disabled";
return false;
}
/* db.$cmd.findOne( { group : <p> } ) */
const BSONObj& p = jsobj.firstElement().embeddedObjectUserCheck();
BSONObj q;
if ( p["cond"].type() == Object )
q = p["cond"].embeddedObject();
else if ( p["condition"].type() == Object )
q = p["condition"].embeddedObject();
else
q = getQuery( p );
if ( p["ns"].type() != String ) {
errmsg = "ns has to be set";
return false;
}
string ns = dbname + "." + p["ns"].String();
BSONObj key;
string keyf;
if ( p["key"].type() == Object ) {
key = p["key"].embeddedObjectUserCheck();
if ( ! p["$keyf"].eoo() ) {
errmsg = "can't have key and $keyf";
return false;
}
}
else if ( p["$keyf"].type() ) {
keyf = p["$keyf"]._asCode();
}
else {
// no key specified, will use entire object as key
}
BSONElement reduce = p["$reduce"];
if ( reduce.eoo() ) {
errmsg = "$reduce has to be set";
return false;
}
BSONElement initial = p["initial"];
if ( initial.type() != Object ) {
errmsg = "initial has to be an object";
return false;
}
string finalize;
if (p["finalize"].type())
finalize = p["finalize"]._asCode();
return group( dbname , ns , q ,
key , keyf , reduce._asCode() , reduce.type() != CodeWScope ? 0 : reduce.codeWScopeScopeDataUnsafe() ,
initial.embeddedObject() , finalize ,
errmsg , result );
}
void cb_points(const visualization_msgs::MarkerConstPtr& data)
{
bool success = false;
double x = data->pose.position.x;
double y = data->pose.position.y ;
double z = data->pose.position.z;
ROS_INFO("Points received! x: %f y: %f z: %f",x,y,z);
moveit::planning_interface::MoveGroup group("manipulator");
group.setPlanningTime(45.0);
group.setNumPlanningAttempts(10);
group.allowReplanning(true);
group.clearPathConstraints();
co.header.stamp = ros::Time::now();
co.header.frame_id = "base_link";
co.id = "testbox";
co.primitives.resize(1);
co.primitives[0].type = shape_msgs::SolidPrimitive::CYLINDER;
co.primitives[0].dimensions.resize(shape_tools::SolidPrimitiveDimCount<shape_msgs::SolidPrimitive::CYLINDER>::value);
co.primitives[0].dimensions[shape_msgs::SolidPrimitive::CYLINDER_RADIUS] = 0.04;
co.primitives[0].dimensions[shape_msgs::SolidPrimitive::CYLINDER_HEIGHT] = 0.14;
//co.primitives[0].dimensions[shape_msgs::SolidPrimitive::BOX_Z] = 0.14;
co.primitive_poses.resize(1);
co.primitive_poses[0].position.x = x;
co.primitive_poses[0].position.y = y;
co.primitive_poses[0].position.z = z;
co.primitive_poses[0].orientation.w = 1.0;
aco.object = co;
aco.link_name = "katana_gripper_tool_frame";
add_collision_object();
ros::WallDuration(5.0).sleep();
ROS_INFO("Generating Grasps");
std::vector<moveit_msgs::Grasp> grasps = generate_grasps(x, y, z);
success = group.pick("testbox",grasps);
if (success)
{
ROS_INFO("Pick was successful.");
}
else
{
ROS_FATAL("Pick failed.");
//return EXIT_FAILURE;
}
ros::WallDuration(3.0).sleep();
if(success)
{
std::vector<moveit_msgs::PlaceLocation> places = generate_places(x, -y, z);
success = group.place("testbox",places);
if (success)
{
ROS_INFO("Place was successful.");
geometry_msgs::PoseStamped po = group.getCurrentPose();
ROS_INFO("x: %f y: %f z: %f",po.pose.position.x,po.pose.position.y,po.pose.position.z);
ROS_INFO("w: %f, x: %f y: %f z: %f",po.pose.orientation.w, po.pose.orientation.x, po.pose.orientation.y, po.pose.orientation.z);
}
else
{
ROS_FATAL("Place failed.");
//return EXIT_FAILURE;
}
}
group.setStartState(*group.getCurrentState());
remove_collision_object();
group.setStartState(*group.getCurrentState());
group.setNamedTarget("home");
group.move();
geometry_msgs::PoseStamped po = group.getCurrentPose();
ROS_INFO("x: %f y: %f z: %f",po.pose.position.x,po.pose.position.y,po.pose.position.z);
ROS_INFO("w: %f, x: %f y: %f z: %f",po.pose.orientation.w, po.pose.orientation.x, po.pose.orientation.y, po.pose.orientation.z);
}
group __retrieve_nular_group(nular_function fnc_) {
return group(host::functions.invoke_raw_nular(fnc_));
}
template<typename... Args> static void group(Args&... args) { group({args...}); }
bool StandardContactList::load_old_dispatch(ParserState& state)
{
if(state.contactId != -1)
{
ContactPtr c = contact(state.contactId);
if(!c)
return false;
if(state.dataname.isEmpty())
{
c->deserialize(state.data);
}
else
{
if(state.dataname.indexOf('.') >= 0)
{
ClientPtr client = getClientManager()->client(state.dataname);
if(!client)
return false;
IMContactPtr imcontact = client->createIMContact();
imcontact->deserialize(state.data);
c->addClientContact(imcontact);
if(c->name().isEmpty())
c->setName(imcontact->name());
}
else if(!state.dataname.isEmpty())
{
deserializeLines(c->userdata(), state.dataname, state.data);
}
else
{
c->deserialize(state.data);
}
}
}
else if(state.groupId != -1)
{
GroupPtr gr = group(state.groupId);
if(!gr)
return false;
if(state.dataname.isEmpty())
{
gr->deserialize(state.data);
}
else
{
if(state.dataname.indexOf('.') >= 0)
{
ClientPtr client = getClientManager()->client(state.dataname);
if(!client)
return false;
IMGroupPtr imgroup = client->createIMGroup();
imgroup->deserialize(state.data);
gr->addClientGroup(imgroup);
}
else
{
deserializeLines(gr->userdata(), state.dataname, state.data);
}
}
}
return true;
}
void CTextInfoForm::DoFilterList(int level)
{
CString t;
Echo(_T("--------------------------------------------------"));
Echo(_T(" Filters"));
Echo(_T("--------------------------------------------------"));
for (int i=0; i<view->graph.filters.GetCount(); i++) {
GraphStudio::Filter *filter = view->graph.filters[i];
t.Format(_T("%3d. %s"), (i + 1), (LPCTSTR)filter->name);
Echo(t);
if (filter->file_name != _T("")) {
CString short_fn = PathFindFileName(filter->file_name);
t = _T(" File: ") + short_fn;
Echo(t);
}
if(level >= 0)
{
CString type;
switch (filter->filter_type) {
case GraphStudio::Filter::FILTER_DMO: type = _T("DMO"); break;
case GraphStudio::Filter::FILTER_WDM: type = _T("WDM"); break;
case GraphStudio::Filter::FILTER_STANDARD: type = _T("Standard"); break;
case GraphStudio::Filter::FILTER_UNKNOWN: type = _T("Unknown"); break;
}
if(type != _T(""))
{
t = _T(" Type: ") + type;
Echo(t);
}
if(filter->clsid_str != _T(""))
{
t = _T(" CLSID: ") + filter->clsid_str;
Echo(t);
}
if(level > 3)
{
GraphStudio::PropItem group(_T("Filter Details"));
GraphStudio::GetFilterDetails(*filter, &group);
for(int i=0;i<group.GetCount();i++)
{
if(group.GetItem(i)->name == _T("File"))
{
for(int j=0;j<group.GetItem(i)->GetCount();j++)
{
if(group.GetItem(i)->GetItem(j)->name == _T("File Name"))
{
t = _T(" File: ") + group.GetItem(i)->GetItem(j)->value;
Echo(t);
}
if(group.GetItem(i)->GetItem(j)->name == _T("File Path"))
{
t = _T(" Path: ") + group.GetItem(i)->GetItem(j)->value;
Echo(t);
}
else if(group.GetItem(i)->GetItem(j)->name == _T("Version Info"))
{
if(group.GetItem(i)->GetItem(j)->GetCount() > 0)
{
t = _T(" Version: ") + group.GetItem(i)->GetItem(j)->GetItem(0)->value;
Echo(t);
}
}
}
}
}
}
}
}
Echo(_T(""));
}
static void InitSystem(Config& config) {
unordered_map<string, string> parentMap; //child -> parent
unordered_map<string, vector<string>> childMap; //parent -> children (a parent may have multiple children, they are ordered by appearance in the file)
//If a network file is specificied, build a Network
string networkFile = config.get<const char*>("sys.networkFile", "");
Network* network = (networkFile != "")? new Network(networkFile.c_str()) : NULL;
//Build the caches
vector<const char*> cacheGroupNames;
config.subgroups("sys.caches", cacheGroupNames);
string prefix = "sys.caches.";
for (const char* grp : cacheGroupNames) {
string group(grp);
if (group == "mem") panic("'mem' is an invalid cache group name");
if (parentMap.count(group)) panic("Duplicate cache group %s", (prefix + group).c_str());
string parent = config.get<const char*>(prefix + group + ".parent");
parentMap[group] = parent;
if (!childMap.count(parent)) childMap[parent] = vector<string>();
childMap[parent].push_back(group);
}
//Check that all parents are valid: Either another cache, or "mem"
for (const char* grp : cacheGroupNames) {
string group(grp);
string parent = parentMap[group];
if (parent != "mem" && !parentMap.count(parent)) panic("%s has invalid parent %s", (prefix + group).c_str(), parent.c_str());
}
//Get the (single) LLC
if (!childMap.count("mem")) panic("One cache must have mem as parent, none found");
if (childMap["mem"].size() != 1) panic("One cache must have mem as parent, multiple found");
string llc = childMap["mem"][0];
//Build each of the groups, starting with the LLC
unordered_map<string, CacheGroup*> cMap;
list<string> fringe; //FIFO
fringe.push_back(llc);
while (!fringe.empty()) {
string group = fringe.front();
fringe.pop_front();
bool isTerminal = (childMap.count(group) == 0); //if no children, connected to cores
if (cMap.count(group)) panic("The cache 'tree' has a loop at %s", group.c_str());
cMap[group] = BuildCacheGroup(config, group, isTerminal);
if (!isTerminal) for (string child : childMap[group]) fringe.push_back(child);
}
//Check single LLC
if (cMap[llc]->size() != 1) panic("Last-level cache %s must have caches = 1, but %ld were specified", llc.c_str(), cMap[llc]->size());
/* Since we have checked for no loops, parent is mandatory, and all parents are checked valid,
* it follows that we have a fully connected tree finishing at the LLC.
*/
//Build the memory controllers
uint32_t memControllers = config.get<uint32_t>("sys.mem.controllers", 1);
assert(memControllers > 0);
g_vector<MemObject*> mems;
mems.resize(memControllers);
for (uint32_t i = 0; i < memControllers; i++) {
stringstream ss;
ss << "mem-" << i;
g_string name(ss.str().c_str());
//uint32_t domain = nextDomain(); //i*zinfo->numDomains/memControllers;
uint32_t domain = i*zinfo->numDomains/memControllers;
mems[i] = BuildMemoryController(config, zinfo->lineSize, zinfo->freqMHz, domain, name);
}
if (memControllers > 1) {
bool splitAddrs = config.get<bool>("sys.mem.splitAddrs", true);
if (splitAddrs) {
MemObject* splitter = new SplitAddrMemory(mems, "mem-splitter");
mems.resize(1);
mems[0] = splitter;
}
}
//Connect everything
// mem to llc is a bit special, only one llc
uint32_t childId = 0;
for (BaseCache* llcBank : (*cMap[llc])[0]) {
llcBank->setParents(childId++, mems, network);
}
// Rest of caches
for (const char* grp : cacheGroupNames) {
if (childMap.count(grp) == 0) continue; //skip terminal caches
CacheGroup& parentCaches = *cMap[grp];
uint32_t parents = parentCaches.size();
assert(parents);
//Concatenation of all child caches
CacheGroup childCaches;
for (string child : childMap[grp]) childCaches.insert(childCaches.end(), cMap[child]->begin(), cMap[child]->end());
uint32_t children = childCaches.size();
assert(children);
uint32_t childrenPerParent = children/parents;
if (children % parents != 0) {
panic("%s has %d caches and %d children, they are non-divisible. "
"Use multiple groups for non-homogeneous children per parent!", grp, parents, children);
}
//HACK FIXME: This solves the L1I+D-L2 connection bug, but it's not very clear.
//A long-term solution is to specify whether the children should be interleaved or concatenated.
bool terminalChildren = true;
for (string child : childMap[grp]) terminalChildren &= (childMap.count(child) == 0 || config.get<bool>("sys.caches." + child + ".isPrefetcher", false));
if (terminalChildren) {
info("%s's children are all terminal OR PREFETCHERS, interleaving them", grp);
CacheGroup tmp(childCaches);
uint32_t stride = children/childrenPerParent;
for (uint32_t i = 0; i < children; i++) childCaches[i] = tmp[(i % childrenPerParent)*stride + i/childrenPerParent];
}
for (uint32_t p = 0; p < parents; p++) {
g_vector<MemObject*> parentsVec;
parentsVec.insert(parentsVec.end(), parentCaches[p].begin(), parentCaches[p].end()); //BaseCache* to MemObject* is a safe cast
uint32_t childId = 0;
g_vector<BaseCache*> childrenVec;
for (uint32_t c = p*childrenPerParent; c < (p+1)*childrenPerParent; c++) {
for (BaseCache* bank : childCaches[c]) {
bank->setParents(childId++, parentsVec, network);
childrenVec.push_back(bank);
}
}
for (BaseCache* bank : parentCaches[p]) {
bank->setChildren(childrenVec, network);
}
}
}
//Check that all the terminal caches have a single bank
for (const char* grp : cacheGroupNames) {
if (childMap.count(grp) == 0) {
uint32_t banks = (*cMap[grp])[0].size();
if (banks != 1) panic("Terminal cache group %s needs to have a single bank, has %d", grp, banks);
}
}
//Tracks how many terminal caches have been allocated to cores
unordered_map<string, uint32_t> assignedCaches;
for (const char* grp : cacheGroupNames) if (childMap.count(grp) == 0) assignedCaches[grp] = 0;
//Instantiate the cores
vector<const char*> coreGroupNames;
unordered_map <string, vector<Core*>> coreMap;
config.subgroups("sys.cores", coreGroupNames);
uint32_t coreIdx = 0;
for (const char* group : coreGroupNames) {
if (parentMap.count(group)) panic("Core group name %s is invalid, a cache group already has that name", group);
coreMap[group] = vector<Core*>();
string prefix = string("sys.cores.") + group + ".";
uint32_t cores = config.get<uint32_t>(prefix + "cores", 1);
string type = config.get<const char*>(prefix + "type", "Simple");
//Build the core group
union {
SimpleCore* simpleCores;
TimingCore* timingCores;
OOOCore* oooCores;
NullCore* nullCores;
};
if (type == "Simple") {
simpleCores = gm_memalign<SimpleCore>(CACHE_LINE_BYTES, cores);
} else if (type == "Timing") {
timingCores = gm_memalign<TimingCore>(CACHE_LINE_BYTES, cores);
} else if (type == "OOO") {
oooCores = gm_memalign<OOOCore>(CACHE_LINE_BYTES, cores);
zinfo->oooDecode = true; //enable uop decoding, this is false by default, must be true if even one OOO cpu is in the system
} else if (type == "Null") {
nullCores = gm_memalign<NullCore>(CACHE_LINE_BYTES, cores);
} else {
panic("%s: Invalid core type %s", group, type.c_str());
}
if (type != "Null") {
string icache = config.get<const char*>(prefix + "icache");
string dcache = config.get<const char*>(prefix + "dcache");
if (!assignedCaches.count(icache)) panic("%s: Invalid icache parameter %s", group, icache.c_str());
if (!assignedCaches.count(dcache)) panic("%s: Invalid dcache parameter %s", group, dcache.c_str());
for (uint32_t j = 0; j < cores; j++) {
stringstream ss;
ss << group << "-" << j;
g_string name(ss.str().c_str());
Core* core;
//Get the caches
CacheGroup& igroup = *cMap[icache];
CacheGroup& dgroup = *cMap[dcache];
if (assignedCaches[icache] >= igroup.size()) {
panic("%s: icache group %s (%ld caches) is fully used, can't connect more cores to it", name.c_str(), icache.c_str(), igroup.size());
}
FilterCache* ic = dynamic_cast<FilterCache*>(igroup[assignedCaches[icache]][0]);
assert(ic);
ic->setSourceId(coreIdx);
ic->setFlags(MemReq::IFETCH | MemReq::NOEXCL);
assignedCaches[icache]++;
if (assignedCaches[dcache] >= dgroup.size()) {
panic("%s: dcache group %s (%ld caches) is fully used, can't connect more cores to it", name.c_str(), dcache.c_str(), dgroup.size());
}
FilterCache* dc = dynamic_cast<FilterCache*>(dgroup[assignedCaches[dcache]][0]);
assert(dc);
dc->setSourceId(coreIdx);
assignedCaches[dcache]++;
//Build the core
if (type == "Simple") {
core = new (&simpleCores[j]) SimpleCore(ic, dc, name);
} else if (type == "Timing") {
uint32_t domain = j*zinfo->numDomains/cores;
TimingCore* tcore = new (&timingCores[j]) TimingCore(ic, dc, domain, name);
zinfo->eventRecorders[coreIdx] = tcore->getEventRecorder();
zinfo->eventRecorders[coreIdx]->setSourceId(coreIdx);
core = tcore;
} else {
assert(type == "OOO");
OOOCore* ocore = new (&oooCores[j]) OOOCore(ic, dc, name);
zinfo->eventRecorders[coreIdx] = ocore->getEventRecorder();
zinfo->eventRecorders[coreIdx]->setSourceId(coreIdx);
core = ocore;
}
coreMap[group].push_back(core);
coreIdx++;
}
} else {
assert(type == "Null");
for (uint32_t j = 0; j < cores; j++) {
stringstream ss;
ss << group << "-" << j;
g_string name(ss.str().c_str());
Core* core = new (&nullCores[j]) NullCore(name);
coreMap[group].push_back(core);
coreIdx++;
}
}
}
//Check that all the terminal caches are fully connected
for (const char* grp : cacheGroupNames) {
if (childMap.count(grp) == 0 && assignedCaches[grp] != cMap[grp]->size()) {
panic("%s: Terminal cache group not fully connected, %ld caches, %d assigned", grp, cMap[grp]->size(), assignedCaches[grp]);
}
}
//Populate global core info
assert(zinfo->numCores == coreIdx);
zinfo->cores = gm_memalign<Core*>(CACHE_LINE_BYTES, zinfo->numCores);
coreIdx = 0;
for (const char* group : coreGroupNames) for (Core* core : coreMap[group]) zinfo->cores[coreIdx++] = core;
//Init stats: cores, caches, mem
for (const char* group : coreGroupNames) {
AggregateStat* groupStat = new AggregateStat(true);
groupStat->init(gm_strdup(group), "Core stats");
for (Core* core : coreMap[group]) core->initStats(groupStat);
zinfo->rootStat->append(groupStat);
}
for (const char* group : cacheGroupNames) {
AggregateStat* groupStat = new AggregateStat(true);
groupStat->init(gm_strdup(group), "Cache stats");
for (vector<BaseCache*>& banks : *cMap[group]) for (BaseCache* bank : banks) bank->initStats(groupStat);
zinfo->rootStat->append(groupStat);
}
//Initialize event recorders
//for (uint32_t i = 0; i < zinfo->numCores; i++) eventRecorders[i] = new EventRecorder();
AggregateStat* memStat = new AggregateStat(true);
memStat->init("mem", "Memory controller stats");
for (auto mem : mems) mem->initStats(memStat);
zinfo->rootStat->append(memStat);
//Odds and ends: BuildCacheGroup new'd the cache groups, we need to delete them
for (pair<string, CacheGroup*> kv : cMap) delete kv.second;
cMap.clear();
info("Initialized system");
}
io_state_stream const & operator<<(io_state_stream const & out, expr const & e) {
options const & opts = out.get_options();
out.get_stream() << mk_pair(group(out.get_formatter()(e)), opts);
return out;
}
KisView2::KisView2(KisPart2 *part, KisDoc2 * doc, QWidget * parent)
: KoView(part, doc, parent),
m_d(new KisView2Private())
{
setXMLFile("krita.rc");
setFocusPolicy(Qt::NoFocus);
if (mainWindow()) {
mainWindow()->setDockNestingEnabled(true);
actionCollection()->addAction(KStandardAction::KeyBindings, "keybindings", mainWindow()->guiFactory(), SLOT(configureShortcuts()));
}
m_d->doc = doc;
m_d->part = part;
m_d->viewConverter = new KisCoordinatesConverter();
KisCanvasController *canvasController = new KisCanvasController(this, actionCollection());
canvasController->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
canvasController->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
canvasController->setDrawShadow(false);
canvasController->setCanvasMode(KoCanvasController::Infinite);
KisConfig cfg;
canvasController->setZoomWithWheel(cfg.zoomWithWheel());
canvasController->setVastScrolling(cfg.vastScrolling());
m_d->canvasController = canvasController;
m_d->resourceProvider = new KisCanvasResourceProvider(this);
m_d->resourceProvider->resetDisplayProfile(QApplication::desktop()->screenNumber(this));
KConfigGroup grp(KGlobal::config(), "krita/crashprevention");
if (grp.readEntry("CreatingCanvas", false)) {
KisConfig cfg;
cfg.setUseOpenGL(false);
}
grp.writeEntry("CreatingCanvas", true);
m_d->canvas = new KisCanvas2(m_d->viewConverter, this, doc->shapeController());
grp.writeEntry("CreatingCanvas", false);
connect(m_d->resourceProvider, SIGNAL(sigDisplayProfileChanged(const KoColorProfile*)), m_d->canvas, SLOT(slotSetDisplayProfile(const KoColorProfile*)));
m_d->canvasController->setCanvas(m_d->canvas);
m_d->resourceProvider->setResourceManager(m_d->canvas->resourceManager());
createManagers();
createActions();
m_d->controlFrame = new KisControlFrame(this);
Q_ASSERT(m_d->canvasController);
KoToolManager::instance()->addController(m_d->canvasController);
KoToolManager::instance()->registerTools(actionCollection(), m_d->canvasController);
// krita/krita.rc must also be modified to add actions to the menu entries
m_d->saveIncremental = new KAction(i18n("Save Incremental &Version"), this);
m_d->saveIncremental->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::Key_S));
actionCollection()->addAction("save_incremental_version", m_d->saveIncremental);
connect(m_d->saveIncremental, SIGNAL(triggered()), this, SLOT(slotSaveIncremental()));
m_d->saveIncrementalBackup = new KAction(i18n("Save Incremental Backup"), this);
m_d->saveIncrementalBackup->setShortcut(Qt::Key_F4);
actionCollection()->addAction("save_incremental_backup", m_d->saveIncrementalBackup);
connect(m_d->saveIncrementalBackup, SIGNAL(triggered()), this, SLOT(slotSaveIncrementalBackup()));
connect(shell(), SIGNAL(documentSaved()), this, SLOT(slotDocumentSaved()));
if (koDocument()->localFilePath().isNull()) {
m_d->saveIncremental->setEnabled(false);
m_d->saveIncrementalBackup->setEnabled(false);
}
m_d->totalRefresh = new KAction(i18n("Total Refresh"), this);
actionCollection()->addAction("total_refresh", m_d->totalRefresh);
m_d->totalRefresh->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_R));
connect(m_d->totalRefresh, SIGNAL(triggered()), this, SLOT(slotTotalRefresh()));
m_d->createTemplate = new KAction( i18n( "&Create Template From Image..." ), this);
actionCollection()->addAction("createTemplate", m_d->createTemplate);
connect(m_d->createTemplate, SIGNAL(triggered()), this, SLOT(slotCreateTemplate()));
m_d->mirrorCanvas = new KToggleAction(i18n("Mirror View"), this);
m_d->mirrorCanvas->setChecked(false);
actionCollection()->addAction("mirror_canvas", m_d->mirrorCanvas);
m_d->mirrorCanvas->setShortcut(QKeySequence(Qt::Key_M));
connect(m_d->mirrorCanvas, SIGNAL(toggled(bool)),m_d->canvasController, SLOT(mirrorCanvas(bool)));
KAction *rotateCanvasRight = new KAction(i18n("Rotate Canvas Right"), this);
actionCollection()->addAction("rotate_canvas_right", rotateCanvasRight);
rotateCanvasRight->setShortcut(QKeySequence("Ctrl+]"));
connect(rotateCanvasRight, SIGNAL(triggered()),m_d->canvasController, SLOT(rotateCanvasRight15()));
KAction *rotateCanvasLeft = new KAction(i18n("Rotate Canvas Left"), this);
actionCollection()->addAction("rotate_canvas_left", rotateCanvasLeft);
rotateCanvasLeft->setShortcut(QKeySequence("Ctrl+["));
connect(rotateCanvasLeft, SIGNAL(triggered()),m_d->canvasController, SLOT(rotateCanvasLeft15()));
KAction *resetCanvasTransformations = new KAction(i18n("Reset Canvas Transformations"), this);
actionCollection()->addAction("reset_canvas_transformations", resetCanvasTransformations);
resetCanvasTransformations->setShortcut(QKeySequence("Ctrl+'"));
connect(resetCanvasTransformations, SIGNAL(triggered()),m_d->canvasController, SLOT(resetCanvasTransformations()));
KToggleAction *tAction = new KToggleAction(i18n("Show Status Bar"), this);
tAction->setCheckedState(KGuiItem(i18n("Hide Status Bar")));
tAction->setChecked(true);
tAction->setToolTip(i18n("Shows or hides the status bar"));
actionCollection()->addAction("showStatusBar", tAction);
connect(tAction, SIGNAL(toggled(bool)), this, SLOT(showStatusBar(bool)));
tAction = new KToggleAction(i18n("Show Canvas Only"), this);
tAction->setCheckedState(KGuiItem(i18n("Return to Window")));
tAction->setToolTip(i18n("Shows just the canvas or the whole window"));
QList<QKeySequence> shortcuts;
shortcuts << QKeySequence(Qt::Key_Tab);
tAction->setShortcuts(shortcuts);
tAction->setChecked(false);
actionCollection()->addAction("view_show_just_the_canvas", tAction);
connect(tAction, SIGNAL(toggled(bool)), this, SLOT(showJustTheCanvas(bool)));
//Workaround, by default has the same shortcut as mirrorCanvas
KAction* action = dynamic_cast<KAction*>(actionCollection()->action("format_italic"));
if (action) {
action->setShortcut(QKeySequence(), KAction::DefaultShortcut);
action->setShortcut(QKeySequence(), KAction::ActiveShortcut);
}
//Workaround, by default has the same shortcut as hide/show dockers
action = dynamic_cast<KAction*>(shell()->actionCollection()->action("view_toggledockers"));
if (action) {
action->setShortcut(QKeySequence(), KAction::DefaultShortcut);
action->setShortcut(QKeySequence(), KAction::ActiveShortcut);
}
if (shell())
{
KoToolBoxFactory toolBoxFactory(m_d->canvasController);
shell()->createDockWidget(&toolBoxFactory);
connect(canvasController, SIGNAL(toolOptionWidgetsChanged(QList<QWidget*>)),
shell()->dockerManager(), SLOT(newOptionWidgets(QList<QWidget*>)));
shell()->dockerManager()->setIcons(false);
}
m_d->statusBar = new KisStatusBar(this);
connect(m_d->canvasController->proxyObject, SIGNAL(documentMousePositionChanged(QPointF)),
m_d->statusBar, SLOT(documentMousePositionChanged(QPointF)));
connect(m_d->nodeManager, SIGNAL(sigNodeActivated(KisNodeSP)),
m_d->resourceProvider, SLOT(slotNodeActivated(KisNodeSP)));
connect(m_d->nodeManager, SIGNAL(sigNodeActivated(KisNodeSP)),
m_d->controlFrame->paintopBox(), SLOT(slotCurrentNodeChanged(KisNodeSP)));
connect(m_d->nodeManager, SIGNAL(sigNodeActivated(KisNodeSP)),
m_d->doc->image(), SLOT(requestStrokeEnd()));
connect(KoToolManager::instance(), SIGNAL(inputDeviceChanged(KoInputDevice)),
m_d->controlFrame->paintopBox(), SLOT(slotInputDeviceChanged(KoInputDevice)));
connect(KoToolManager::instance(), SIGNAL(changedTool(KoCanvasController*,int)),
m_d->controlFrame->paintopBox(), SLOT(slotToolChanged(KoCanvasController*,int)));
// 25 px is a distance that works well for Tablet and Mouse events
qApp->setStartDragDistance(25);
show();
loadPlugins();
// Wait for the async image to have loaded
connect(m_d->doc, SIGNAL(sigLoadingFinished()), this, SLOT(slotLoadingFinished()));
if (!m_d->doc->isLoading() || m_d->doc->image()) {
slotLoadingFinished();
}
connect(m_d->canvasController, SIGNAL(documentSizeChanged()), m_d->zoomManager, SLOT(slotScrollAreaSizeChanged()));
setAcceptDrops(true);
KConfigGroup group(KGlobal::config(), "krita/shortcuts");
foreach(KActionCollection *collection, KActionCollection::allCollections()) {
collection->setConfigGroup("krita/shortcuts");
collection->readSettings(&group);
}
template<typename... Args> static void group(Args&&... args) { group({std::forward<Args>(args)...}); }
void KgArchives::disableNonExistingPackers()
{
KConfigGroup group(krConfig, "Archives");
group.writeEntry("Supported Packers", KRarcHandler::supportedPackers());
}