return;

}

m_temp = new KTempFile;

int handle = m_temp->handle();

TQString backtraceCommand = m_krashconf->backtraceCommand();

const char* bt = backtraceCommand.latin1();

// write the debugger command

m_temp_cmd = new KTempFile(TQString::null, TQString::null, 0700);

handle = m_temp_cmd->handle();

const char* dbgcommand = str.latin1();

::write(handle, dbgcommand, strlen(dbgcommand)); // the command to execute the debugger

m_proctrace(0)

{

TQVBoxLayout *vbox = new TQVBoxLayout( this, 0, KDialog::marginHint() );

m_backtrace = new KTextBrowser(this);

m_backtrace->setTextFormat(TQt::PlainText);

*childproc << "-maxdepth" << "1";

if (!cmbFiles->currentText().isEmpty() )

{

*childproc << "(";

bool first = true;

for ( TQStringList::Iterator it = files.begin(); it != files.end(); ++it )

}

/*

* with multiWallpaperMode and FileName (it needs to be a XML)

*/

void KCrossBGRender::fixEnabled(){

time.setHMS( hour->value(), minute->value(), second->value() );

kclock->setTime( time );

}

void Dtime::changeDate(TQDate d)

{

date = d;

}

void Dtime::configChanged(){

}

void Dtime::load()

// get current time

time = TQTime::currentTime();

second->setValue(time.second());

minute->setValue(time.minute());

hour->setValue(time.hour());

kclock->setTime( time );

}

void zoneChanged(bool);

protected slots:

private:

void currentZone();

" prompted for a name.") );

removeBt = new TQPushButton(i18n("R&emove Scheme"), group);

connect(removeBt, TQ_SIGNAL(clicked()), TQ_SLOT(slotRemove()));

TQWhatsThis::add( removeBt, i18n("Press this button to remove the selected"

// Inactive window

&brush);

paint.setBrush( iaTitle );

// Active window

&brush);

paint.setBrush( aTitle );paint.setPen( aTitle );

// Menu bar

tdeApp->style().drawPrimitive(TQStyle::PE_PanelMenuBar, &paint,

TQRect(TQPoint(25, 55), TQSize(width()-52, 28)), cg);

paint.setPen(txt );

TQString file = i18n("File");

textLen = paint.fontMetrics().width( file );

tdeApp->style().drawPrimitive(TQStyle::PE_Panel, &paint,

TQRect(30, 59, textLen + 10, 21), cg);

paint.drawText( 35, 74, file );

brush.setColor( window );

qDrawShadePanel ( &paint, 25, 80+5-4, width()-7-45-2,

// Standard text

TQFont fnt = TDEGlobalSettings::generalFont();

// Valance

qDrawWinPanel ( &paint, 0, 0, width(), height(),

// Stop the painting

hotspots[ spot++ ] =

HotSpot( TQRect( 0, 0, width(), height() ), CSM_Background ); // ?

}

}

void KDisplayConfig::activatePreview() {

}

void KDisplayConfig::load()

void KDisplayConfig::activateProfile() {

if (getuid() != 0) {

}

else {

}

rescanHardware();

}

for ( i = 0; i < int(monitors.count()); ++i ) {

if (::tqt_cast<DraggableMonitor*>(monitors.at( i ))) {

TQWidget *monitor = static_cast<TQWidget*>(monitors.at( i ));

Q_ASSERT("zombie monitor will not go away!");

}

}

screendata->gamma_green = ((float)base->gammaAllSlider->value())/10.0;

screendata->gamma_blue = ((float)base->gammaAllSlider->value())/10.0;

base->gammaAllSlider->blockSignals(false);

base->gammaRedSlider->blockSignals(false);

screendata->gamma_red = ((float)index)/10.0;

gammaSetAverageAllSlider();

setGammaLabels();

base->gammaAllSlider->blockSignals(false);

base->gammaRedSlider->blockSignals(false);

screendata->gamma_green = ((float)index)/10.0;

gammaSetAverageAllSlider();

setGammaLabels();

base->gammaAllSlider->blockSignals(false);

base->gammaRedSlider->blockSignals(false);

screendata->gamma_blue = ((float)index)/10.0;

gammaSetAverageAllSlider();

setGammaLabels();

base->gammaAllSlider->blockSignals(false);

base->gammaRedSlider->blockSignals(false);

void KDisplayConfig::save()

{

saveActiveSystemWideProfileToDisk();

updateProfileConfigObjectFromGrid();

// Signal that settings were NOT applied

TQTimer *t = new TQTimer( this );

connect(t, TQ_SIGNAL(timeout()), TQ_SLOT(changed()) );

}

}

void FilterOptions::configChanged()

{

emit changed(true);

}

};

was filled into the lBox-Widget.

returning false indicates, that information was not available.

*/

/*

* information was not available.

*/

#define INFO_CD_ROM_AVAILABLE

was filled into the lBox-Widget.

returning false indicates, that information was not available.

*/

while (index >= 0)

{

if (index >= 0) {

index += passwd.length();

while (index < (int) str.length() &&

/*

* information was not available.

*/

lBox->addColumn(i18n("IRQ"));

lBox->addColumn(i18n("Device"));

lBox->setSorting(0);

(void) GetDmesgInfo(lBox, "[ (]irq ", AddIRQLine);

return true;

}

/*

* information was not available.

*/

#define INFO_XSERVER_AVAILABLE

/*

* information was not available.

*/

#define INFO_XSERVER_AVAILABLE

was filled into the lBox-Widget.

returning false indicates, that information was not available.

*/

if ( mouseCapabilityFlags & HAS_RES ) {

updateResolution();

connect( button400cpi, TQ_SIGNAL( clicked() ), parent, TQ_SLOT( changed() ) );

connect( button800cpi, TQ_SIGNAL( clicked() ), parent, TQ_SLOT( changed() ) );

if ( 4 == resolution() ) {

} else if ( 3 == resolution() ) {

} else {

// it must have failed, try to help out

permissionProblemText->show();

}

}

// Do a name

cordlessNameLabel->setText( i18n("Mouse type: %1").arg( cordlessName() ) );

// Display the battery power level - the level gets updated in updateGUI()

// Channel

// if the channel is changed, we need to turn off the timer, otherwise it

// just resets the button to reflect the current status. The timer is

// started again when we applyChanges()

connect( channel1, TQ_SIGNAL( clicked() ), this, TQ_SLOT( stopTimerForNow() ) );

connect( channel1, TQ_SIGNAL( clicked() ), parent, TQ_SLOT( changed() ) );

if ( isDualChannelCapable() ) {

connect( channel2, TQ_SIGNAL( clicked() ), this, TQ_SLOT( stopTimerForNow() ) );

connect( channel2, TQ_SIGNAL( clicked() ), parent, TQ_SLOT( changed() ) );

}

if (0 > result) {

// We probably have a permission problem

cordlessNameLabel->hide();

permissionProblemText->show();

} else {

if ( isDualChannelCapable() ) {

if ( 2 == channel() ) {

} else if ( 1 == channel() ) {

} // else it might have failed - we don't do anything

}

}

TQWhatsThis::add(addBt, i18n("Click here to add a new key bindings scheme. You will be prompted for a name."));

removeBt = new TQPushButton( i18n("&Remove Scheme"), this );

connect( removeBt, TQ_SIGNAL( clicked() ), TQ_SLOT( slotRemove() ) );

TQWhatsThis::add( removeBt, i18n("Click here to remove the selected key bindings scheme. You can not"

" remove the standard system wide schemes, 'Current scheme' and 'TDE default'.") );

do {

if ( ss.exec() ) {

sName = ss.nameLine->text();

}

} else return;

disconnect( sList, TQ_SIGNAL( highlighted( int ) ), this,

TQ_SLOT( slotPreviewScheme( int ) ) );

if ( indx < nSysSchemes ||

(*sFileList->at(indx)).contains( "/global-" ) ||

(*sFileList->at(indx)).contains( "/app-" ) ) {

} else {

}

}*/

if (it->mimeType().startsWith("media/builtin-") == false)

it->setVisible(enabled);

else

}

}

continue;

}

TQString mime = desc[0].stripWhiteSpace();

TQString name = desc[2];

TQString suffixes = desc[1];

m_locale(locale)

{

TQGridLayout *lay = new TQGridLayout(this, 5, 2);

// Whatever the color scheme is, we want black text

TQColorGroup a = palette().active();

TQGridLayout *lay = new TQGridLayout(this, 5, 2,

KDialog::marginHint(),

KDialog::spacingHint());

m_labDecSym = new TQLabel(this, I18N_NOOP("&Decimal symbol:"));

m_edDecSym = new TQLineEdit(this);

TQGridLayout *lay = new TQGridLayout(this, 7, 2,

KDialog::marginHint(),

KDialog::spacingHint());

m_labCalendarSystem = new TQLabel(this, I18N_NOOP("Calendar system:"));

m_comboCalendarSystem = new TQComboBox(false, this);

m_locale = new TDELocale(TQString::fromLatin1("kcmlocale"), m_nullConfig);

TQVBoxLayout *l = new TQVBoxLayout(this, 0, KDialog::spacingHint());

m_tab = new TQTabWidget(this);

bool KRandRApp::x11EventFilter(XEvent* e)

{

if (e->type == m_tray->screenChangeNotifyEvent()) {

}

return TDEApplication::x11EventFilter( e );

}

profileName = "";

}

TQPtrList<SingleScreenData> profileData = loadDisplayConfiguration(profileName, locateLocal("config", "/", true));

destroyScreenInformationObject(profileData);

}

logFileName.setURL("/var/log/samba.log");

viewHistory.setFocusPolicy(TQWidget::ClickFocus);

viewHistory.setShowSortIndicator(true);

" If the list is empty, try clicking the \"Update\" button. The samba"

" log file will be read and the list refreshed.") );

connect(&updateButton,TQ_SIGNAL(clicked()),this,TQ_SLOT(updateList()));

emit contentsChanged(&viewHistory,0,0);

configFile->setGroup(LOGGROUPNAME);

logFileName.setURL(configFile->readPathEntry( "SambaLogFile", "/var/log/samba.log"));

}

void LogView::saveSettings()

expandedInfoCb = new TQCheckBox( i18n( "Show expanded service info" ), this );

expandedUserCb = new TQCheckBox( i18n( "Show expanded host info" ), this );

viewStatistics->setFocusPolicy(TQWidget::ClickFocus);

viewStatistics->setShowSortIndicator(true);

eventCb->insertItem(i18n("Connection"));

eventCb->insertItem(i18n("File Access"));

clearStatistics();

serviceLe->setText("*");

hostLe->setText("*");

