void apbar::place_clients(void)
{
	WINDOW *cur;
	int twidth=2;  // total width

	for(cur = ap.first(); cur != NULL; cur = ap.next())
		twidth += cur->width+4;

	twidth -= 2;
	setUpdatesEnabled(FALSE);
	setFixedWidth(twidth);

	if(! twidth)
	{
		setUpdatesEnabled(TRUE);
		return;
	}	
		
	int cx = 2;
	for(cur = ap.first(); cur != NULL; cur = ap.next())
	{
		XMoveWindow(qt_xdisplay(), cur->w, cx, 0);
		
		XWindowAttributes attr;
		if(XGetWindowAttributes(qt_xdisplay(), cur->w, &attr))
		{
			XMapWindow(qt_xdisplay(), cur->w);
			XRaiseWindow(qt_xdisplay(), cur->w);
		}	
		cx += cur->width+4;
	}
	setUpdatesEnabled(TRUE);
}

void getrunprocs(void)  // get already running clients
{
	Window w,w1,w2,*wins;
	uint nwins,cwin;
	XWindowAttributes attr;

	if(XQueryTree(qt_xdisplay(), qt_xrootwin(), &w1, &w2, &wins, &nwins) == 0 || ! nwins)
		return;
	
	bool surgent = defaults::starturgent;
	defaults::starturgent = FALSE;

	for(cwin=0; cwin < nwins; cwin++)
	{
		w = wins[cwin];
		
		if(w == qapp::tb->winId())
			continue;

		XGetWindowAttributes(qt_xdisplay(), w, &attr);

		if(attr.map_state == IsViewable && ! attr.override_redirect)
			qapp::run_client(w);
	}
	XSync(qt_xdisplay(), FALSE);
	defaults::starturgent = surgent;
}

bool KKeyNative::init(const KKey &key)
{
    // Get any extra mods required by the sym.
    //  E.g., XK_Plus requires SHIFT on the en layout.
    m_sym = key.sym();
    uint modExtra = KKeyServer::Sym(m_sym).getModsRequired();
    // Get the X modifier equivalent.
    if(!m_sym || !KKeyServer::modToModX(key.modFlags() | modExtra, m_mod))
    {
        m_sym = m_mod = 0;
        m_code = 0;
        return false;
    }

    // XKeysymToKeycode returns the wrong keycode for XK_Print and XK_Break.
    // Specifically, it returns the code for SysReq instead of Print
    // Only do this for the default Xorg layout, other keycode mappings
    // (e.g. evdev) don't need or want it.
    if(m_sym == XK_Print && !(m_mod & Mod1Mask) && XKeycodeToKeysym(qt_xdisplay(), 111, 0) == XK_Print)
        m_code = 111; // code for Print
    else if(m_sym == XK_Break || ((m_sym == XK_Pause && (m_mod & ControlMask)) && XKeycodeToKeysym(qt_xdisplay(), 114, 0) == XK_Pause))
        m_code = 114;
    else
        m_code = XKeysymToKeycode(qt_xdisplay(), m_sym);

    if(!m_code && m_sym)
        kdDebug(125) << "Couldn't get code for sym" << endl;
    // Now get the true sym formed by the modifiers
    //  E.g., Shift+Equal => Plus on the en layout.
    if(key.modFlags() && ((m_sym < XK_Home || m_sym > XK_Begin) && m_sym != XK_Insert && m_sym != XK_Delete))
        KKeyServer::codeXToSym(m_code, m_mod, m_sym);

    return true;
}

void qt_xdnd_handle_selection_request( const XSelectionRequestEvent * req )
{
    if ( !req )
	return;
    XEvent evt;
    evt.xselection.type = SelectionNotify;
    evt.xselection.display = req->display;
    evt.xselection.requestor = req->requestor;
    evt.xselection.selection = req->selection;
    evt.xselection.target = req->target;
    evt.xselection.property = None;
    evt.xselection.time = req->time;
    const char* format = qt_xdnd_atom_to_str( req->target );
    if ( format && qt_xdnd_source_object &&
	 qt_xdnd_source_object->provides( format ) ) {
	QByteArray a = qt_xdnd_source_object->encodedData(format);
	XChangeProperty ( qt_xdisplay(), req->requestor, req->property,
			  req->target, 8, PropModeReplace,
			  (unsigned char *)a.data(), a.size() );
	evt.xselection.property = req->property;
    }
    // ### this can die if req->requestor crashes at the wrong
    // ### moment
    XSendEvent( qt_xdisplay(), req->requestor, False, 0, &evt );
}

