Does Xcode support regions?

Question

Does Xcode support anything akin to Visual Studio style #region directives for arbitrary code folding?

Briant

Answer 1

No, you can only fold code on various defined scoping levels in Xcode.

You can use little tricks to make navigating via the function menu easier, though.

#pragma mark

Allows you to create a grouping where the label following mark will show up in the function menu. If the label is a hyphen, a separator is inserted into the function menu.

Also, the following labels in comments will show up in the function menu:

// MARK:
// TODO:
// FIXME:
// !!!:
// ???:

Obviously since #pragma mark is not really portable, if you're building a portable application and need it to work with a compiler that doesn't just ignore #pragma directives that it doesn't understand, the comment-style mark is a decent alternative.

Glidebomb

The C standard says a conforming implementation must ignore #pragma directives that it doesn't understand. Of course, every #pragma directive that does not start with STDC is implementation-defined anyway, so still not that portable. – Stableboy

Somebody should definitely make an XCode plugin for custom code folding. That would be very useful :) – Galleywest

Answer 2

I am going to hell for this but here goes:

At the top of a given file, put

#define FOLD 1

Wherever you want to fold something, wrap it in an if block like so:

if(FOLD) {
 // your code to hide
 // more code
}

That will let you fold it away out of sight.

Egalitarian

It would be a good idea, but you can only put an if statement inside a function scope. You can't wrap struct, enum and function definitions in an if. – Prefecture

Another +1 for most IDEs not supporting preprocessing directive for code folding, -1 for i think this is because they want to force us for method usage rather than folding, +1 for this would be awesome for method grouping, -1 for i think this is because they want to force us to use classes. So we are even :P. Excuse my ignorance, if there exist any. – Moor

Why bother with the define? Why not just if (true)? – Tradespeople

@Tradespeople I imagine because he doesn't want to go through changing all the trues when he wants to actually read his code again – Marimaria

Answer 3

That won't work in the place you want it most, that is, around groups of functions or methods.

It may be useful inside a long, linear method with no internal conditionals or loops, but such methods aren't common in general Mac OS X UI code, though if you're writing some big numeric or graphics-crunching code it could help group things.

And the if(fold) is entirely superfluous. Just use the braces inside a method or function and Xcode will fold them.

Mab

It's surprising that so many people are unaware that you can introduce scope without branching. – Stableboy

Answer 4

Try this way :

//region title1
{
    //region Subtitl1
    {

    }
    //region Subtitl2
    {

    }
}

It can do like that :

Affluent

Answer 5

A useful option in XCode 12 (maybe before), is an option in preferences "Code Folding Ribbon"

When you check it, the source code looks like this

When you hover the mouse over this ribbon, you get foldable regions based on brackets, like this

When you click the Ribbon, it folds the bracket region, like this

Its not as the regions in Visual Studio, where you can place them wherever you want, but they're good enough to tidy up your code files.

Karalee

Answer 6

Without support for .Net style regions, being able to collapse all your functions at the same time is the next best thing.

command-option-shift-left arrow to collapse all.

command-option-shift-right arrow to expand all.

Xcode will remember the last state of collapsed functions.

Angloindian

NB: in Xcode 8, to make Xcode remember your folding, ensure your project format is set to Xcode 8.0-compatible. – Porcine

Answer 7

To answer your question...No. And It drives me nuts.

If you have the opportunity/ability you can use AppCode for this. I've been using it for a few years and it usually beats Xcode in many areas.

Also I specifically use AppCode because of these features:

• Ability to use regions
• Searching classes, text and usages is MUCH faster.
• Refactoring is also faster.
• Cleaner and more customizable UI.
• Tabs are handled (in my opinion) much better than in Xcode.
• FOLDING. You can actually change what levels of folding you want. Why Apple thought there should be no quick-key to fold extensions is beyond me. And fold ribbons? Really Apple? Yes they're pretty and all but most professionals use hotkeys for everything.
• Better GIT integration.
• Support for live updates in SwiftUI
• If you use other Jetbrains IDE's like PyCharm or Android Studio the UI is exactly the same.

Some downsides of AppCode:

• Some things that work in Xcode aren't supported
  • Visual #colorLiteral(). When using them they don't show a color picker.
  • No Storyboard support. Annoying to have to open up Xcode. If you write your UI in code this is a moot point.
• Editing .plist files isn't as nice. Doable, but not nice.
• Initial indexing can take a while.
• Cost. But I would argue the time savings in just navigation will compensate for this.

Kind of a lot for a simple question but I think it's nice having alternatives.

Transform

Answer 8

Put your desired code inside brackets { }, and it will become a folding zone.

But you have to keep in mind that brackets also define variables scope, so this code should not have variables declarations which will be used outside these brackets.

Reflate

Answer 9

One nice solution I just found:

Put your project into one big namespace. Close and reopen this namespace for the individual sections of your source file:

namespace myproj { // members of class MyClassA

void MyClassA::dosomething()
{
}

void MyClassA::dosomethingelse()
{
}

} // members of class MyClassA
namespace myproj { // members of MyClassB

void MyClassB::dosomething()
{
}

void MyClassB::dosomethingelse()
{
}

} // members of MyClassB

Flier

That solution, if at all viable, would only work for C++ as Objective-C does not support namespaces – Victuals