if ((expandedInfoCb->isChecked()) || (expandedUserCb->isChecked()))

{

SambaLog sLog;

TQString item2, item3;

TQListViewItem* item=dataList->firstChild();

while (item!=0)

{

calcCount++;

int count(0);

TQListViewItem* item=dataList->firstChild();

while (item!=0)

{

LogItem():name(""), accessed(),count(0) {};

LogItem(TQString n, TQString a):name(n), accessed(), count(1)

{

accessed.append(new SmallLogItem(a));

};

TQString name;

public:

SambaLog()

{

};

TQPtrList<LogItem> items;

void addItem (TQString share, TQString host);

grabMouse();

grabKeyboard();

mPreviewProc->kill();

while (!ts.atEnd())

"",

"signalReaderListChanged(TQStringList)",

"loadReadersTab(TQStringList)",

kdDebug()<<"Error connecting to DCOP server" <<endl;

"",

"signalCardStateChanged(TQString,bool,TQString)",

"updateReadersState (TQString,bool,TQString) ",

kdDebug()<<"Error connecting to DCOP server" <<endl;

_cardDB= new KCardDB();

type,

subType,

subSubType);

}

else{

TDEListViewItem * hil =new TDEListViewItem(ant,

i18n("No module managing this card"));

}

}

spellConfig->setNoRootAffix(0);

spellConfig->setRunTogether(0);

spellConfig->setDictionary("");

spellConfig->setEncoding (KS_E_UTF8);

spellConfig->setClient (KS_CLIENT_ISPELL);

}

hbLayout = new TQHBoxLayout( KDialog::spacingHint(), "hbLayout" );

cbStyle = new KComboBox( gbWidgetStyle, "cbStyle" );

hbLayout->addWidget( cbStyle );

pbConfigStyle = new TQPushButton( i18n("Con&figure..."), gbWidgetStyle );

pbConfigStyle->setSizePolicy( TQSizePolicy::Maximum, TQSizePolicy::Minimum );

hbLayout->addWidget( pbConfigStyle );

gbWidgetStyleLayout->addLayout( hbLayout );

containerLayout = new TQGridLayout( containerFrame, 1, 1, // rows, columns

KDialog::marginHint(), KDialog::spacingHint() );

comboComboEffect->insertItem( i18n("Disable") );

comboComboEffect->insertItem( i18n("Animate") );

lblComboEffect = new TQLabel( i18n("Combobo&x effect:"), containerFrame );

containerLayout->addWidget( lblComboEffect, 0, 0 );

containerLayout->addWidget( comboComboEffect, 0, 1 );

comboTooltipEffect->insertItem( i18n("Disable") );

comboTooltipEffect->insertItem( i18n("Animate") );

comboTooltipEffect->insertItem( i18n("Fade") );

containerLayout->addWidget( lblTooltipEffect, 1, 0 );

containerLayout->addWidget( comboTooltipEffect, 1, 1 );

comboRubberbandEffect->insertItem( i18n("Disable") );

comboRubberbandEffect->insertItem( i18n("Make translucent") );

lblRubberbandEffect = new TQLabel( i18n("&Rubberband effect:"), containerFrame );

containerLayout->addWidget( lblRubberbandEffect, 2, 0 );

containerLayout->addWidget( comboRubberbandEffect, 2, 1 );

comboMenuEffect->insertItem( i18n("Disable") );

comboMenuEffect->insertItem( i18n("Animate") );

comboMenuEffect->insertItem( i18n("Fade") );

containerLayout->addWidget( lblMenuEffect, 3, 0 );

containerLayout->addWidget( comboMenuEffect, 3, 1 );

comboMenuHandle->insertItem( i18n("Disable") );

comboMenuHandle->insertItem( i18n("Application Level") );

// comboMenuHandle->insertItem( i18n("Enable") );

menuPreview = new MenuPreview( menuContainer, /* opacity */ 90, MenuPreview::Blend );

comboMenuEffectType->insertItem( i18n("Software Tint") );

comboMenuEffectType->insertItem( i18n("Software Blend") );

#ifdef HAVE_XRENDER

TQHBoxLayout* box2 = new TQHBoxLayout( dummy, 0, KDialog::spacingHint() );

lbl = new TQLabel( i18n("Text pos&ition:"), dummy );

comboToolbarIcons->insertItem( i18n("Icons Only") );

comboToolbarIcons->insertItem( i18n("Text Only") );

comboToolbarIcons->insertItem( i18n("Text Alongside Icons") );

if ( cbStyle->text(i) == name )

{

combobox_item = i;

}

}

}

case TQEvent::Leave:

case TQEvent::Wheel:

case TQEvent::ContextMenu:

default:

break;

}

}

TQFile configFile(locateLocal("config", m_configFileName));

if (!configFile.exists())

{

TDEConfig localConfig(m_configFileName);

globalConfig.copyTo(m_configFileName, &localConfig);

localConfig.sync();

void TaskbarConfig::slotReloadConfigurationFromGlobals()

{

TDEConfig localConfig(m_configFileName);

globalConfig.copyTo(m_configFileName, &localConfig);

localConfig.sync();

TQGroupBox *group0 = new TQGroupBox( i18n("Allow Shutdown"), this );

sdllabel = new TQLabel (sdlcombo, i18n ("&Local:"), group0);

sdlcombo->insertItem(i18n("Everybody"), SdAll);

sdlcombo->insertItem(i18n("Only Root"), SdRoot);

sdlcombo->insertItem(i18n("Nobody"), SdNone);

connect(sdlcombo, TQ_SIGNAL(activated(int)), TQ_SLOT(changed()));

sdrlabel = new TQLabel (sdrcombo, i18n ("&Remote:"), group0);

sdrcombo->insertItem(i18n("Everybody"), SdAll);

sdrcombo->insertItem(i18n("Only Root"), SdRoot);

mainView->lv->header()->setStretchEnabled(true, 0);

// mainView->lv->addColumn(i18n("Interface"));

// mainView->lv->addColumn(i18n("Function"));

connect(mainView->lv, TQ_SIGNAL(doubleClicked(TQListViewItem *)), TQ_SLOT(slotCallFunction(TQListViewItem *)));

connect(mainView->lv, TQ_SIGNAL(currentChanged(TQListViewItem *)), TQ_SLOT(slotCurrentChanged(TQListViewItem *)));

connect(mainView->lb_replyData, TQ_SIGNAL(contextMenuRequested(TQListBoxItem*, const TQPoint&)),

}

}

if ( needRepaint ) {

saveIconPositions();

}

if (area.isNull()) area = iconArea();

// If the proposed item rect is not contained by the desktop, by definition the item position is not free!

return false;

}

if (area.isNull()) area = iconArea();

// If the proposed item rect is not contained by the desktop, by definition the item position is not free!

return false;

}

extern TQCString kdesktop_name, kicker_name, twin_name;