GlobalKey::GlobalKey(CommandDef *cmd)
{
    m_key = QAccel::stringToKey(cmd->accel);
    m_state = 0;
    if (m_key & Qt::SHIFT) {
        m_key &= ~Qt::SHIFT;
        m_state |= 1;
    }
    if (m_key & Qt::CTRL) {
        m_key &= ~Qt::CTRL;
        m_state |= 4;
    }
    if (m_key & Qt::ALT) {
        m_key &= ~Qt::ALT;
        m_state |= 8;
    }
    m_key &= ~Qt::UNICODE_ACCEL;
    for (const TransKey *t = g_rgQtToSymX; t->x_key; t++) {
        if (t->qt_key == m_key) {
            m_key = t->x_key;
            break;
        }
    }
    m_key = XKeysymToKeycode( qt_xdisplay(), m_key);
    XSync( qt_xdisplay(), 0 );
    XErrorHandler savedErrorHandler = XSetErrorHandler(XGrabErrorHandler);
    XGrabKey( qt_xdisplay(), m_key, m_state,
              qt_xrootwin(), True, GrabModeAsync, GrabModeSync);
    XSync( qt_xdisplay(), 0 );
    XSetErrorHandler( savedErrorHandler );
}

// FINISHED - set defaults...
void Kaptan::accept()
{
    // Kicker değişkenlerini ayarlayalım...
    // 	- İkonların üzerine gelince büyüme efektini aç...
    KConfig kickerconf("kickerrc", false, false);
    kickerconf.setGroup("buttons");
    kickerconf.writeEntry("EnableIconZoom", true);
    kickerconf.sync();

    // Kicker'ı DCOP ile dürtelim ki yeni ayarları yüklesin
    if (!kapp->dcopClient()->isAttached())
        kapp->dcopClient()->attach();

    QByteArray data;
    QCString appname;
    if (DefaultScreen(qt_xdisplay()) == 0)
        appname = "kicker";
    else
        appname.sprintf("kicker-screen-%d", DefaultScreen(qt_xdisplay()));
    kapp->dcopClient()->send( appname, "kicker", "configure()", data );

    // KDE değişkenlerini ayarlayalım...
    // 	- Düğmeler üzerinde simgeleri görünsün
    // 	- Combo'lar açılırken efektli açılsın
    // 	- Renk şeması lipstikwhite olsun
    KGlobal::config()->setGroup("KDE");
    KGlobal::config()->writeEntry("ShowIconsOnPushButtons", true,true, true);
    KGlobal::config()->writeEntry("EffectAnimateCombo", true, true, true);
    KGlobal::config()->writeEntry("colorScheme", "lipstikwhite.kcsrc", true, true, true);

    KGlobal::config()->sync();

    exit(0);
}

/*!
  For internal use only.
*/
void QNPWidget::setWindow(bool delold)
{
    saveWId = winId(); // ### Don't need this anymore

    create((WId)pi->window, FALSE, delold);

   if ( delold ) {
      // Make sure they get a show()
      clearWState( WState_Visible );
   }

#ifdef _WS_X11_
    Widget w = XtWindowToWidget (qt_xdisplay(), pi->window);
    XtAddEventHandler(w, EnterWindowMask, FALSE, enter_event_handler, pi);
    XtAddEventHandler(w, LeaveWindowMask, FALSE, leave_event_handler, pi);
    Pixmap bgpm=0;
    XColor col;
    XtVaGetValues(w,
	XtNbackground, &col.pixel,
	XtNbackgroundPixmap, &bgpm,
	0, 0);
    XQueryColor(qt_xdisplay(), x11Colormap(), &col);
    setBackgroundColor(QColor(col.red >> 8, col.green >> 8, col.blue >> 8));
    if (bgpm) {
	// ### Need an under-the-hood function here, or we have to
	// ### rewrite lots of code from QPixmap::convertToImage().
	// ### Doesn't matter yet, because Netscape doesn't ever set
	// ### the background image of the window it gives us.
    }
#endif

    createNewWindowsForAllChildren(this);

    setGeometry( pi->x, pi->y, pi->width, pi->height );
}

void KStart::applyStyle(Window w) {
    if (window)
	KWM::prepareForSwallowing(w);
    if (desktop >= 0) {
	if (KWM::desktop(w) != desktop)
	    KWM::moveToDesktop(w, desktop);
    }
    if (maximize) {
	debug("do maximize");
	KWM::doMaximize(w, true);
    }
    if (iconify)
	KWM::setIconify(w, true);
    if (sticky) {
	KWM::setSticky(w, true);
    }
    if (decoration != KWM::normalDecoration) {
	KWM::setDecoration(w, decoration);
	if (decoration & KWM::staysOnTop )
	  XRaiseWindow( qt_xdisplay(), w);
    }

    XSync(qt_xdisplay(), False);
    if (window) {
	XMapWindow(qt_xdisplay(), w);
	XSync(qt_xdisplay(), False);
    }
    if (activate)
      KWM::activate(w);
    XSync(qt_xdisplay(), False);
}

