start ()

start ();

Starts cinnamon. Should not be called in JavaScript code

setWorkspaceName ()

setWorkspaceName (int      index,
                  string   name);

Sets the name of the workspace index to name

getWorkspaceName ()

string
getWorkspaceName (int   index);

Retrieves the name of the workspace index

hasDefaultWorkspaceName ()

boolean
hasDefaultWorkspaceName (int   index);

Whether the workspace uses the default name

moveWindowToNewWorkspace ()

moveWindowToNewWorkspace (Meta.Window   metaWindow,
                          boolean       switchToNewWorkspace);

Moves the window to a new workspace.

If switchToNewWorkspace is true, it will switch to the new workspace after moving the window

getThemeStylesheet ()

string
getThemeStylesheet ();

Get the theme CSS file that Cinnamon will load

setThemeStylesheet ()

setThemeStylesheet (string   cssStylesheet);

Set the theme CSS file that Cinnamon will load

loadTheme ()

loadTheme ();

Reloads the theme CSS file

notify ()

notify (string   msg,
        string   details);

Sends a notification

criticalNotify ()

criticalNotify (msg,
                details);

warningNotify ()

warningNotify (msg,
               details);

notifyError ()

notifyError (string   msg,
             string   details);

See cinnamon_global_notify_problem().

formatLogArgument ()

formatLogArgument (any   arg,
                   int   recursion,
                   int   depth);

Used by _log to handle each argument type and its formatting.

_log ()

_log (string   category,
      string   msg);

Log a message into the LookingGlass error stream. This is primarily intended for use by the extension system as well as debugging.

isError ()

boolean
isError (Object   obj);

Tests whether obj is an error object

_LogTraceFormatted ()

_LogTraceFormatted (string   stack);

Prints the stack trace to the LookingGlass error stream in a predefined format

_logTrace ()

_logTrace (Error   msg);

Prints a stack trace of the given object.

If msg is an error, its stack-trace will be printed. Otherwise, a stack-trace of the call will be generated

If you want to print the message of an Error as well, use the other log functions instead.

_logWarning ()

_logWarning (Error/string   msg);

Logs the message to the LookingGlass error stream.

If msg is an error, its stack-trace will be printed.

_logError ()

_logError (string   msg,
           Error    error);

Logs the following (if present) to the LookingGlass error stream:

It can be called in the form of either _logError(msg), _logError(error) or _logError(msg, error).

_logInfo ()

_logInfo (Error/string   msg);

Logs the message to the LookingGlass error stream. If msg is an Error object, its stack trace will also be printed

logStackTrace ()

logStackTrace (string   msg);

Logs the message msg to stdout with backtrace

isWindowActorDisplayedOnWorkspace ()

boolean
isWindowActorDisplayedOnWorkspace (Meta.WindowActor   win,
                                   int                workspaceIndex);

Determines whether the window actor belongs to a specific workspace

getWindowActorsForWorkspace ()

array
getWindowActorsForWorkspace (int   workspaceIndex);

Gets a list of actors on a workspace

pushModal ()

boolean
pushModal (Clutter.Actor       actor,
           int                 timestamp,
           Meta.ModalOptions   options);

Ensure we are in a mode where all keyboard and mouse input goes to the stage, and focus actor. Multiple calls to this function act in a stacking fashion; the effect will be undone when an equal number of popModal() invocations have been made.

Next, record the current Clutter keyboard focus on a stack. If the modal stack returns to this actor, reset the focus to the actor which was focused at the time pushModal() was invoked.

timestamp is optionally used to associate the call with a specific user initiated event. If not provided then the value of global.get_current_time() is assumed.

popModal ()

popModal (Clutter.Actor   actor,
          int             timestamp);

Reverse the effect of pushModal(). If this invocation is undoing the topmost invocation, then the focus will be restored to the previous focus at the time when pushModal() was invoked.

timestamp is optionally used to associate the call with a specific user initiated event. If not provided then the value of global.get_current_time() is assumed.

createLookingGlass ()

LookingGlass.Melange
createLookingGlass ();

Obtains the looking glass object. Create if it does not exist

getRunDialog ()

RunDialog.RunDialog
getRunDialog ();

Obtains the run dialog object. Create if it does not exist

activateWindow ()

activateWindow (Meta.Window   window,
                int           time,
                int           workspaceNum);

Activates window, switching to workspaceNum first if provided, and switching out of the overview if it's currently active. If no workspace is provided, workspace-related behavior during activation will be handled in muffin.

initializeDeferredWork ()

string
initializeDeferredWork (Clutter.Actor   actor,
                        function        callback);

This function sets up a callback to be invoked when either the given actor is mapped, or after some period of time when the machine is idle. This is useful if your actor isn't always visible on the screen (for example, all actors in the overview), and you don't want to consume resources updating if the actor isn't actually going to be displaying to the user.

Note that queueDeferredWork is called by default immediately on initialization as well, under the assumption that new actors will need it.