{

s_rootWm = this;

m_actionCollection = new TDEActionCollection(_desktop, this, "KRootWm::m_actionCollection");

extern TQXLibWindowList trinity_desktop_lock_hidden_window_list;

#define ENABLE_CONTINUOUS_LOCKDLG_DISPLAY \

mHackDelayStartupTimer->stop();

#define DISABLE_CONTINUOUS_LOCKDLG_DISPLAY \

mForceContinualLockDisplayTimer->stop(); \

mHackDelayStartupTimer->stop();

//===========================================================================

bool LockProcess::closeCurrentWindow()

{

if (currentDialog != NULL) {

mForceReject = true;

if (dynamic_cast<SAKDlg*>(currentDialog)) {

}

if( mDialogs.isEmpty() ) {

mForceReject = false;

return false;

}

else {

return true;

}

}

}

if (trinity_desktop_lock_delay_screensaver_start && trinity_desktop_lock_forced && trinity_desktop_lock_use_system_modal_dialogs) {

ENABLE_CONTINUOUS_LOCKDLG_DISPLAY

}

else {

if (mHackStartupEnabled == true) {

else {

if (trinity_desktop_lock_use_system_modal_dialogs == true) {

ENABLE_CONTINUOUS_LOCKDLG_DISPLAY

}

else {

startHack();

// Handle remaining case (switch user)

if (forcecontdisp) {

ENABLE_CONTINUOUS_LOCKDLG_DISPLAY

}

stopSaver();

}

resizeTimer = new TQTimer( this );

connect( resizeTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(doDesktopResizeFinish()) );

}

}

void LockProcess::doDesktopResizeFinish()

// Restart the hack as the window size is now different

if (trinity_desktop_lock_delay_screensaver_start && trinity_desktop_lock_use_system_modal_dialogs) {

ENABLE_CONTINUOUS_LOCKDLG_DISPLAY

}

else {

if (mHackStartupEnabled == true) {

else {

if (trinity_desktop_lock_use_system_modal_dialogs == true) {

ENABLE_CONTINUOUS_LOCKDLG_DISPLAY

}

else {

startHack();

}

}

if (trinity_desktop_lock_delay_screensaver_start && trinity_desktop_lock_forced && trinity_desktop_lock_use_system_modal_dialogs) {

ENABLE_CONTINUOUS_LOCKDLG_DISPLAY

}

else {

if (mHackStartupEnabled || mOverrideHackStartupEnabled) {

else {

if (trinity_desktop_lock_use_system_modal_dialogs == true) {

ENABLE_CONTINUOUS_LOCKDLG_DISPLAY

}

else {

startHack();

// Make sure saver will attempt to start again after DPMS wakeup

// This is related to Bug 1475

ENABLE_CONTINUOUS_LOCKDLG_DISPLAY

// Should not start saver here, because the DPMS check method below would turn it right back off!

// This is related to Bug 1475

return;

bool LockProcess::startHack()

{

if ((mEnsureVRootWindowSecurityTimer) && (!mEnsureVRootWindowSecurityTimer->isActive())) {

}

if (currentDialog || (!mDialogs.isEmpty())) {

}

if (trinity_desktop_lock_use_system_modal_dialogs) {

ENABLE_CONTINUOUS_LOCKDLG_DISPLAY

}

saverReadyIfNeeded();

}

}

setCursor( TQt::arrowCursor );

}

//---------------------------------------------------------------------------

{

// Hack exited while we're supposed to be saving the screen.

// Make sure the saver window is black.

usleep(100);

TQApplication::syncX();

if (!trinity_desktop_lock_use_system_modal_dialogs) {

if (!mSuspended) {

if (trinity_desktop_lock_use_system_modal_dialogs) {

ENABLE_CONTINUOUS_LOCKDLG_DISPLAY

}

}

saverReadyIfNeeded();

stopHack();

ENABLE_CONTINUOUS_LOCKDLG_DISPLAY

if (mHackStartupEnabled) {

}

}

else {

}

hackstat[8191] = 0;

hackStatus = hackstat;

TQStringList hackStatusList = TQStringList::split(" ", hackStatus);

hackStatus = (*(hackStatusList.at(1)));

}

connect( hackResumeTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(resumeUnforced()) );

}

if (mResizingDesktopLock == false) {

}

}

else {

// fall through

case KeyPress:

if ((mHackDelayStartupTimer) && (mHackDelayStartupTimer->isActive())) {

}

if (mBusy || !mDialogs.isEmpty()) {

break;

if (mLocked) {

ENABLE_CONTINUOUS_LOCKDLG_DISPLAY

if (mHackStartupEnabled) {

}

}

if ((!mLocked) && (!mInSecureDialog)) {

else {

if (trinity_desktop_lock_use_system_modal_dialogs == true) {

ENABLE_CONTINUOUS_LOCKDLG_DISPLAY

}

else {

resume( false );

}

// Clicked inside dialog; set focus

WId window = mDialogs.first()->winId();

XSetInputFocus(tqt_xdisplay(), window, RevertToParent, CurrentTime);

fakeFocusIn(window);

}

// Clicked inside window handle (or border); drag window

TQPoint oldPoint = mDialogs.first()->pos();

m_mouseDown = 1;

m_dialogPrevX = oldPoint.x();

// Drag the window...

if (event->type == MotionNotify) {

int deltaX = me->x_root - m_mousePrevX;

int deltaY = me->y_root - m_mousePrevY;

m_dialogPrevX = m_dialogPrevX + deltaX;

TQXLibWindowList trinity_desktop_lock_hidden_window_list;

// [FIXME] Add GUI configuration checkboxes for these three settings (see kdesktoprc [ScreenSaver] UseUnmanagedLockWindows, DelaySaverStart, and UseTDESAK)

LockProcess* trinity_desktop_lock_process = NULL;

bool signalled_securedialog;

bool signalled_blank;

bool signalled_run;

pid_t kdesktop_pid = -1;

static void sigusr1_handler(int)

{

}

static void sigusr2_handler(int)

{

}

static void sigusr3_handler(int)

{

}

static void sigusr4_handler(int)

{

}

static void sigusr5_handler(int)

{

}

static int trapXErrors(Display *, XErrorEvent *)

sigfillset(&new_mask);

sigprocmask(SIG_BLOCK, &new_mask, NULL);

int kdesktop_screen_number = 0;

int starting_screen = 0;

kdesktop_pid = atoi(args->getOption( "internal" ));

struct sigaction act;

// handle SIGUSR1

act.sa_handler= sigusr1_handler;

sigaddset(&new_mask,SIGTTIN);

sigaddset(&new_mask,SIGTTOU);

// let kdesktop know the saver process is ready

if (kill(kdesktop_pid, SIGTTIN) < 0) {

// The controlling kdesktop process probably died. Commit suicide...

// wait for SIGUSR1, SIGUSR2, SIGWINCH, SIGTTIN, or SIGTTOU

sigprocmask(SIG_BLOCK, &new_mask, &orig_mask);

sigsuspend(&orig_mask);

}

sigprocmask(SIG_UNBLOCK, &new_mask, NULL);

delete tdmconfig;

}

if (!child) {

trinity_desktop_lock_process->setChildren(child_sockets);

}

}

bool rt;

rt = trinity_desktop_lock_process->lock();

}

rt = trinity_desktop_lock_process->dontLock();

}

int retcode = tde_sak_verify_calling_process();

if (retcode == 0) {

rt = trinity_desktop_lock_process->runSecureDialog();

return 0;

}

trinity_desktop_lock_hidden_window_list.clear();

int ret = app->exec();

restore_hidden_override_redirect_windows();

#include "xautolock_c.h"

extern xautolock_corner_t xautolock_corners[ 4 ];

SaverEngine* m_masterSaverEngine = NULL;

static void sigusr1_handler(int)

}

mLockProcess << path;

mLockProcess << TQString( "--internal" ) << TQString( "%1" ).arg(getpid());

{

kdDebug( 1204 ) << "Failed to start kdesktop_lock!" << endl;

}

}

int retcode = mSAKProcess->exitStatus();

if ((retcode != 0) && (mSAKProcess->normalExit())) {

printf("[kdesktop] SAK driven secure dialog is not available for use (retcode %d). Check tdmtsak for proper functionality.\n", retcode); fflush(stdout);

}

return;

}

bool ok = true;

if (mState == Waiting)

{

}

mLockProcess << path;

mLockProcess << TQString( "--internal" ) << TQString( "%1" ).arg(getpid());

kdDebug( 1204 ) << "Failed to start kdesktop_lock!" << endl;

return false;

}

void SaverEngine::lockProcessExited()

{

bool abnormalExit = false;

abnormalExit = true;

}

else {

abnormalExit = true;

}

}

abnormalExit = false;

mTerminationRequested = false;

}

// PROBABLE HACKING ATTEMPT DETECTED

restartDesktopLockProcess();

mState = Waiting;

void SaverEngine::lockProcessWaiting()

{

kdDebug(1204) << "SaverEngine: lock exited" << endl;

handleSecureDialog();

}