bool RandRScreen::applyProposed()
{
    // kdDebug() << k_funcinfo << " size " << (SizeID)proposedSize() << ", rotation " << proposedRotation() << ", refresh " <<
    // refreshRateIndexToHz(proposedSize(), proposedRefreshRate()) << endl;

    Status status;

    if(proposedRefreshRate() < 0)
        status = XRRSetScreenConfig(qt_xdisplay(), d->config, DefaultRootWindow(qt_xdisplay()), (SizeID)proposedSize(), (Rotation)proposedRotation(),
                                    CurrentTime);
    else
    {
        if(refreshRateIndexToHz(proposedSize(), proposedRefreshRate()) <= 0)
        {
            m_proposedRefreshRate = 0;
        }
        status = XRRSetScreenConfigAndRate(qt_xdisplay(), d->config, DefaultRootWindow(qt_xdisplay()), (SizeID)proposedSize(),
                                           (Rotation)proposedRotation(), refreshRateIndexToHz(proposedSize(), proposedRefreshRate()), CurrentTime);
    }

    // kdDebug() << "New size: " << WidthOfScreen(ScreenOfDisplay(QPaintDevice::x11AppDisplay(), screen)) << ", " <<
    // HeightOfScreen(ScreenOfDisplay(QPaintDevice::x11AppDisplay(), screen)) << endl;

    if(status == RRSetConfigSuccess)
    {
        m_currentSize = m_proposedSize;
        m_currentRotation = m_proposedRotation;
        m_currentRefreshRate = m_proposedRefreshRate;
        return true;
    }

    return false;
}

QRect KWM::geometry(Window w, bool including_frame){
  static Atom a = 0;
  if (!a)
    a = XInternAtom(qt_xdisplay(), "KWM_WIN_FRAME_GEOMETRY", False);
  QRect result;
  if (including_frame){
    if (getQRectProperty(w, a, result))
      return result;
  }
  XWindowAttributes attr;
  if (XGetWindowAttributes(qt_xdisplay(), w, &attr)){
    if (getQRectProperty(w, a, result)){
      result.setWidth(attr.width);
      result.setHeight(attr.height);
    }
    else{
      int x, y;
      Window child;
      XTranslateCoordinates(qt_xdisplay(),
			    w, qt_xrootwin(),
			    0, 0, &x, &y, &child);
      result.setRect(x, y, attr.width, attr.height);
    }
  }
  return result;
}

void RandRScreen::loadSettings()
{
    if(d->config)
        XRRFreeScreenConfigInfo(d->config);

    d->config = XRRGetScreenInfo(qt_xdisplay(), RootWindow(qt_xdisplay(), m_screen));
    Q_ASSERT(d->config);

    Rotation rotation;
    m_currentSize = m_proposedSize = XRRConfigCurrentConfiguration(d->config, &rotation);
    m_currentRotation = m_proposedRotation = rotation;

    m_pixelSizes.clear();
    m_mmSizes.clear();
    int numSizes;
    XRRScreenSize *sizes = XRRSizes(qt_xdisplay(), m_screen, &numSizes);
    for(int i = 0; i < numSizes; i++)
    {
        m_pixelSizes.append(QSize(sizes[i].width, sizes[i].height));
        m_mmSizes.append(QSize(sizes[i].mwidth, sizes[i].mheight));
    }

    m_rotations = XRRRotations(qt_xdisplay(), m_screen, &rotation);

    m_currentRefreshRate = m_proposedRefreshRate = refreshRateHzToIndex(m_currentSize, XRRConfigCurrentRate(d->config));
}

Atom KWinSelectionOwner::make_selection_atom(int screen_P)
{
    if(screen_P < 0)
        screen_P = DefaultScreen(qt_xdisplay());
    char tmp[30];
    sprintf(tmp, "WM_S%d", screen_P);
    return XInternAtom(qt_xdisplay(), tmp, False);
}

void ungrabXServer()
{
    assert(server_grab_count > 0);
    if(--server_grab_count == 0)
    {
        XUngrabServer(qt_xdisplay());
        XFlush(qt_xdisplay());
        Notify::sendPendingEvents();
    }
}

void Shape::init()
{
    kwin_shape_version = 0;
    int dummy;
    if(!XShapeQueryExtension(qt_xdisplay(), &kwin_shape_event, &dummy))
        return;
    int major, minor;
    if(!XShapeQueryVersion(qt_xdisplay(), &major, &minor))
        return;
    kwin_shape_version = major * 0x10 + minor;
}