queueDeferredWork ()

queueDeferredWork (string   workId);

Ensure that the work identified by workId will be run on map or timeout. You should call this function for example when data being displayed by the actor has changed.

isInteresting ()

boolean
isInteresting (Meta.Window   metaWindow);

Determines whether a window is "interesting", i.e. ones to be displayed in alt-tab, window list etc.

getTabList ()

array
getTabList (Meta.Workspace   workspaceOpt,
            Meta.Screen      screenOpt);

Return a list of the interesting windows on a workspace (by default, the active workspace). The list will include app-less dialogs.

The “placesManager” property

  “placesManager”            PlacesManager.PlacesManager

The places manager

The “overview” property

  “overview”                 Overview.Overview

The "scale" overview

The “expo” property

  “expo”                     Expo.Expo

The "expo" overview

The “runDialog” property

  “runDialog”                RunDialog.RunDialog

The run dialog

The “lookingGlass” property

  “lookingGlass”             LookingGlass.Melange

The looking glass object

The “wm” property

  “wm”                       WindowManager.WindowManager

The window manager

The “messageTray” property

  “messageTray”              MessageTray.MessageTray

The mesesage tray

The “notificationDaemon” property

  “notificationDaemon”       NotificationDaemon.NotificationDaemon

The notification daemon

The “windowAttentionHandler” property

  “windowAttentionHandler”   WindowAttentionHandler.WindowAttentionHandler

The window attention handle

The “screenRecorder” property

  “screenRecorder”           ScreenRecorder.ScreenRecorder

The recorder

The “cinnamonDBusService” property

  “cinnamonDBusService”      CinnamonDBus.Cinnamon

The cinnamon dbus object

The “screenshotService” property

  “screenshotService”        Screenshot.ScreenshotService

Implementation of gnome-shell's screenshot interface.

The “modalCount” property

  “modalCount”               int

The number of modals "pushed"

The “modalActorFocusStack” property

  “modalActorFocusStack”     array

Array of pushed modal actors

The “uiGroup” property

  “uiGroup”                  Cinnamon.GenericContainer

The group containing all Cinnamon and Muffin actors

The “magnifier” property

  “magnifier”                Magnifier.Magnifier

The magnifier

The “locatePointer” property

  “locatePointer”            LocatePointer.LocatePointer

The locate pointer object

The “xdndHandler” property

  “xdndHandler”              XdndHandler.XdndHandler

The X DND handler

The “statusIconDispatcher” property

  “statusIconDispatcher”     StatusIconDispatcher.StatusIconDispatcher

The status icon dispatcher

The “virtualKeyboard” property

  “virtualKeyboard”          VirtualKeyboard.Keyboard

The keyboard object

The “layoutManager” property

  “layoutManager”            Layout.LayoutManager

The layout manager.

All actors that are part of the Cinnamon UI ar handled by the layout manager, which will determine when to show and hide the actors etc.

The “panelManager” property

  “panelManager”             Panel.PanelManager

The panel manager.

This is responsible for handling events relating to panels, eg. showing all panels.

The “themeManager” property

  “themeManager”             ThemeManager.ThemeManager

The theme manager

The “soundManager” property

  “soundManager”             SoundManager.SoundManager

The sound manager

The “settingsManager” property

  “settingsManager”          Settings.SettingsManager

The manager of the xlet Settings API

The “backgroundManager” property

  “backgroundManager”        BackgroundManager.BackgroundManager

The background manager.

This listens to changes in the GNOME background settings and mirrors them to the Cinnamon settings, since many applications have a "Set background" button that modifies the GNOME background settings.

The “slideshowManager” property

  “slideshowManager”         SlideshowManager.SlideshowManager

The slideshow manager.

This is responsible for managing the background slideshow, since the background "slideshow" is created by cinnamon changing the active background gsetting every x minutes.

The “keybindingManager” property

  “keybindingManager”        KeybindingManager.KeybindingManager

The keybinding manager

The “systrayManager” property

  “systrayManager”           Systray.SystrayManager

The systray manager

The “osdWindow” property

  “osdWindow”                OsdWindow.OsdWindow

Osd window that pops up when you use media keys.

The “tracker” property

  “tracker”                  Cinnamon.WindowTracker

The window tracker

The “workspace_names” property

  “workspace_names”          array

Names of workspace

The “deskletContainer” property

  “deskletContainer”         DeskletManager.DeskletContainer

The desklet container.

This is a container that contains all the desklets as childs. Its actor is put between global.bottom_window_group and global.uiGroup.

The “software_rendering” property

  “software_rendering”       boolean

Whether software rendering is used

The “animations_enabled” property

  “animations_enabled”       boolean

Whether any effects or animations should be used.

The “popup_rendering_actor” property

  “popup_rendering_actor”    Clutter.Actor

The popup actor that is in the process of rendering

The “xlet_startup_error” property

  “xlet_startup_error”       boolean

Whether there was at least one xlet that did not manage to load