if( mState == Waiting ) {

int textX;

if (drawRoundedRect == true)

else

int align = ((TDEIconView *) iconView())->itemTextPos() == TQIconView::Bottom

? AlignHCenter : AlignAuto;

// FIXME

TQPainter pixPainter;

int spread = shadowThickness();

textPixmap.fill(TQColor(0,0,0));

pixPainter.begin(&textPixmap);

pixPainter.setPen(white); // get the pen from the root painter

static int directCommand(TDECmdLineArgs *args)

{

TQString title;

bool printWId = args->isSet("print-winid");

bool embed = args->isSet("embed") || args->isSet("attach");

TQString defaultEntry;

// --separate-output

if (args->isSet("separate-output"))

{

}

if (printWId || embed)

{

TQTimer *timer = new TQTimer();

TQObject::connect( timer, TQ_SIGNAL( timeout() ), tdeApp, TQ_SLOT( quit() ) );

TQObject::connect( popup, TQ_SIGNAL( clicked() ), tdeApp, TQ_SLOT( quit() ) );

#ifdef TQ_WS_X11

if ( ! tdeApp->geometryArgument().isEmpty()) {

int Widgets::textBox(TQWidget *parent, int width, int height, const TQString& title, const TQString& file)

{

KDialogBase dlg( parent, 0, true, title, KDialogBase::Ok, KDialogBase::Ok );

tdeApp->setTopWidget( &dlg );

KTextEdit *edit = new KTextEdit( dlg.makeVBoxMainWidget() );

TQFile f(file);

if (!f.open(IO_ReadOnly))

int Widgets::textInputBox(TQWidget *parent, int width, int height, const TQString& title, const TQStringList& args, TQCString &result)

{

KDialogBase dlg( parent, 0, true, title, KDialogBase::Ok, KDialogBase::Ok );

tdeApp->setTopWidget( &dlg );

}

KTextEdit *edit = new KTextEdit( vbox );

edit->setTextFormat( TQt::PlainText );

edit->setFocus();

}

table.insertStringList(entries);

table.setCurrentItem(0); // This is to circumvent a Qt bug

for (unsigned int i=0; i+2<args.count(); i += 3) {

#include "kdatecombo.moc"

{

TQDate date = TQDate::currentDate();

initObject(date, parent, name);

}

{

initObject(date, parent, name);

}

if (count())

clear();

insertItem(date2String(newDate));

}

}

void KDateCombo::dateEnteredEvent(TQDate newDate)

pages[0] = new TQWidget( this, "page1" );

nameBox->setSizePolicy(TQSizePolicy::Preferred, TQSizePolicy::Fixed); // allow smaller than widest entry

TQLabel * namedL = new TQLabel(nameBox, i18n("&Named:"), pages[0], "named");

TQToolTip::add( namedL, i18n("You can use wildcard matching and \";\" for separating multiple names") );

dirBox->setSizePolicy(TQSizePolicy::Preferred, TQSizePolicy::Fixed); // allow smaller than widest entry

TQLabel * lookinL = new TQLabel(dirBox, i18n("Look &in:"), pages[0], "named");

subdirsCb = new TQCheckBox(i18n("Include &subfolders"), pages[0]);

if(TDEStandardDirs::findExe("locate")==NULL)

useLocateCb->setEnabled(false);

nameBox->setFocus();

nameBox->setInsertionPolicy(TQComboBox::AtTop);

dirBox->setInsertionPolicy(TQComboBox::AtTop);

rb[0] = new TQRadioButton(i18n("&between"), pages[1] );

rb[1] = new TQRadioButton(i18n("&during the previous"), pages[1] );

TQLabel * andL = new TQLabel(i18n("and"), pages[1], "and");

betweenType->insertItem(i18n("minute(s)"));

betweenType->insertItem(i18n("hour(s)"));

betweenType->insertItem(i18n("day(s)"));

toDate = new KDateCombo(pages[1], "toDate");

timeBox = new TQSpinBox(1, 60, 1, pages[1], "timeBox");

TQLabel * sizeL =new TQLabel(sizeBox,i18n("File &size is:"), pages[1],"size");

sizeEdit=new TQSpinBox(0, INT_MAX, 1, pages[1], "sizeEdit" );

sizeEdit->setValue(1);

m_usernameBox = new KComboBox( true, pages[1], "m_combo1");

TQLabel *usernameLabel= new TQLabel(m_usernameBox,i18n("Files owned by &user:"),pages[1]);

int tmp = sizeEdit->fontMetrics().width(" 000000000 ");

sizeEdit->setMinimumSize(tmp, sizeEdit->sizeHint().height());

m_usernameBox->setInsertionPolicy(TQComboBox::AtTop);

m_groupBox->setInsertionPolicy(TQComboBox::AtTop);

pages[2] = new TQWidget( this, "page3" );

typeBox->setSizePolicy(TQSizePolicy::Preferred, TQSizePolicy::Fixed); // allow smaller than widest entry

TQLabel * typeL =new TQLabel(typeBox, i18n("File &type:"), pages[2], "type");

textEdit=new KLineEdit(pages[2], "textEdit" );

bool KfindTabWidget::isDateValid()

{

// All files

if (rb[1]->isChecked())

{

KMessageBox::sorry(this, i18n("Unable to search within a period that is less than a minute."));

}

// If we can not parse either of the dates or

TQDate hi1, hi2;

TQString str;

if (!str.isNull()) {

KMessageBox::sorry(0, str);

}

}

void KfindTabWidget::setQuery(KQuery *query)

/// dirlister->openURL(KURL(dirBox->currentText().stripWhiteSpace()));

saveHistory();

}

void KfindTabWidget::endSearch()

{

}

/*

// and second radio group on page two

if(! findCreated->isChecked()) {

for(i=0; i<2; i++)

}

else {

for(i=0; i<2; i++)

fromDate->setEnabled(rb[0]->isChecked());

toDate->setEnabled(rb[0]->isChecked());

,m_menu(0)

{

setSelectionMode( TQListView::Extended );

addColumn(i18n("Name"));

addColumn(i18n("In Subfolder"));

TQRegExp *regExp;

TQRegExp sep(";");

TQStringList strList=TQStringList::split( sep, regexp, false);

m_regexps.clear();

// m_regexpsContainsGlobs.clear();

if (_force || newStr != _timeStr)

{

_timeStr = newStr;

display(_timeStr);

update();

}

// but other colors would break the lcd-lock anyway

void DigitalClock::drawContents( TQPainter * p)

{

TQPalette pal = palette();

if (_prefs->digitalLCDStyle())

pal.setColor( TQColorGroup::Foreground, TQColor(128,128,128));

pal.setColor( TQColorGroup::Foreground, _prefs->digitalForegroundColor());

setPalette( pal );

p->translate( -2, -2 );

TQLCDNumber::drawContents( p );

p->translate( +1, +1 );

}

}

if (_qurl->kurl().url() == "SPECIAL_BUTTON__SHOW_DESKTOP") {

if (isOn()) {

}

else {

}

}

else {

: PanelServiceMenu(TQString::null, TQString::null, 0, "KMenu")

, bookmarkMenu(0)

, bookmarkOwner(0)

{

static const TQCString dcopObjId("KMenu");

DCOPObject::setObjId(dcopObjId);

TQTimer *windowtimer = new TQTimer( this );

connect( windowtimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(windowClearTimeout()) );

windowTimerTimedOut = false;

while (windowTimerTimedOut == false)

tdeApp->eventLoop()->processEvents(TQEventLoop::ExcludeUserInput, 1000);

TQTimer *delaytimer = new TQTimer( this );

connect( delaytimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(windowClearTimeout()) );

windowTimerTimedOut = false;

while (windowTimerTimedOut == false)

tdeApp->eventLoop()->processEvents(TQEventLoop::ExcludeUserInput, 1000);

}

insertTearOffHandle();

#endif

}

setInitialized(true);

// Now do a nasty hack to prevent search bar merging into the side image

// This forces a layout/repaint of the qpopupmenu

repaint(); // This ensures that the side bar image was applied

update(); // This repaints the entire popup menu to apply the widget size/alignment changes made above

}

}

if (input_timer->isActive ())

input_timer->stop ();

}

bool KMenu::dontQueryNow (const TQString& str)

return (mimetype_iconstore [hit_item->mimetype]);

else {

KMimeType::Ptr mimetype_ptr = KMimeType::mimeType (hit_item->mimetype);

mimetype_iconstore [hit_item->mimetype] = mimetype_icon;

return mimetype_icon;

}

return;

}

m_changeCursorOverItem = TDEGlobalSettings::changeCursorOverIcon();

else

if (m_changeCursorOverItem)

{

void PanelButton::enterEvent(TQEvent* e)

{

{

m_highlight = true;

repaint(false);

style().drawPrimitive(TQStyle::PE_ButtonBevel, p, btn_rect, colorGroup(), TQStyle::Style_Raised);

}

if (hasFocus() || m_hasAcceptedDrag)

{

void PanelButton::drawButtonLabel(TQPainter *p)

{

}

void PanelButton::drawButtonLabel(TQPainter *p, int voffset, bool drawArrow)

* @param parent the parent widget

* @param name the widget's name

*/

/**

* Configures this button according to the user's preferences for

* @param parent the parent widget

* @param name the widget's name

*/

/**

* Sets the button's popup menu.

{

TQRect r(0, 0, width(), height());

if (m_highlight || isDown() || isOn()) {

int flags = TQStyle::Style_Default | TQStyle::Style_Enabled;

if (isDown() || isOn()) flags |= TQStyle::Style_Down;

TQPixmap pix = isEnabled() ? ((m_highlight&&(!m_disableHighlighting))? m_activeIcon : m_normalIcon) : m_disabledIcon;

{

pix = TQImage(pix.convertToImage()).smoothScale(pix.width() - 2,

pix.height() - 2);

}

pix = TQImage(pix.convertToImage()).smoothScale(pix.width() - 4,

pix.height() - 4);

}

}

bool changeCursor;

changeCursor = TDEGlobalSettings::changeCursorOverIcon();

else

if (changeCursor)

{

TQ_OBJECT

public:

void setPixmap(const TQPixmap &pix);

void setOrientation(TQt::Orientation orientaton);

TQSize sizeHint() const;

TQ_OBJECT

public:

virtual ~SimpleArrowButton() {};

TQSize sizeHint() const;

TQFile configFileObject(locateLocal("config", configFile));

if (!configFileObject.exists())

{

TDEConfig localConfig(configFile);

globalConfig.copyTo(configFile, &localConfig);

localConfig.sync();

}

settingsObject = new TaskBarSettings(TDESharedConfig::openConfig(configFile));

TQByteArray statRaw = procStatFile.readAll();

procStatFile.close();

TQString statString(statRaw);

TQString tcomm = statFields[1];

TQString state = statFields[2];

if( state == "T" ) {

insertSeparator();

if (taskMoveMenu) {

insertItem(i18n("Move Task Button"), taskMoveMenu);

insertSeparator();

enable = false;

if (taskMoveMenu) {

insertItem(i18n("Move Task Button"), taskMoveMenu);

insertSeparator();

// changing the clipboard at the same time.

bSavedSelectionMode = selectionMode;

bCheckForEmpty = true;

return;

}

// changing the clipboard at the same time.

bSavedSelectionMode = !selectionMode; // inverted in order to sync

bCheckForEmpty = false;

}

}

file.left( file.findRev( '/' )) +

TQString::fromLatin1("/\">\n");

TQRegExp reg("<head>");

res.replace(reg, "<head>\n\t" + basehref);

return res;

}

p.fillRect( re.right() - pix.width() - 3 , re.y(), pix.width() + 4, re.height(),

TQBrush( useColor ? color : edit->paletteBackgroundColor() ));

p.drawPixmap( re.right() - pix.width() -1 , re.y() + ( re.height() - pix.height() ) / 2, pix );

}

else {

TQRect r = edit->geometry();

virtual void printFrameInfo( const TQString& spaces );

virtual void reparentFrame( TQWidget* parent,

virtual KonqFrameContainerBase* parentContainer() { return m_pParentContainer; }

virtual void setParentContainer(KonqFrameContainerBase* parent) { m_pParentContainer = parent; }

virtual void setTabIcon( const KURL &url, TQWidget* sender );

virtual void reparentFrame(TQWidget * parent,

//virtual KonqFrameContainerBase* parentContainer();

virtual TQWidget* widget() { return this; }

virtual TQCString frameType() { return TQCString("ContainerBase"); }

virtual void reparentFrame(TQWidget * parent,

virtual KonqFrameBase* activeChild() { return m_pActiveChild; }

//inherited

virtual void reparentFrame(TQWidget * parent,

//make this one public

int idAfter( TQWidget* w ){ return TQSplitter::idAfter( w ); }

// happens only with the hackish non-_NET_WM_STATE_FULLSCREEN way

setWFlags( WDestructiveClose );

// Qt bug (see below)

topData()->dnd = 0;

}

else

{

// Qt bug, the flags aren't restored. They know about it.

setWFlags( WType_TopLevel | WDestructiveClose );

// Other Qt bug

topData()->dnd = 0;

}

}

void printFrameInfo( const TQString &spaces );

void reparentFrame( TQWidget* parent,

KonqFrameContainerBase* parentContainer()const;

void setParentContainer(KonqFrameContainerBase* parent);

//inherited

virtual void reparentFrame(TQWidget * parent,

void moveTabBackward(int index);

void moveTabForward(int index);

for (KonqBaseListViewWidget::iterator it = m_pListView->begin(); it != m_pListView->end(); it++ )

{

if ((m_pListView->automaticSelection()) && (it->isSelected())) {

//the following line is to prevent that more than one item were selected

//and now get deselected and automaticSelection() was true, this shouldn't happen

//but who knows, aleXXX

}

if ( it->isVisible() ) {

if ( re.exactMatch( it->text(0) ) ) {

}

}

else {

}

}

m_pListView->blockSignals( false );

if ( !ok )

return;

for (KonqBaseListViewWidget::iterator it = m_pListView->begin(); it != m_pListView->end(); it++ ) {

if ( it->isVisible() ) {

if ( re.exactMatch( it->text(0) ) ) {

}

}

else {

}

}

m_pListView->deactivateAutomaticSelection();

emit m_pListView->selectionChanged();

m_pListView->viewport()->update();

void KonqListView::slotSelectAll()

{

m_pListView->deactivateAutomaticSelection();

emit m_pListView->selectionChanged();

}

void KonqListView::slotUnselectAll()

{

m_pListView->deactivateAutomaticSelection();

emit m_pListView->selectionChanged();

}

if ((m_pListView->automaticSelection())

&& (m_pListView->currentItem()!=0)

&& (m_pListView->currentItem()->isSelected()))

m_pListView->invertSelection();

m_pListView->deactivateAutomaticSelection();

if (nameOfSortColumn!=m_pListView->sortedByColumn)

{

m_pListView->sortedByColumn=nameOfSortColumn;

}

else

{

TQRect r( m_rubber->normalize() );

delete m_rubber;

m_rubber = 0;

}

delete m_selected;

TQRect r( m_rubber->normalize() );

delete m_rubber;

m_rubber = 0;

}

if ( m_scrollTimer ) {

TQRect rr;

TQRect nr = m_rubber->normalize();

if ( cur )

{

{

setSelected( cur, true );

setActiveMultiSelectItem( at );

rr = rr.unite( itemRect( cur ) );

}

}

{

if ( cur->isSelected() )

{

rr = rr.unite( itemRect( cur ) );

}

{

setSelected( cur, true );

setActiveMultiSelectItem( at );

rr = rr.unite( itemRect( cur ) );

}

}

{

if ( cur->isSelected() )

{

rr = rr.unite( itemRect( cur ) );

}

// I know, but I want to have it this way and I use it all the time.

// If I want to have free space, I disable some columns.

// If people don't like it, they can use a different view type. Alex

setRootIsDecorated(false);

colors[KTVI_REGULAR]=TQt::black;

colors[KTVI_CHARDEV]=TQt::blue;

colors[KTVI_BLOCKDEV]=TQt::blue;

}

KonqTextViewWidget::~KonqTextViewWidget()

if (m_fileItem->isLink())

{

TQFont f( _painter->font() );

_painter->setFont( f );

}

TQListViewItem::paintCell( _painter, _cg, _column, _width, _alignment );

m_bgPixmap = 0L;

m_bgDirty=true;

m_grabWindows=false;

setBackgroundMode(NoBackground);

if (m_desk==1) Desktop::m_windowPixmaps.setAutoDelete(true);

id = m_dmnu->insertItem( TQString("&")+TQString::number(i )+TQString(" ")

+ m_winmodule->desktopName(i), i );

if ( m_winfo.desktop() == i )

}

}

char *tmp=data.data();

sscanf(tmp,"%lu %d %d %d", &w, &deltax, &deltay, &origdesk);

e->accept();

}

}

case TQEvent::Leave:

case TQEvent::Wheel:

case TQEvent::ContextMenu:

default:

break;

}

}

TQObject* mainWin = new KRootBacking();

TQTimer *timer = new TQTimer( mainWin );

TQObject::connect( timer, TQ_SIGNAL(timeout()), mainWin, TQ_SLOT(start()) );

app.exec();

kdDebug( 1218 ) << " We killed all clients. We have now clients.count()=" << clients.count() << endl;

completeKilling();

}

void KSMServer::completeKilling()

{

// Activity detected; reset forcible shutdown timer...

if (shutdownTimer.isActive()) {

}

SHUTDOWN_MARKER("completeKilling");

kdDebug( 1218 ) << "KSMServer::completeKilling clients.count()=" << clients.count() << endl;

m_currentY( 0 ),

m_grayOpacity( 0.0f ),

m_compensation( 0.0f ),

m_unfadedImage(),

m_grayImage(),

m_fadeTime(),

m_pmio(),

{

if (tdeApp->isX11CompositionAvailable()) {

void KSMShutdownFeedback::fadeBack( void )

{

m_fadeTime.restart();

// its possible that we have to fade back, before all is completely gray, so we cannot start

// with completely gray when fading back...

m_compensation = 1.0f - m_grayOpacity;

// if slotPaintEffect() is called first time, we have to initialize the gray image

// we also could do that in the constructor, but then the displaying of the

// logout-UI would be too much delayed...

{

m_greyImageCreated = true;

}

// return if fading is completely done...

return;

{

m_grayOpacity = m_fadeTime.elapsed() / doFancyLogoutFadeTime;

if ( m_grayOpacity > 1.0f )

if( y2 > imgHeight )

y2 = imgHeight;

{

if( y1 > 0 && y1 < imgHeight && y1-m_rowsDone > 0 && m_rowsDone < imgHeight )

{

// if slotPaintEffect() is called first time, we have to initialize the gray image

// we also could do that in the constructor, but then the displaying of the

// logout-UI would be too much delayed...

{

m_greyImageCreated = true;

}

// return if fading is completely done...

return;

{

m_grayOpacity = m_fadeTime.elapsed() / doFancyLogoutFadeTime;

if ( m_grayOpacity > 1.0f )

if( y2 > imgHeight )

y2 = imgHeight;

{

if( y1 > 0 && y1 < imgHeight && y1-m_rowsDone > 0 && m_rowsDone < imgHeight )

{

// The end effect will be very similar to the old style logout

float doFancyLogoutFadeTime = 1000;

float doFancyLogoutFadeBackTime = 0;

m_greyImageCreated = true;

// eliminate nasty flicker on first show

}

// return if fading is completely done...

return;

}

m_grayOpacity = m_fadeTime.elapsed() / doFancyLogoutFadeTime;

if ( m_grayOpacity > 1.0f )

m_grayOpacity = 1.0f;

y2 = imgHeight;

}

{

if( y1 > 0 && y1 < imgHeight && y1-m_rowsDone > 0 && m_rowsDone < imgHeight )

{

KSMShutdownDlg::KSMShutdownDlg( TQWidget* parent,

bool maysd, bool mayrb, TDEApplication::ShutdownType sdtype, int* selection )

// this is a WType_Popup on purpose. Do not change that! Not

// having a popup here has severe side effects.

case Key_Enter:

case Key_Return:

case Key_Space:

setDown(true);

emit pressed();

break;

if ( m_pressed )

{

setDown(false);

emit released();

emit clicked();

}

case Key_Enter:

case Key_Return:

case Key_Space:

setDown(true);

emit pressed();

break;

if ( m_pressed )

{

setDown(false);

emit released();

emit clicked();

}

#include <kdebug.h>

// shall we show a nice fancy login screen?

/*! Restores the previous session. Ensures the window manager is

running (if specified).

config->readEntry( TQString("userId")+n ));

lastIdStarted = config->readEntry( TQString("clientId")+n );

if ( !lastIdStarted.isEmpty() ) {

return; // we get called again from the clientRegistered handler

}

}

if (startupNotifierIPDlg) {

static_cast<KSMStartupIPDlg*>(startupNotifierIPDlg)->setStartupPhase(msg);

if (msg == TQString("session ready")) {

}

}

DCOPRef( "ksplash" ).send( "upAndRunning", msg );

{

TQ_OBJECT

public:

~SplashInstaller();

virtual void load();

mLabel->setPaletteForegroundColor( mLabelForeground );

mLabel->setPaletteBackgroundPixmap( blimage );

TQFont f(mLabel->font());

mLabel->setFont(f);

mProgressBar = new KProgress( mLabel );

mCurrentAction = mActionList.first();

config->setGroup( "General" );

mThemeEngine->installEventFilter( this );

connect( mThemeEngine, TQ_SIGNAL(destroyed()), this, TQ_SLOT(close()) );

{

close_timer = new TQTimer( this );

connect( close_timer, TQ_SIGNAL( timeout() ), this, TQ_SLOT( close() ) );

}

}

firstTime = false;

}

if ( close_timer->isActive() )

if( s == "dcop" )

{

if ( ( e->type() == TQEvent::MouseButtonRelease ) && ( o == mThemeEngine ) )

{

TQTimer::singleShot( 0, this, TQ_SLOT(close()));

}

else

}

unsigned long length, after;

unsigned char *data;

int r = XGetWindowProperty( tqt_xdisplay(), winid, tqt_wm_state, 0, 2,

&length, &after, &data );

if ( r == Success && data && format == 32 ) {

TQ_UINT32 *wstate = (TQ_UINT32*)data;

withdrawn = (*wstate == WithdrawnState );

/**

* The udpate function can be used to update the displayed process

* list. A current list of processes is requested from the OS. In

* returned.

*/

bool update(const TQString& list);

widget->listLayoutsSrc->setColumnWidth(LAYOUT_COLUMN_FLAG, 28);

widget->listLayoutsDst->setColumnWidth(LAYOUT_COLUMN_FLAG, 28);

// widget->listLayoutsDst->setColumnWidth(LAYOUT_COLUMN_DISPLAY_NAME, 0);

widget->listLayoutsDst->setSorting(-1);

TQMemArray<TQRect> rects = r.rects();

TQMemArray<TQRect>::Iterator it = rects.begin();

for (; it != rects.end(); ++it)

{

TQRect rect = *it;

/**

* Constructor

*/

virtual ~KonqIconViewWidget();

/**

* Called when entering a directory

* Checks for a .directory, read it.

* Don't do this on the default properties instance

* different from the settings in the old directory.

*/

bool enterDir( const KURL & dir );

m_iconTransparency = DEFAULT_TEXTPREVIEW_ICONTRANSPARENCY;

// Behaviour

m_homeURL = config->readPathEntry("HomeURL", "~");

/*if ( ( ( KonqIconViewWidget* ) iconView() )->m_pActiveItem == this )

{

TQFont f( p->font() );

p->setFont( f );

}*/

if ( m_fileitem->isLink() )

{

TQFont f( p->font() );

p->setFont( f );

}

}

/** You are not supposed to call this on a KFileIVI, from the outside,

* it bypasses the icons cache */

virtual void setPixmap ( const TQPixmap & icon ) { TDEIconViewItem::setPixmap( icon ); }

{ TDEIconViewItem::setPixmap( icon, recalc, redraw ); }

/** Check if a thumbnail will be generated and calc the size of the icon */

continue;

}

TQString mime = desc[0].stripWhiteSpace();

TQStringList suffixes = TQStringList::split(',', desc[1].stripWhiteSpace());

if (!mime.isEmpty())

}

// write into type cache

TQStringList::Iterator token;

token = tokens.begin();

cache << (*token).lower();

{

// mark for destruction

_trash.append( inst );

}

/****************************************************************************/

// stream into temporary file (use lower() in case the

// filename as an upper case X in it)

_tempFile = new KTempFile;

_fileURL = _tempFile->name();

kdDebug() << "saving into " << _fileURL << endl;

}

queue( data );

if ( !pump() ) {

_job->suspend();

}

}

_job->resume();

} else {

kdDebug(1431) << "restart timer" << endl;

}

}

{

// redeliver the event to Xt, NOT through Qt

if ( static_d->dispatchers[ event->type ]( event ) )

}

QXtEventLoopPrivate::QXtEventLoopPrivate()

: appContext(NULL), ownContext(NULL),

{

}

case EnterNotify:

case LeaveNotify:

event->xcrossing.focus = False;

break;

case XKeyPress:

case XKeyRelease:

break;

case XFocusIn:

case XFocusOut:

break;

default:

break;

}

}

*/

void qmotif_timeout_handler( XtPointer, XtIntervalId * )

{

static_d->timerid = 0;

}

if ( d->activate_timers ) {

nevents += activateTimers();

}

return ( (flags & WaitForMore) || ( pendingmask != 0 ) || nevents > 0 );

}

#if defined(CHECK_RANGE)

tqWarning( "TQSocketNotifier: Internal error" );

#endif

}

XtPointer inpMask = 0;

case TQSocketNotifier::Read: inpMask = (XtPointer)XtInputReadMask; break;

case TQSocketNotifier::Write: inpMask = (XtPointer)XtInputWriteMask; break;

case TQSocketNotifier::Exception: inpMask = (XtPointer)XtInputExceptMask; break;

}

if (enable) {

while ( sn && !(sn->obj == obj && sn->fd == sockfd) )

sn = _notifiers[type].next();

if ( !sn ) // not found

XtRemoveInput( sn->id );

_notifiers[type].remove();

}

}

#endif

if (g!=NULL && f>c && (g-f)<12 && (isalnum(f[-1]) || f[-1]=='>' || ( f[-1] == ';' ) ) &&

isdigit(f[1]) && f[1]!='0' && ((g-f)<=2 || isalpha(f[2])))

{

h = f+2;

while (h<g)

{

if (!isalnum(*h++))

{

break;

}

}

#else /* !_USE_QSORT */

QManIndexList manpages;

#endif /* _USE_QSORT */

TQString device = "camera:/";

TQString devNode0 = devNodeList[devNodeList.count()-2];

TQString devNode1 = devNodeList[devNodeList.count()-1];

}

if (diskLabel.isEmpty()) {

// Try to use a pretty mount point if possible

TQString node = pieces[pieces.count()-1];

diskLabel = medium->label() + " (" + node + ")";

diskLabel.replace("/", "_");

connectDCOPSignal( "kded", "mediamanager", "mediumRemoved(TQString, bool)",

"onMediumRemove(TQString, bool)", true );

m_freeTimer = new TQTimer( this );

connect( m_freeTimer, TQ_SIGNAL( timeout() ), TQ_SLOT( checkFreeDiskSpace() ) );

m_freeTimer->start( 1000*6*2 /* 20 minutes */ );

bool isWritable = action!=0L && action->isWritable();

m_view->deleteButton->setEnabled( isWritable );

m_view->editButton->setEnabled( isWritable );

m_view->toggleAutoButton->setEnabled( action!=0L && !m_mimetype.isEmpty() );

}

static bool isAbsoluteLink(const TQString& path)

{

//hmm, don't know

}

static void createVirtualDirEntry(UDSEntry & entry)

}

NFSFileHandle::NFSFileHandle()

{

memset(m_handle,'\0',NFS_FHSIZE+1);

// m_detectTime=time(0);

}

NFSFileHandle::NFSFileHandle(const NFSFileHandle & handle)

{

m_handle[NFS_FHSIZE]='\0';

memcpy(m_handle,handle.m_handle,NFS_FHSIZE);

{

if (src==0)

{

return *this;

};

memcpy(m_handle,src,NFS_FHSIZE);

// m_detectTime=time(0);

return *this;

}

if (!checkForError(clnt_stat, 0, m_currentHost.latin1())) return;

fhstatus fhStatus;

for(; exportlist!=0;exportlist = exportlist->ex_next) {

kdDebug(7121) << "found export: " << exportlist->ex_dir << endl;

clnt_stat = clnt_call(m_client, MOUNTPROC_MNT,(xdrproc_t) xdr_dirpath, (char*)(&(exportlist->ex_dir)),

(xdrproc_t) xdr_fhstatus,(char*) &fhStatus,total_timeout);

if (fhStatus.fhs_status==0) {

NFSFileHandle fh;

fh=fhStatus.fhstatus_u.fhs_fhandle;

TQString fname;

kdDebug(7121)<<"rpc error: "<<clientStat<<endl;

//does this mapping make sense ?

error(ERR_CONNECTION_BROKEN,i18n("An RPC error occurred."));

}

if (nfsStat!=NFS_OK)

{

error(ERR_UNKNOWN,text);

break;

}

}

}

void NFSProtocol::del( const KURL& url, bool isfile)

bool NFSProtocol::isValidLink(const TQString& parentDir, const TQString& linkDest)

{

kdDebug(7121)<<"isValidLink: parent: "<<parentDir<<" link: "<<linkDest<<endl;

if (isAbsoluteLink(linkDest))

{

kdDebug(7121)<<"is an absolute link"<<endl;

absDest=TQDir::cleanDirPath(absDest);

kdDebug(7121)<<"simplified to "<<absDest<<endl;

if (absDest.find("../")==0)

kdDebug(7121)<<"is inside the nfs tree"<<endl;

absDest=parentDir+"/"+linkDest;

NFSFileHandle fh=getFileHandle(absDest);

return (!fh.isInvalid());

}

}

NFSFileHandle& operator= (const char* src);

operator const char* () const {return m_handle;}

bool isInvalid() const {return m_isInvalid;}

// time_t age() const;

protected:

char m_handle[NFS_FHSIZE+1];

SocketSecurity::SocketSecurity(int sockfd)

{

if (!warned_him) {

kdWarning() << "Using void socket security. Please add support for your" << endl;

kdWarning() << "platform to tdesu/tdesud/secure.cpp" << endl;

}

// This passes the test made in handler.cpp

vbox->addWidget( host_view );

iline = new TQLineEdit( this );

TQLabel *itxt = new TQLabel( iline, i18n("Hos&t:"), this );

TQPushButton *addButton = new TQPushButton( i18n("A&dd"), this );

connect( addButton, TQ_SIGNAL(clicked()), TQ_SLOT(addHostname()) );

bool argb_visual_available = false;

bool has_twin = false;

bool is_themed = false;

TQPoint primaryScreenPosition;

static int

#define FIFO_FILE "/tmp/tdesocket-global/tdm/tdmctl-%1"

#define FIFO_SAK_FILE "/tmp/tdesocket-global/tdm/tdmctl-sak-%1"

extern bool trinity_desktop_lock_use_sak;

//===========================================================================

//TDEConfig *config = tdeApp->config();

//config->setGroup( "Option" );

//config->setGroup( "Font" );

mFont.setFamily( TQString::fromLatin1("Utopia")/*config->readEntry( "Family", "Utopia")*/ );

mFont.setPointSize( 51/*config->readNumEntry( "Point Size", 51)*/ );

mFont.setWeight( 75/*config->readNumEntry( "Weight", 75)*/ );

setFixedSize( 100, 100 );

case Key_Enter:

case Key_Return:

case Key_Space:

setDown(true);

emit pressed();

break;

if ( m_pressed )

{

setDown(false);

emit released();

emit clicked();

}

case Key_Enter:

case Key_Return:

case Key_Space:

setDown(true);

emit pressed();

break;

if ( m_pressed )

{

setDown(false);

emit released();

emit clicked();

}

desk = 0; // no desktop yet

mode = PositionCenter;

info = NULL;

shade_mode = ShadeNone;

deleting = false;

motif_noborder = false;

fullscreen_mode = FullScreenNone;

original_skip_taskbar = false;

minimized = false;

hidden = false;

Ptakeactivity = 0;

Pcontexthelp = 0;

Pping = 0;

max_mode = MaximizeRestore;

maxmode_restore = MaximizeRestore;

deleting = true;

workspace()->discardUsedWindowRules( this, true ); // remove ForceTemporarily rules

StackingUpdatesBlocker blocker( workspace());

if (moveResizeMode)

leaveMoveResize();

removeShadow();

case NET::Menu :

case NET::Dialog :

case NET::Utility :

break;

default:

assert( false );

result = XGetWindowProperty(tqt_xdisplay(), window(), atoms->net_wm_system_modal_notification, 0L, 1L, False, XA_CARDINAL, &actual, &format, &n, &left, /*(unsigned char **)*/ &data);

if (result == Success && data && format == 32 )

{

}

}

void Client::updateShape()

XShapeCombineShape(tqt_xdisplay(), frameId(), ShapeBounding,

clientPos().x(), clientPos().y(),

window(), ShapeBounding, ShapeSet);

}

// !shape() mask setting is done in setMask() when the decoration

// calls it or when the decoration is created/destroyed

if( isOnCurrentDesktop() && isShown( true ))

{

if( mainClients().isEmpty() && !avoid_animation )

}

updateVisibility();

updateAllowedActions();

float diff;

TQPainter p ( workspace()->desktopWidget() );

TQPixmap pm3;

do

{

if ( need_to_clear )

{

p.drawPixmap( area2.x(), area2.y(), pm3 );

}

area2 = area;

}

else

{ // no overlap, we can clear later to avoid flicker

pm3 = pm2;

}

}

} while ( t.elapsed() < step);

XSelectInput( tqt_xdisplay(), wrapper, ClientWinMask | SubstructureNotifyMask );

//as we hid the unmap event, xcompmgr didn't recognize the client wid has vanished, so we'll extra inform it

//done xcompmgr workaround

// bool wasStaticContents = testWFlags( WStaticContents );

// setWFlags( WStaticContents );

int step = TQMAX( 4, TQABS( h - s.height() ) / as )+1;

resizeDecoration( TQSize( s.width(), h ));

// assume a border

// we do not have time to wait for X to send us paint events

TQApplication::syncX();

} while ( h < s.height() - step );

// if ( !wasStaticContents )

shade_geometry_change = false;

plainResize( s );

if( shade_mode == ShadeHover || shade_mode == ShadeActivated )

XMapWindow( tqt_xdisplay(), wrapperId());

XMapWindow( tqt_xdisplay(), window());

XDeleteProperty (tqt_xdisplay(), client, atoms->net_wm_window_shade);

tcomm = basename(tbuf);

#else /* default */

TQString statString(statRaw);

TQString tcomm = statFields[1];

TQString state = statFields[2];

#endif /* default */

TQString state(TQChar(inf->pr_sname));

#else /* default */

TQString statString(statRaw);

TQString tcomm = statFields[1];

TQString state = statFields[2];

#endif /* default */

{

// get the icons, allow scaling

if( icon != NULL )

if( miniicon != NULL )

{

if( icon == NULL || !icon->isNull())

else

*miniicon = TQPixmap();

}

}

if( icon_pix.isNull())

{ // and if nothing else, load icon from classhint or xapp icon

}

if( isManaged() && decoration != NULL )

decoration->iconChange();

custom_opacity = true;

// setOpacity(opacity_ < 0xFFFFFFFF, opacity_);

XFree ((char*)data);

}

}

void Client::setCustomOpacityFlag(bool custom)

// checks if this client borders c, needed to test beep media player window state

{

if (y() == c->y() + c->height()) // this bottom to c

if (y() + height() == c->y()) // this top to c

if (x() == c->x() + c->width()) // this right to c

if (x() + width() == c->x()) // this left to c

}

void Client::setDecoHashProperty(uint topHeight, uint rightWidth, uint bottomHeight, uint leftWidth)

}

/*!

Returns whether the client is on the virtual desktop \a d.

*/

inline bool Client::isOnDesktop( int d ) const

{

result = XGetWindowProperty(tqt_xdisplay(), windowId(), kde_wm_system_modal_notification, 0L, 1L, False, XA_CARDINAL, &actual, &format, &n, &left, /*(unsigned char **)*/ &data);

if (result == Success && data != None && format == 32 )

{

}

}

void B2Client::addButtons(const TQString& s, const TQString tips[],

result = XGetWindowProperty(tqt_xdisplay(), windowId(), kde_wm_system_modal_notification, 0L, 1L, False, XA_CARDINAL, &actual, &format, &n, &left, /*(unsigned char **)*/ &data);

if (result == Success && data != None && format == 32 )

{

}

}

void KeramikClient::addButtons( TQBoxLayout *layout, const TQString &s )

widget()->update( TQRect( titlebar->geometry().topRight(), TQPoint( width() - 4,

titlebar->geometry().bottom() ) ) );

// Titlebar needs no paint event

}

}

}

info->maximized = config->readNumEntry( TQString("maximize")+n, 0 );

info->fullscreen = config->readNumEntry( TQString("fullscreen")+n, 0 );

info->desktop = config->readNumEntry( TQString("desktop")+n, 0 );

info->windowType = txtToWindowType( config->readEntry( TQString("windowType")+n ).latin1());

info->active = false;

info->fake = true;

{

if ( mouse_emulation && (e->type == ButtonPress || e->type == ButtonRelease ) )

{

XUngrabKeyboard( tqt_xdisplay(), get_tqt_x_time() );

}

if ( tab_grab || control_grab )

{

tab_box->handleMouseEvent( e );

}

break;

case KeyPress:

addSystemTrayWin( w );

}

}

}

return ( e->xunmap.event != e->xunmap.window ); // hide wm typical event from Qt

{

//do not confuse Qt with these events. After all, _we_ are the

//window manager who does the reparenting.

}

case DestroyNotify:

{

if ( removeSystemTrayWin( e->xdestroywindow.window, false ) )

return false;

}

case MapRequest:

// this code doesn't check the parent to be root.

// if ( e->xmaprequest.parent == root ) { //###TODO store previously destroyed client ids

if ( addSystemTrayWin( e->xmaprequest.window ) )

c = createClient( e->xmaprequest.window, false );

if ( c != NULL && root != tqt_xrootwin() )

{ // TODO what is this?

break;

case KeyRelease:

if ( mouse_emulation )

break;

case FocusIn:

if( e->xfocus.window == rootWin() && TQCString( getenv("TDE_MULTIHEAD")).lower() != "true"

default:

break;

}

}

// Some events don't have the actual window which caused the event

}

/*!

Handles client messages for the client window

delete shadeHoverTimer;

shadeHoverTimer = new TQTimer( this );

connect( shadeHoverTimer, TQ_SIGNAL( timeout() ), this, TQ_SLOT( shadeHover() ));

}

if ( options->focusPolicy == Options::ClickToFocus )

delete autoRaiseTimer;

autoRaiseTimer = new TQTimer( this );

connect( autoRaiseTimer, TQ_SIGNAL( timeout() ), this, TQ_SLOT( autoRaise() ) );

}

TQPoint currentPos( e->x_root, e->y_root );

++i )

XGrabButton( tqt_xdisplay(), AnyButton,

modifier | mods[ i ],

GrabModeSync, GrabModeAsync, None, None );

}

bool replay = performMouseCommand( com, TQPoint( x_root, y_root), perform_handled );

if ( isSpecialWindow())

if( w == wrapperId()) // these can come only from a grab

XAllowEvents(tqt_xdisplay(), replay? ReplayPointer : SyncPointer, CurrentTime ); //tqt_x_time);

Options::MouseCommand com = Options::MouseNothing;

bool active = isActive();

if ( !wantsInput() ) // we cannot be active, use it anyway

if ( button == Button1 )

com = active ? options->commandActiveTitlebar1() : options->commandInactiveTitlebar1();

&& com != Options::MouseMinimize ) // mouse release event

{

mode = mousePosition( TQPoint( x, y ));

moveOffset = TQPoint( x, y );

invertedMoveOffset = rect().bottomRight() - moveOffset;

unrestrictedMoveResize = false;

y = this->y();

if ( (state & ( Button1Mask & Button2Mask & Button3Mask )) == 0 )

{

if ( moveResizeMode )

{

finishMoveResize( false );

bool activate = workspace()->allowClientActivation( this, -1U, true );

workspace()->gotFocusIn( this ); // remove from should_get_focus list

if( activate )

else

{

workspace()->restoreFocus();

if ( TQApplication::activePopupWidget() )

return;

if( !check_follows_focusin( this ))

}

// performs _NET_WM_MOVERESIZE

else if( moveResizeMode && direction == NET::MoveResizeCancel )

{

finishMoveResize( true );

setCursor( mode );

}

else if( direction >= NET::TopLeft && direction <= NET::Left )

return;

if( moveResizeMode )

finishMoveResize( false );

moveOffset = TQPoint( x_root - x(), y_root - y()); // map from global

invertedMoveOffset = rect().bottomRight() - moveOffset;

unrestrictedMoveResize = false;

case Key_Return:

case Key_Enter:

finishMoveResize( false );

setCursor( mode );

break;

case Key_Escape:

finishMoveResize( true );

setCursor( mode );

break;

default:

return false;

}

if ( maximizeMode() != MaximizeRestore )

TQSize max = maxSize();

#if 0

if( max.width() < 32767 || max.height() < 32767 ) // sizes are 16bit with X

int supported;

stream >> supported;

btn.supported = supported;

}

}

: TQFrame( parent, name ),

m_selected(0)

{

setFrameShape( WinPanel );

setFrameShadow( Raised );

setMinimumHeight( 26 );

int swm;

for ( swm = 0; swm < thirdpartyWMList->count(); ++swm ) {

if ( thirdpartyWMList->text( swm ).startsWith(selectedWM + " ") ) {

break;

}

}

thirdpartyWMList->setCurrentItem(0);

}

else {

: TDECModule(parent, "kcmkwm"), config(_config), standAlone(_standAlone)

{

kompmgr = 0L;

TQVBoxLayout *lay = new TQVBoxLayout (this);

kompmgrAvailable_ = kompmgrAvailable();

if (!kompmgrAvailable_){

tabW->addTab(tGroup, i18n("Opacity"));

TQWidget *sGroup = new TQWidget(tabW);

TQVBoxLayout *vLay2 = new TQVBoxLayout (sGroup,11,6);

vLay2->addSpacing(11); // to get the proper gb top offset

useShadows = new TQCheckBox(i18n("Use shadows on windows (standard effects should be disabled in the Styles module if this is checked)"),sGroup);

void KTranslucencyConfig::resetKompmgr()

{

}

void KTranslucencyConfig::load( void )

TDEConfig conf_(TQDir::homeDirPath() + "/.xcompmgrrc");

conf_.setGroup("xcompmgr");

blurBackground->setEnabled(useOpenGL->isChecked());

greyscaleBackground->setEnabled(useOpenGL->isChecked());

useShadows->setChecked(conf_.readEntry("Compmode","").compare("CompClientShadows") == 0);

shadowTopOffset->setValue(-1*(conf_.readNumEntry("ShadowOffsetY",0)));

shadowLeftOffset->setValue(-1*(conf_.readNumEntry("ShadowOffsetX",0)));

else

shadowColor->setColor(TQColor(r,g,b));

fadeInSpeed->setValue((int)(conf_.readDoubleNumEntry("FadeInStep",0.070)*1000.0));

fadeOutSpeed->setValue((int)(conf_.readDoubleNumEntry("FadeOutStep",0.070)*1000.0));

inactiveWindowOpacity->setEnabled(false);

movingWindowOpacity->setEnabled(false);

dockWindowOpacity->setEnabled(false);

shadowColor->setColor(TQt::black);

fadeInSpeed->setValue(70);

fadeOutSpeed->setValue(70);

emit TDECModule::changed(true);

button_released = (ev.xbutton.button == Button1);

if ( ev.xbutton.button == Button3 )

{

break;

}

if( ev.xbutton.button == Button1 || ev.xbutton.button == Button2 )

result = XGetWindowProperty(tqt_xdisplay(), windowId(), kde_wm_system_modal_notification, 0L, 1L, False, XA_CARDINAL, &actual, &format, &n, &left, /*(unsigned char **)*/ &data);

if (result == Success && data != None && format == 32 )

{

}

}

void KCommonDecoration::addButtons(ButtonContainer &btnContainer, const TQString& s, bool isLeft)

int screen_number = -1;

bool disable_twin_composition_manager = false;

static

int x11ErrorHandler(Display *d, XErrorEvent *e)

{

char msg[80], req[80], number[80];

if (initting &&

(

// if there was already twin running, it saved its configuration after loosing the selection -> reread

config()->reparseConfiguration();

// install X11 error handler

XSetErrorHandler( x11ErrorHandler );

DCOPRef ref( "kded", "kded" );

ref.send( "unloadModule", TQCString( "kdetrayproxy" ));

dcopClient()->send( "ksplash", "", "upAndRunning(TQString)", TQString("wm started"));

XEvent e;

bool Application::x11EventFilter( XEvent *e )

{

if ( Workspace::self()->workspaceEvent( e ) )

return TDEApplication::x11EventFilter( e );

}

// onAllDesktopsChange(); decoration doesn't exist here yet

TQRect geom( attr.x, attr.y, attr.width, attr.height );

if ( session )

geom = session->geometry;

if ( ( (xSizeHint.flags & PPosition) && !ignorePPosition ) ||

(xSizeHint.flags & USPosition) )

{

// disobey xinerama placement option for now (#70943)

area = workspace()->clientArea( PlacementArea, geom.center(), desktop());

}

if( isMovable())

{

if( geom.x() > area.right() || geom.y() > area.bottom())

}

if ( placementDone )

if( !placementDone )

{ // placement needs to be after setting size

workspace()->place( this, area );

}

if(( !isSpecialWindow() || isToolbar()) && isMovable())

// probably should be replaced by something better

bool doNotShow = false;

if ( workspace()->isNotManaged( caption() ) )

// other settings from the previous session

if ( session )

return event;

}

TQValueList< Notify::EventData > Notify::pending_events;

bool Notify::raise( Event e, const TQString& message, Client* c )

separateScreenFocus = config->readBoolEntry( "SeparateScreenFocus", false );

activeMouseScreen = config->readBoolEntry( "ActiveMouseScreen", focusPolicy != ClickToFocus );

// focusStealingPreventionLevel = config->readNumEntry( "FocusStealingPreventionLevel", 2 );

// TODO use low level for now

xineramaPlacementScreen = KCLAMP( config->readNumEntry( "XineramaPlacementScreen", -1 ),

-1, tqApp->desktop()->numScreens() - 1 );

animateMinimizeSpeed = config->readNumEntry("AnimateMinimizeSpeed", 5 );

if( focusPolicy == ClickToFocus )

}

else

{

autoRaiseInterval = config->readNumEntry("AutoRaiseInterval", 0 );

delayFocusInterval = config->readNumEntry("DelayFocusInterval", 0 );

}

shadeHoverInterval = config->readNumEntry("ShadeHoverInterval", 250 );

// important: autoRaise implies ClickRaise

borderSnapZone = config->readNumEntry("BorderSnapZone", 10);

windowSnapZone = config->readNumEntry("WindowSnapZone", 10);

// active borders: compatibility with old option names (Electric*)

active_borders = config->readNumEntry("ActiveBorders", -1);

onlyDecoTranslucent = config->readBoolEntry("OnlyDecoTranslucent",false);

resetKompmgr = config->readBoolEntry("ResetKompmgr", false);

if (resetKompmgr)

// window drop shadows

config->setGroup("Style");

connect(&m_delayedHideTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(hide()));

TQFont f = font();

f.setPointSize( 14 );

setFont( f );

config->writeEntry( TQString("wmClientMachine")+n, c->wmClientMachine( true ).data() );

config->writeEntry( TQString("resourceName")+n, c->resourceName().data() );

config->writeEntry( TQString("resourceClass")+n, c->resourceClass().data() );

config->writeEntry( TQString("restore")+n, c->geometryRestore() );

config->writeEntry( TQString("fsrestore")+n, c->geometryFSRestore() );

config->writeEntry( TQString("maximize")+n, (int) c->maximizeMode() );

info->maximized = config->readNumEntry( TQString("maximize")+n, 0 );

info->fullscreen = config->readNumEntry( TQString("fullscreen")+n, 0 );

info->desktop = config->readNumEntry( TQString("desktop")+n, 0 );

info->windowType = txtToWindowType( config->readEntry( TQString("windowType")+n ).latin1());

info->shortcut = config->readEntry( TQString("shortcut")+n );

info->active = ( active_client == i );

if ( clients.count() == 0 ) // height for the "not tasks" text

{

TQFont f = font();

f.setPointSize( 14 );

h = TQFontMetrics(f).height()*4;

if ( !currentClient() )

{

TQFont f = font();

f.setPointSize( 14 );

p.setFont(f);

{

if( !establishTabBoxGrab())

return false;

keys->suspend( true );

disable_shortcuts_keys->suspend( true );

client_keys->suspend( true );

tab_box->setMode( TabBox::WindowsMode );

tab_box->reset();

}

bool Workspace::startWalkThroughDesktops( int mode )

{

if( !establishTabBoxGrab())

return false;

keys->suspend( true );

disable_shortcuts_keys->suspend( true );

client_keys->suspend( true );

tab_box->setMode( (TabBox::Mode) mode );

tab_box->reset();

}

bool Workspace::startWalkThroughDesktops()

keys->suspend( false );

disable_shortcuts_keys->suspend( false );

client_keys->suspend( false );

}

/*!

bool isAppsOnly() const;

void reset();

void delayedShow();

void hide();

if ( !popup )

{

popup = new TQPopupMenu;

popup->setFont(TDEGlobalSettings::menuFont());

connect( popup, TQ_SIGNAL( aboutToShow() ), this, TQ_SLOT( clientPopupAboutToShow() ) );

connect( popup, TQ_SIGNAL( activated(int) ), this, TQ_SLOT( clientPopupActivated(int) ) );

advanced_popup = new TQPopupMenu( popup );

advanced_popup->setFont(TDEGlobalSettings::menuFont());

connect( advanced_popup, TQ_SIGNAL( activated(int) ), this, TQ_SLOT( clientPopupActivated(int) ) );

advanced_popup->insertItem( SmallIconSet( "go-up" ),

return;

desk_popup = new TQPopupMenu( popup );

desk_popup->setFont(TDEGlobalSettings::menuFont());

connect( desk_popup, TQ_SIGNAL( activated(int) ),

this, TQ_SLOT( slotSendToDesktop(int) ) );

desk_popup->clear();

desk_popup->insertItem( i18n("&All Desktops"), 0 );

if ( active_popup_client && active_popup_client->isOnAllDesktops() )

desk_popup->insertSeparator( -1 );

int id;

const int BASE = 10;

i );

if ( active_popup_client &&

!active_popup_client->isOnAllDesktops() && active_popup_client->desktop() == i )

}

}

*/

bool Client::performMouseCommand( Options::MouseCommand command, TQPoint globalPos, bool handled )

{

switch (command)

{

case Options::MouseRaise:

case Options::MouseActivateRaiseAndPassClick:

workspace()->takeActivity( this, ActivityFocus | ActivityRaise, handled );

workspace()->setActiveScreenMouse( globalPos );

break;

case Options::MouseActivateAndPassClick:

workspace()->takeActivity( this, ActivityFocus, handled );

workspace()->setActiveScreenMouse( globalPos );

break;

case Options::MouseActivateRaiseAndMove:

case Options::MouseActivateRaiseAndUnrestrictedMove:

if( moveResizeMode )

finishMoveResize( false );

mode = PositionCenter;

moveOffset = TQPoint( globalPos.x() - x(), globalPos.y() - y()); // map from global

invertedMoveOffset = rect().bottomRight() - moveOffset;

unrestrictedMoveResize = ( command == Options::MouseActivateRaiseAndUnrestrictedMove

break;

if( moveResizeMode )

finishMoveResize( false );

moveOffset = TQPoint( globalPos.x() - x(), globalPos.y() - y()); // map from global

int x = moveOffset.x(), y = moveOffset.y();

bool left = x < width() / 3;

{

if (opacity_ < 0xF3333333)

{

custom_opacity = true;

}

else

{

custom_opacity = false;

}

}

case Options::MouseOpacityLess:

if (opacity_ > 0)

{

custom_opacity = true;

}

break;

case Options::MouseNothing:

break;

}

return replay;

unsigned int wws, hws, wbs, hbs;

int boundingShaped = 0, clipShaped = 0;

if (!available())

XShapeQueryExtents(tqt_xdisplay(), w,

&boundingShaped, &xws, &yws, &wws, &hws,

&clipShaped, &xbs, &ybs, &wbs, &hbs);

TDEProcess* kompmgr = 0;

TDESelectionOwner* kompmgr_selection;

extern bool disable_twin_composition_manager;

bool supportsCompMgr()

root = tqt_xrootwin();

default_colormap = DefaultColormap(tqt_xdisplay(), tqt_xscreen() );

installed_colormap = default_colormap;

for (int i = 0; i < ACTIVE_BORDER_COUNT; ++i)

{

if (r.search(title) != -1)

{

doNotManageList.remove( it );

}

}

}

/*!

bool Workspace::addSystemTrayWin( WId w )

{

if ( systemTrayWins.contains( w ) )

NETWinInfo ni( tqt_xdisplay(), w, root, NET::WMKDESystemTrayWinFor );

WId trayWinFor = ni.kdeSystemTrayWinFor();

if ( !trayWinFor )

systemTrayWins.append( SystemTrayWindow( w, trayWinFor ) );

XSelectInput( tqt_xdisplay(), w,

StructureNotifyMask

);

XAddToSaveSet( tqt_xdisplay(), w );

propagateSystemTrayWins();

}

/*!

bool Workspace::removeSystemTrayWin( WId w, bool check )

{

if ( !systemTrayWins.contains( w ) )

if( check )

{

// When getting UnmapNotify, it's not clear if it's the systray

systemTrayWins.remove( w );

XRemoveFromSaveSet (tqt_xdisplay (), w);

propagateSystemTrayWins();

}

if ( mouse_emulation )

{

XUngrabKeyboard(tqt_xdisplay(), get_tqt_x_time());

return;

}

if ( XGrabKeyboard(tqt_xdisplay(),

GrabModeAsync, GrabModeAsync,

get_tqt_x_time()) == GrabSuccess )

{

mouse_emulation_state = 0;

mouse_emulation_window = 0;

}

bool Workspace::keyPressMouseEmulation( XKeyEvent& ev )

{

if ( root != tqt_xrootwin() )

int kc = XkbKeycodeToKeysym(tqt_xdisplay(), ev.keycode, 0, 0);

int km = ev.state & (ControlMask | Mod1Mask | ShiftMask);

// fall through

case XK_Escape:

XUngrabKeyboard(tqt_xdisplay(), get_tqt_x_time());

default:

}

TQCursor::setPos( pos );

if ( mouse_emulation_state )

mouse_emulation_state = sendFakedMouseEvent( pos, mouse_emulation_window, EmuMove, 0, mouse_emulation_state );

}

delete delayFocusTimer;

delayFocusTimer = new TQTimer( this );

connect( delayFocusTimer, TQ_SIGNAL( timeout() ), this, TQ_SLOT( delayFocus() ) );

}

void Workspace::cancelDelayFocus()

}

if (!kompmgr->start(TDEProcess::OwnGroup, TDEProcess::Stderr))

{

TDEProcess proc;

proc << "kdialog" << "--error"

<< i18n("The Composite Manager could not be started.\\nMake sure you have \"" TDE_COMPOSITOR_BINARY "\" in a $PATH directory.")

connect( kompmgr_selection, TQ_SIGNAL( lostOwnership()), TQ_SLOT( stopKompmgr()));

kompmgr_selection->claim( true );

connect(kompmgr, TQ_SIGNAL(processExited(TDEProcess*)), TQ_SLOT(restartKompmgr(TDEProcess*)));

//TQTimer::singleShot( 60000, this, TQ_SLOT(unblockKompmgrRestart()) );

TQByteArray ba;

TQDataStream arg(ba, IO_WriteOnly);

delete kompmgr_selection;

kompmgr_selection = NULL;

kompmgr->disconnect(this, TQ_SLOT(restartKompmgr(TDEProcess*)));

if (popup){ delete popup; popup = 0L; } // to add/remove opacity slider

kompmgr->kill(SIGKILL);

TQByteArray ba;

void Workspace::unblockKompmgrRestart()

{

}

void Workspace::restartKompmgr( TDEProcess *proc )

{

delete kompmgr_selection;

kompmgr_selection = NULL;

if (crashed) {

TDEProcess proc;

proc << "kdialog" << "--error"

{

delete kompmgr_selection;

kompmgr_selection = NULL;

TDEProcess proc;

proc << "kdialog" << "--error"

<< i18n("The Composite Manager could not be started.\\nMake sure you have \"" TDE_COMPOSITOR_BINARY "\" in a $PATH directory.")

}

else

{

TQTimer::singleShot( 60000, this, TQ_SLOT(unblockKompmgrRestart()) );

}

}

{

TQ_OBJECT

public:

virtual ~Workspace();

static Workspace * self() { return _self; }

// stealing prevention code.

Client* mostRecentlyActivatedClient() const;

void takeActivity( Client* c, int flags, bool handled ); // flags are ActivityFlags

void handleTakeActivity( Client* c, Time timestamp, int flags ); // flags are ActivityFlags

bool allowClientActivation( const Client* c, Time time = -1U, bool focus_in = false );